Application module: Numeric expression ISO/TS 10303-1526:2018-11(E)
© ISO

Cover page
Table of contents
Copyright
Foreword
Introduction
1 Scope
2 Normative references
3 Terms, definitions and abbreviated terms
    3.1 Terms and definitions
    3.2 Abbreviated terms

4 Information requirements
   4.1 Required AM ARMs
   4.2 ARM entity definitions
   4.3 ARM function definitions
5 Module interpreted model
   5.1 Mapping specification
   5.2 MIM EXPRESS short listing

A MIM short names
B Information object registration
C ARM EXPRESS-G   EXPRESS-G
D MIM EXPRESS-G   EXPRESS-G
E Computer interpretable listings
F Change history
Bibliography
Index

4 Information requirements

This clause specifies the information requirements for the Numeric expression application module. The information requirements are specified as the Application Reference Model (ARM) of this application module.

NOTE 1  A graphical representation of the information requirements is given in Annex C.

NOTE 2  The mapping specification is specified in 5.1. It shows how the information requirements are met by using common resources and constructs defined or imported in the MIM schema of this application module.

This clause defines the information requirements to which implementations shall conform using the EXPRESS language as defined in ISO 10303-11. The following begins the Numeric_expression_arm schema and identifies the necessary external references.

The Numeric_expression module represents a simple expression. It can represent a numeric or boolean expression.

EXPRESS specification:

*)
SCHEMA Numeric_expression_arm;
(*

4.1 Required AM ARMs

The following EXPRESS interface statements specify the elements imported from the ARMs of other application modules.

EXPRESS specification:

*)
USE FROM Expression_arm;    --  ISO/TS 10303-1342

USE FROM Generic_expression_arm;    --  ISO/TS 10303-1341

USE FROM Numeric_function_arm;    --  ISO/TS 10303-1346
(*

NOTE 1   The schemas referenced above are specified in the following part of ISO 10303:

Expression_arm ISO/TS 10303-1342
Generic_expression_arm ISO/TS 10303-1341
Numeric_function_arm ISO/TS 10303-1346

NOTE 2   See Annex C, Figures C.1, C.2, C.3and C.4 for a graphical representation of this schema.

4.2 ARM entity definitions

This subclause specifies the ARM entities for this module. Each ARM application entity is an atomic element that embodies a unique application concept and contains attributes specifying the data elements of the entity. The ARM entities and definitions are specified below.

4.2.1 And_expression   EXPRESS-GMapping table

An And_expression is a type of Multiple_arity_boolean_expression. It carries the semantics of the 'AND' operator defined in ISO 10303-11 and uses its associativity property to handle multiple arity.

NOTE    The AND operator requires at least two Boolean expressions and evaluates to a Boolean value that is the conjunction of the two operands.

EXPRESS specification:

*)
ENTITY And_expression
  SUBTYPE OF (Multiple_arity_boolean_expression);
END_ENTITY;
(*

4.2.2 Binary_boolean_expression   EXPRESS-GMapping table

A Binary_boolean_expression is a type of Boolean_expression and Binary_generic_expression. It shall be one of a Xor_expression or an Equals_expression. It is a binary operator of which the range is the BOOLEAN data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Binary_boolean_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Xor_expression,
                                Equals_expression))
  SUBTYPE OF (Boolean_expression, Binary_generic_expression);
END_ENTITY;
(*

4.2.3 Binary_numeric_expression   EXPRESS-GMapping table

A Binary_numeric_expression is a type of Numeric_expression and Binary_generic_expression. It shall be a subtype of either a Minus_expression, a Div_expression, a Mod_expression, a Slash_expression and a Power_expression. It is a binary operator of which the range is the BOOLEAN data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Binary_numeric_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Minus_expression,
                                Div_expression,
                                Mod_expression,
                                Slash_expression,
                                Power_expression))
  SUBTYPE OF (Numeric_expression, Binary_generic_expression);
  SELF\Binary_generic_expression.operands : LIST[2:2] OF Numeric_expression;
END_ENTITY;
(*

Attribute definitions:

operands: a list containing the two parameters of the binary operator.

4.2.4 Boolean_defined_function   EXPRESS-GMapping table

A Boolean_defined_function is a type of Defined_function and Boolean_expression. It is any application-defined operator of which the range is the BOOLEAN data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Boolean_defined_function
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Defined_function, Boolean_expression);
END_ENTITY;
(*

4.2.5 Boolean_expression   EXPRESS-GMapping table

A Boolean_expression is a type of Expression for which the range is the BOOLEAN data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Boolean_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Simple_boolean_expression,
                                Unary_boolean_expression,
                                Binary_boolean_expression,
                                Multiple_arity_boolean_expression,
                                Comparison_expression,
                                Boolean_defined_function,
                                Interval_expression))
  SUBTYPE OF (Expression);
END_ENTITY;
(*

4.2.6 Boolean_literal   EXPRESS-GMapping table

A Boolean_literal is a type of Simple_boolean_expression and Generic_literal. It is an EXPRESS BOOLEAN literal.

NOTE 1   The EXPRESS Boolean data type has as its domain the set containing the two literals TRUE and FALSE.

EXPRESS specification:

*)
ENTITY Boolean_literal
  SUBTYPE OF (Simple_boolean_expression, Generic_literal);
  the_value : BOOLEAN;
END_ENTITY;
(*

Attribute definitions:

the_value: a BOOLEAN literal value.

NOTE 2   The EXPRESS Boolean data type has as its domain the set containing the two literals TRUE and FALSE.

4.2.7 Boolean_variable   EXPRESS-GMapping table

A Boolean_variable is a type of Simple_boolean_expression and Variable. It is a variable that stands for a Boolean value.

EXPRESS specification:

*)
ENTITY Boolean_variable
  SUBTYPE OF (Simple_boolean_expression, Variable);
END_ENTITY;
(*

4.2.8 Comparison_equal   EXPRESS-GMapping table

A Comparison_equal is a type of Comparison_expression carries the semantics of the value equal ('=') operator defined in ISO 10303-11 restricted to the NUMBER, BOOLEAN and STRING EXPRESS data types. Both operands shall have the same data type.

NOTE    The Comparison_equal evaluates to TRUE if the two operands evaluate to the same value.

EXPRESS specification:

*)
ENTITY Comparison_equal
  SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*

4.2.9 Comparison_expression   EXPRESS-GMapping table

A Comparison_expression is a type of Boolean_expression and a Binary_generic_expression. It shall be one of a Comparison_equal, a Comparison_greater, a Comparison_greater_equal, a Comparison_less, a Comparison_less_equal, or a Comparison_not_equal. . The Comparison_expression expressions carry the semantics of the different value comparison operators defined in ISO 10303-11 restricted to the NUMBER, BOOLEAN and STRING EXPRESS data types. Both operands shall have the same data type.

EXPRESS specification:

*)
ENTITY Comparison_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Comparison_equal,
                                Comparison_greater,
                                Comparison_greater_equal,
                                Comparison_less,
                                Comparison_less_equal,
                                Comparison_not_equal))
  SUBTYPE OF (Boolean_expression, Binary_generic_expression);
  SELF\Binary_generic_expression.operands : LIST[2:2] OF Expression;
WHERE
  WR1: ( ('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND ('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2]))) OR (('NUMERIC_EXPRESSION_ARM.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND ('NUMERIC_EXPRESSION_ARM.BOOLEAN_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2]))) OR (('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[1])) AND ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF(SELF\Binary_generic_expression.operands[2])));
END_ENTITY;
(*

Attribute definitions:

operands: a list of Generic_expressions that contains the expressions to be compared.

Formal propositions:

WR1: the operands of the Comparison_expression shall be compatible in type.

4.2.10 Comparison_greater   EXPRESS-GMapping table

A Comparison_greater is a type of Comparison_expression. It carries the semantics of the greater than ('>') operator defined in of ISO 10303-11 restricted to the NUMBER, BOOLEAN and STRING EXPRESS data types. Both operands shall have the same data type.

NOTE    The Comparison_greater evaluates to TRUE if the first operand evaluates to a value greater than the second operand. The relevant orders are:

EXPRESS specification:

*)
ENTITY Comparison_greater
  SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*

4.2.11 Comparison_greater_equal   EXPRESS-GMapping table

A Comparison_greater_equal is a type of Comparison_expression. It carries the semantics of the greater than or equal ('>=') operator defined in of ISO 10303-11 restricted to the NUMBER, BOOLEAN and STRING EXPRESS data types. Both operands shall have the same data type.

NOTE    The Comparison_greater_equal evaluates to TRUE if the first operand evaluates to a value greater than or equal to the second operand. The relevant orders are:

EXPRESS specification:

*)
ENTITY Comparison_greater_equal
  SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*

4.2.12 Comparison_less   EXPRESS-GMapping table

A Comparison_less is a type of Comparison_expression. It carries the semantics of the less than ('<') operator defined in ISO 10303-11 restricted to the NUMBER, BOOLEAN and STRING EXPRESS data types. Both operands shall have the same data type.

NOTE    The Comparison_less evaluates to TRUE if the first operand evaluates to a value less than the second operand. The relevant orders are:

EXPRESS specification:

*)
ENTITY Comparison_less
  SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*

4.2.13 Comparison_less_equal   EXPRESS-GMapping table

A Comparison_less_equal is a type of Comparison_expression. It carries the semantics of the EXPRESS less than or equal ('<=') operator defined in ISO 10303-11 restricted to the NUMBER, BOOLEAN and STRING EXPRESS data types. Both operands shall have the same data type.

NOTE    The Comparison_less_equal evaluates to TRUE if the first operand evaluates to a value less than or equal to the second operand. The relevant orders are:

EXPRESS specification:

*)
ENTITY Comparison_less_equal
  SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*

4.2.14 Comparison_not_equal   EXPRESS-GMapping table

A Comparison_not_equal is a type of Comparison_expression. It carries the semantics of the value not equal ('<>') operator defined in ISO 10303-11 restricted to the NUMBER, BOOLEAN and STRING EXPRESS data types. Both operands shall have the same data type.

NOTE    The Comparison_not_equal evaluates to TRUE if the first operand evaluates to a value different from the second operand. The relevant orders are:

EXPRESS specification:

*)
ENTITY Comparison_not_equal
  SUBTYPE OF (Comparison_expression);
END_ENTITY;
(*

4.2.15 Defined_function   EXPRESS-GMapping table

A Defined_function is a strongly typed function intended to be subtyped in the information models that use the iso13584_expressions_schema.

EXPRESS specification:

*)
ENTITY Defined_function
  ABSTRACT SUPERTYPE ;
END_ENTITY;
(*

4.2.16 Div_expression   EXPRESS-GMapping table

A Div_expression is a type of Binary_numeric_expression. It carries the semantics of the EXPRESS 'DIV' operator, defined in ISO 10303-11, on NUMBER data type.

NOTE    The Div_expression is an expression which evaluates to the integer division of its operands. In the iso13584_expressions_schema, all these operands shall evaluate to a number in the number data type domain. The result is an integer number. If either operand is of data type REAL, it is truncated to an INTEGER before the operation, i.e. any fractional part is lost.

EXPRESS specification:

*)
ENTITY Div_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*

4.2.17 Equals_expression   EXPRESS-GMapping table

An Equals_expression is a type of Binary_boolean_expression. It carries the semantics of the ':=:' instance equal operator defined in ISO 10303-11, the domain of which is entities of data type Generic_expression.

NOTE    The entity instance equality operator accepts two compatible instance values that are Generic_expression and evaluates to a Boolean value. In the context of the iso13584_expressions_schema the two Generic_expressions instance values are compatible either if their data types are the same, or if one data type is a subtype of the other one.

EXPRESS specification:

*)
ENTITY Equals_expression
  SUBTYPE OF (Binary_boolean_expression);
END_ENTITY;
(*

4.2.18 Expression   EXPRESS-GMapping table

An Expression is a type of Generic_expression. It is restricted to numeric, boolean, or string domain of values.

EXPRESS specification:

*)
ENTITY Expression
  ABSTRACT SUPERTYPE OF (ONEOF (Numeric_expression,
                                Boolean_expression))
  SUBTYPE OF (Generic_expression);
END_ENTITY;
(*

4.2.19 Int_literal   EXPRESS-GMapping table

An Int_literal is a type of Literal_number. It is an EXPRESS INTEGER literal.

NOTE    An EXPRESS INTEGER literal represents an integer VALUE that is composed of one or more digits.

EXPRESS specification:

*)
ENTITY Int_literal
  SUBTYPE OF (Literal_number);
  SELF\Literal_number.the_value : INTEGER;
END_ENTITY;
(*

Attribute definitions:

the_value: an INTEGER literal value.

4.2.20 Int_numeric_variable   EXPRESS-GMapping table

An Int_numeric_variable is a type of Numeric_variable. It is a variable that stands for an integer value.

EXPRESS specification:

*)
ENTITY Int_numeric_variable
  SUBTYPE OF (Numeric_variable);
END_ENTITY;
(*

4.2.21 Interval_expression   EXPRESS-GMapping table

An Interval_expression is a type of Boolean_expression and Multiple_arity_generic_expression. It carries the semantics of the interval expression defined in ISO 10303-11 restricted to the NUMBER, BOOLEAN and STRING EXPRESS data types. Both operands shall have the same data type.

NOTE    An Interval_expression expression tests whether or not a value falls within a given interval. It evaluates to TRUE if interval_low < = interval_item < = interval_high. The relevant orders are:

EXPRESS specification:

*)
ENTITY Interval_expression
  SUBTYPE OF (Boolean_expression, Multiple_arity_generic_expression);
DERIVE
  interval_low : Generic_expression := SELF\Multiple_arity_generic_expression.operands[1];
  interval_item : Generic_expression := SELF\Multiple_arity_generic_expression.operands[2];
  interval_high : Generic_expression := SELF\Multiple_arity_generic_expression.operands[3];
WHERE
  WR1: ('NUMERIC_EXPRESSION_ARM.EXPRESSION' IN TYPEOF(interval_low)) AND ('NUMERIC_EXPRESSION_ARM.EXPRESSION' IN TYPEOF(interval_item) ) AND ('NUMERIC_EXPRESSION_ARM.EXPRESSION' IN TYPEOF(interval_high));
  WR2: (('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF (SELF.Interval_low)) AND ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF (SELF.Interval_high)) AND ('EXPRESSION_ARM.STRING_EXPRESSION' IN TYPEOF (SELF.Interval_item))) OR (('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_low)) AND ('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_item)) AND ('NUMERIC_EXPRESSION_ARM.NUMERIC_EXPRESSION' IN TYPEOF(SELF.Interval_high)));
END_ENTITY;
(*

Attribute definitions:

interval_low: the interval_low operand of the interval expression (see 12.2.4 of ISO 10303-11).

interval_item: the interval_item operand of the interval expression (see 12.2.4 of ISO 10303-11).

interval_high: the interval_high operand of the interval expression (see 12.2.4 of ISO 10303-11).

Formal propositions:

WR1: the data type of the operands shall be Expression.

WR2: the types of the Expression to be compared in the Interval_expression shall evaluate to comparable Expression.

4.2.22 Literal_number   EXPRESS-GMapping table

A Literal_number is a type of Simple_numeric_expression and Generic_literal. It shall be a subtype of either an Int_literal and Real_literal. It is an EXPRESS NUMBER literal . A Literal_number may be either an integer literal or a real literal.

NOTE    The EXPRESS NUMBER data type has the numeric values as domain

EXPRESS specification:

*)
ENTITY Literal_number
  ABSTRACT SUPERTYPE OF (ONEOF (Int_literal,
                                Real_literal))
  SUBTYPE OF (Simple_numeric_expression, Generic_literal);
  the_value : NUMBER;
END_ENTITY;
(*

Attribute definitions:

the_value: a NUMBER literal value.

4.2.23 Minus_expression   EXPRESS-GMapping table

A Minus_expression is a type of Numeric_expression. It carries the semantics of the '-' operator, defined in ISO 10303-11, on NUMBER data type.

NOTE    The Minus_expression is an expression which evaluates to the difference of its operands. In the iso13584_expressions_schema, all these operands shall evaluate to a number in the number data type domain.

EXPRESS specification:

*)
ENTITY Minus_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*

4.2.24 Mod_expression   EXPRESS-GMapping table

A Mod_expression is a type of Binary_numeric_expression. It carries the semantics of the EXPRESS 'MOD' operator, defined in ISO 10303-11, on NUMBER data type.

NOTE    The Mod_expression is an expression which evaluates to the first argument value modulo operation of the second argument value. Its operands shall evaluate to a number in the number data type domain. The result is an integer number. If either operand is of data type REAL, it is truncated to an INTEGER before the operation, i.e. any fractional part is lost.

EXPRESS specification:

*)
ENTITY Mod_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*

4.2.25 Mult_expression   EXPRESS-GMapping table

A Mult_expression is a type of Multiple_arity_numeric_expression. It carries the semantics of the '*' operator, defined in ISO 10303-11, on NUMBER data type.

NOTE    The Mult_expression is an expression which evaluates to the difference of its operands. In the iso13584_expressions_schema, all these operands shall evaluate to a number in the number data type domain.

EXPRESS specification:

*)
ENTITY Mult_expression
  SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;
(*

4.2.26 Multiple_arity_boolean_expression   EXPRESS-GMapping table

A Multiple_arity_boolean_expression is a type of Boolean_expression and Multiple_arity_generic_expression. It shall be one of And_expression or an Or_expression. It is a multiple-arity operator for which the range is the same as the EXPRESS BOOLEAN data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Multiple_arity_boolean_expression
  ABSTRACT SUPERTYPE OF (ONEOF (And_expression,
                                Or_expression))
  SUBTYPE OF (Boolean_expression, Multiple_arity_generic_expression);
  SELF\Multiple_arity_generic_expression.operands : LIST[2:?] OF Boolean_expression;
END_ENTITY;
(*

Attribute definitions:

operands: the occurrences of Boolean_expression that represents the parameters of the m-arity operator.

4.2.27 Multiple_arity_function_call   EXPRESS-GMapping table

A Multiple_arity_function_call is a type of Multiple_arity_numeric_expression. It is a multiple-arity operator on NUMBER data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Multiple_arity_function_call
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;
(*

4.2.28 Multiple_arity_numeric_expression   EXPRESS-GMapping table

A Multiple_arity_numeric_expression is a type of Numeric_expression and Multiple_arity_generic_expression. It shall be a subtype of either a Plus_expression, Mult_expression and Multiple_arity_function_call. A Multiple_arity_numeric_expression is a multiple arity operator whose range is the NUMBER data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Multiple_arity_numeric_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Plus_expression,
                                Mult_expression,
                                Multiple_arity_function_call))
  SUBTYPE OF (Numeric_expression, Multiple_arity_generic_expression);
  SELF\Multiple_arity_generic_expression.operands : LIST[2:?] OF Numeric_expression;
END_ENTITY;
(*

Attribute definitions:

operands: a list containing the parameters of the multiple arity operator. The length of this list is equal to the arity of the operator.

4.2.29 Not_expression   EXPRESS-GMapping table

A Not_expression is a type of Unary_boolean_expression. It carries the semantics of the 'NOT' on Boolean data type operator defined in ISO 10303-11.

NOTE    The NOT operator requires one Boolean operand and evaluates to a Boolean value.

EXPRESS specification:

*)
ENTITY Not_expression
  SUBTYPE OF (Unary_boolean_expression);
  SELF\Unary_generic_expression.operand : Boolean_expression;
END_ENTITY;
(*

Attribute definitions:

operand: the Boolean_expression that represents the operand of the 'NOT' operator.

4.2.30 Numeric_expression   EXPRESS-GMapping table

A Numeric_expression is a type of Expression. A Numeric_expression is an expression of which the range is the NUMBER data type defined in 8.1.1 of ISO 10303-11.

EXPRESS specification:

*)
ENTITY Numeric_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Expression);
DERIVE
  is_int : BOOLEAN := Is_int_expr (SELF);
  sql_mappable : BOOLEAN := Is_sql_mappable (SELF);
END_ENTITY;
(*

Attribute definitions:

is_int: a Boolean attribute that indicates if an expression evaluates to integer or not.

sql_mappable: a Boolean attribute that indicates if an expression is mappable to the SQL, defined in ISO/IEC 9075:1992, query language.

4.2.31 Numeric_variable   EXPRESS-GMapping table

A Numeric_variable is a type of Simple_numeric_expression and Variable. It is a variable that stands for a number value.

EXPRESS specification:

*)
ENTITY Numeric_variable
  SUPERTYPE OF (ONEOF (Int_numeric_variable,
                       Real_numeric_variable))
  SUBTYPE OF (Simple_numeric_expression, Variable);
WHERE
  WR1: ('EXPRESSION_ARM.INT_NUMERIC_VARIABLE' IN TYPEOF(SELF) ) OR ('EXPRESSION_ARM.REAL_NUMERIC_VARIABLE' IN TYPEOF(SELF) );
END_ENTITY;
(*

Formal propositions:

WR1: A Numeric_variable can only be a real variable or an integer variable.

4.2.32 Or_expression   EXPRESS-GMapping table

An Or_expression is a type of Multiple_arity_boolean_expression entity carries the semantics of the 'OR' operator defined in ISO 10303-11 and uses its associativity property to handle multiple arity.

NOTE    The OR operator requires at least two Boolean expressions and evaluates to a Boolean value that is the inclusive disjunction of the two operands.

EXPRESS specification:

*)
ENTITY Or_expression
  SUBTYPE OF (Multiple_arity_boolean_expression);
END_ENTITY;
(*

4.2.33 Plus_expression   EXPRESS-GMapping table

A Plus_expression is a type of Multiple_arity_numeric_expression. It carries the semantics of the '+' operator, defined in ISO 10303-11, on NUMBER data type.

NOTE    The Plus_expression is an expression which evaluates to the sum of all its operands. In the iso13584_expressions_schema, all these operands shall evaluate to a number in the number data type domain.

EXPRESS specification:

*)
ENTITY Plus_expression
  SUBTYPE OF (Multiple_arity_numeric_expression);
END_ENTITY;
(*

4.2.34 Power_expression   EXPRESS-GMapping table

A Power_expression is a type of Binary_numeric_expression. It carries the semantics of the EXPRESS '**' operator, defined in ISO 10303-11, on NUMBER data type

NOTE    The Power_expression is an expression which evaluates to the first argument value modulo operation of the second argument value. Its operands shall evaluate to a number in the number data type domain. The result is an integer number. If either operand is of data type REAL, it is truncated to an INTEGER before the operation, i.e. any fractional part is lost.

EXPRESS specification:

*)
ENTITY Power_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*

4.2.35 Real_literal   EXPRESS-GMapping table

A Real_literal is a type of Literal_number. It is an EXPRESS REAL literal.

NOTE    An EXPRESS REAL literal represents a real VALUE that is composed of a mantissa and an optional exponent; the mantissa shall include a decimal point.

EXPRESS specification:

*)
ENTITY Real_literal
  SUBTYPE OF (Literal_number);
  SELF\Literal_number.the_value : REAL;
END_ENTITY;
(*

Attribute definitions:

the_value: a REAL literal value.

4.2.36 Real_numeric_variable   EXPRESS-GMapping table

A Real_numeric_variable is a type of Numeric_variable. It is a variable that stands for a real value.

EXPRESS specification:

*)
ENTITY Real_numeric_variable
  SUBTYPE OF (Numeric_variable);
END_ENTITY;
(*

4.2.37 Simple_boolean_expression   EXPRESS-GMapping table

A Simple_boolean_expression is a type of Boolean_expression and Simple_generic_expression. It shall be one of a Boolean_literal, or a Boolean_variable and it is an unary operator for which the range is BOOLEAN, such a data type being defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Simple_boolean_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Boolean_literal,
                                Boolean_variable))
  SUBTYPE OF (Boolean_expression, Simple_generic_expression);
END_ENTITY;
(*

4.2.38 Simple_numeric_expression   EXPRESS-GMapping table

A Simple_numeric_expression is a type of Numeric_expression and Simple_generic_expression. It shall be a subtype of either a Literal_number and Numeric_variable. It is either a numeric literal or a numeric variable.

EXPRESS specification:

*)
ENTITY Simple_numeric_expression
  ABSTRACT SUPERTYPE OF (ONEOF (Literal_number,
                                Numeric_variable))
  SUBTYPE OF (Numeric_expression, Simple_generic_expression);
END_ENTITY;
(*

4.2.39 Slash_expression   EXPRESS-GMapping table

A Slash_expression is a type of Binary_numeric_expression. It carries the semantics of the EXPRESS '/' operator, defined in ISO 10303-11, on NUMBER data type.

NOTE    The Slash_expression is an expression which evaluates to the first argument value modulo operation of the second argument value. Its operands shall evaluate to a number in the number data type domain. The result is an integer number. If either operand is of data type REAL, it is truncated to an INTEGER before the operation, i.e. any fractional part is lost.

EXPRESS specification:

*)
ENTITY Slash_expression
  SUBTYPE OF (Binary_numeric_expression);
END_ENTITY;
(*

4.2.40 Unary_boolean_expression   EXPRESS-GMapping table

A Unary_boolean_expression is a type of Boolean_expression and Unary_generic_expression. It shall be one of a Not_expression, or an Odd_function. It is an unary operator for which the range is the BOOLEAN data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Unary_boolean_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Boolean_expression, Unary_generic_expression);
END_ENTITY;
(*

4.2.41 Unary_numeric_expression   EXPRESS-GMapping table

A Unary_numeric_expression is a type of Numeric_expression and Unary_generic_expression. It is an unary operator whose range is the NUMBER data type defined in ISO 10303-11.

EXPRESS specification:

*)
ENTITY Unary_numeric_expression
  ABSTRACT SUPERTYPE
  SUBTYPE OF (Numeric_expression, Unary_generic_expression);
  SELF\Unary_generic_expression.operand : Numeric_expression;
END_ENTITY;
(*

Attribute definitions:

operand: a Numeric_expression that represents the parameter of the unary operator.

4.2.42 Xor_expression   EXPRESS-GMapping table

A Xor_expression is a type of Binary_boolean_expression. It carries the semantics of the 'XOR' operator defined in ISO 10303-11.

NOTE    The XOR operator requires two Boolean operands and evaluates to a Boolean value that is the exclusive disjunction of the two operands.

EXPRESS specification:

*)
ENTITY Xor_expression
  SUBTYPE OF (Binary_boolean_expression);
  SELF\Binary_generic_expression.operands : LIST[2:2] OF Boolean_expression;
END_ENTITY;
(*

Attribute definitions:

operands: the two Binary_boolean_expression operands of the XOR operator that shall be Binary_boolean_expression.

4.3 ARM function definitions

This subclause specifies the ARM functions for this module. The ARM functions and definitions are specified below.

4.3.1 Is_int_expr

The Is_int_expr function checks if a syntactically correct expression evaluates to an integer value or not.

EXPRESS specification:

*)
FUNCTION Is_int_expr (arg : Numeric_expression) : BOOLEAN;
LOCAL
	i: INTEGER;
END_LOCAL;

IF 'NUMERIC_EXPRESSION_ARM.INT_LITERAL' IN TYPEOF(arg) 
THEN 
	RETURN (TRUE); 
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.REAL_LITERAL' IN TYPEOF(arg) 
THEN 
	RETURN (FALSE); 
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.INT_NUMERIC_VARIABLE' IN TYPEOF(arg) 
THEN 
	RETURN (TRUE); 
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.REAL_NUMERIC_VARIABLE' IN TYPEOF(arg) 
THEN 
	RETURN (FALSE); 
END_IF;
IF 'ELEMENTARY_FUNCTION_ARM.ABS_FUNCTION' IN TYPEOF(arg) 
THEN 
	RETURN (Is_int_expr(arg\Unary_numeric_expression.operand));
END_IF;
IF 'ELEMENTARY_FUNCTION_ARM.MINUS_FUNCTION' IN TYPEOF(arg) 
THEN 
	RETURN (Is_int_expr(arg\Unary_numeric_expression.operand)); 
END_IF;
IF ('ELEMENTARY_FUNCTION_ARM.SIN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.COS_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.TAN_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.ASIN_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.ACOS_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.ATAN_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.EXP_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.LOG_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.LOG2_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.LOG10_FUNCTION' IN TYPEOF(arg))
	OR ('ELEMENTARY_FUNCTION_ARM.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg))
THEN 
	RETURN (FALSE);
END_IF;
IF 	('NUMERIC_EXPRESSION_ARM.PLUS_EXPRESSION' IN TYPEOF(arg))
		OR ('NUMERIC_EXPRESSION_ARM.MULT_EXPRESSION' IN TYPEOF(arg))
		OR ('ELEMENTARY_FUNCTION_ARM.MAXIMUM_FUNCTION' IN TYPEOF(arg))
		OR ('ELEMENTARY_FUNCTION_ARM.MINIMUM_FUNCTION' IN TYPEOF(arg)) 
THEN 
	REPEAT i :=1 TO SIZEOF (
			arg\Multiple_arity_numeric_expression.operands);
	IF NOT 
		Is_int_expr(arg\Multiple_arity_numeric_expression.operands[i]) 
	THEN 
		RETURN (FALSE);
	END_IF;
	END_REPEAT;
	RETURN (TRUE);
END_IF;
IF 	('NUMERIC_EXPRESSION_ARM.MINUS_EXPRESSION' IN TYPEOF(arg))
		OR ('NUMERIC_EXPRESSION_ARM.POWER_EXPRESSION' 
								IN TYPEOF(arg))
THEN 
	RETURN (Is_int_expr(arg\Binary_numeric_expression.operands[1])
		AND Is_int_expr(arg\Binary_numeric_expression.operands[2]));
END_IF;
IF	('NUMERIC_EXPRESSION_ARM.DIV_EXPRESSION' IN TYPEOF(arg))
		OR ('NUMERIC_EXPRESSION_ARM.MOD_EXPRESSION' IN TYPEOF(arg))
THEN 
	RETURN(TRUE);	
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.SLASH_EXPRESSION' IN TYPEOF(arg) 
THEN 
	RETURN (FALSE); 	
END_IF;
IF 'NUMERIC_FUNCTION_ARM.LENGTH_FUNCTION' IN TYPEOF(arg) 
THEN 
	RETURN (TRUE); 
END_IF;
IF 'NUMERIC_FUNCTION_ARM.FUNCTION_PARAMETER_VALUE' IN TYPEOF(arg) 
THEN 
	IF 'NUMERIC_FUNCTION_ARM.INT_VALUE_FUNCTION' IN TYPEOF(arg) 
	THEN 
		RETURN (TRUE); 
	ELSE 
		RETURN (FALSE); 
	END_IF;
END_IF;
IF 'ELEMENTARY_FUNCTION_ARM.INTEGER_DEFINED_FUNCTION' IN TYPEOF(arg)
THEN 
	RETURN(TRUE) ;
END_IF;
IF'ELEMENTARY_FUNCTION_ARM.REAL_DEFINED_FUNCTION' IN TYPEOF(arg) 
THEN 
	RETURN(FALSE) ;
END_IF ;
IF 'NUMERIC_EXPRESSION_ARM.BOOLEAN_DEFINED_FUNCTION' IN TYPEOF(arg)
THEN 
	RETURN(FALSE) ;
END_IF ;
IF 'EXPRESSION_ARM.STRING_DEFINED_FUNCTION' IN TYPEOF(arg)
THEN 
	RETURN (FALSE) ;
END_IF ;

RETURN (FALSE);
END_FUNCTION;
(*

Argument definitions:

arg: it is a Numeric_expression.

4.3.2 Is_sql_mappable

The Is_sql_mappable function checks if the acyclic graph that represents an expression only contains elements that are mappable to SQL, defined in ISO/IEC 9075:1992.

EXPRESS specification:

*)
FUNCTION Is_sql_mappable (arg : Expression) : BOOLEAN;
LOCAL
	i: INTEGER;
END_LOCAL;

IF 'EXPRESSION_ARM.SIMPLE_NUMERIC_EXPRESSION' IN TYPEOF (arg) 
THEN 
	RETURN (TRUE);
END_IF;
IF 'EXPRESSION_ARM.SQL_MAPPABLE_DEFINED_FUNCTION' IN TYPEOF (arg) 
THEN 
	RETURN (TRUE);
END_IF;
IF 'EXPRESSION_ARM.MINUS_FUNCTION' IN TYPEOF(arg) 
THEN 
	RETURN (Is_sql_mappable(arg\Unary_numeric_expression.operand)); 
END_IF;
IF ('ELEMENTARY_FUNCTION_ARM.ABS_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.SIN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.COS_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.TAN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.ASIN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.ACOS_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.ATAN_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.EXP_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.LOG_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.LOG2_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.LOG10_FUNCTION' IN TYPEOF(arg)) 
	OR ('ELEMENTARY_FUNCTION_ARM.SQUARE_ROOT_FUNCTION' IN TYPEOF(arg)) 
	OR ('NUMERIC_FUNCTION_ARM.FUNCTION_PARAMETER_VALUE' IN TYPEOF(arg)) 
	OR ('NUMERIC_FUNCTION_ARM.LENGTH_FUNCTION' IN TYPEOF(arg))
THEN 
	RETURN (FALSE);
END_IF;
IF ('NUMERIC_EXPRESSION_ARM.PLUS_EXPRESSION' IN TYPEOF(arg)) 
	OR('NUMERIC_EXPRESSION_ARM.MULT_EXPRESSION' IN TYPEOF(arg)) 
	OR('NUMERIC_EXPRESSION_ARM.MAXIMUM_FUNCTION' IN TYPEOF(arg)) 
	OR('NUMERIC_EXPRESSION_ARM.MAXIMUM_FUNCTION' IN TYPEOF(arg)) 
THEN 
	REPEAT i :=1 TO SIZEOF (arg\Multiple_arity_numeric_expression.operands);
		IF NOT Is_sql_mappable(
			arg\Multiple_arity_numeric_expression.operands[i])
		THEN 
			RETURN (FALSE);
		END_IF;
	END_REPEAT;
RETURN (TRUE);
END_IF;
IF ('EXPRESSION_ARM.MINUS_EXPRESSION' IN TYPEOF(arg)) 
	OR ('EXPRESSION_ARM.SLASH_EXPRESSION' IN TYPEOF(arg))
THEN
	RETURN (Is_sql_mappable(arg\Binary_numeric_expression.operands[1])
		AND Is_sql_mappable(arg\Binary_numeric_expression.operands[2]));
END_IF;
IF ('NUMERIC_EXPRESSION_ARM.DIV_EXPRESSION' IN TYPEOF(arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.MOD_EXPRESSION' IN TYPEOF(arg)) 
	OR('NUMERIC_EXPRESSION_ARM.POWER_EXPRESSION' IN TYPEOF(arg))
THEN 
	RETURN (FALSE); 	
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.SIMPLE_BOOLEAN_EXPRESSION' IN TYPEOF (arg) 
THEN 
	RETURN (TRUE);
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.NOT_EXPRESSION' IN TYPEOF (arg) 
THEN 
	RETURN (Is_sql_mappable (arg\UNARY_GENERIC_EXPRESSION.OPERAND));
END_IF;
IF ('NUMERIC_FUNCTION_ARM.ODD_FUNCTION'IN TYPEOF (arg)) 
		OR ('NUMERIC_EXPRESSION_ARM.XOR_EXPRESSION' IN TYPEOF (arg)) 
THEN	
	RETURN (FALSE);
END_IF;
IF ('NUMERIC_EXPRESSION_ARM.AND_EXPRESSION' IN TYPEOF (arg)) 
		OR ('NUMERIC_EXPRESSION_ARM.OR_EXPRESSION' IN TYPEOF (arg)) 
THEN
	REPEAT i:=1 TO SIZEOF (
			arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.OPERANDS);
		IF NOT Is_sql_mappable (
			arg\MULTIPLE_ARITY_BOOLEAN_EXPRESSION.OPERANDS[i]) 
		THEN 
			RETURN (FALSE);
		END_IF;
	END_REPEAT;
	RETURN (TRUE);
END_IF;
IF 'NUMERIC_EXPRESSION_ARM.EQUALS_EXPRESSION' IN TYPEOF (arg) 
THEN
	RETURN(Is_sql_mappable (
			arg\Binary_generic_expression.OPERANDS [1])
		AND Is_sql_mappable(
			arg\Binary_generic_expression.OPERANDS [2]));
END_IF;
IF	('NUMERIC_EXPRESSION_ARM.COMPARISON_EQUAL' IN TYPEOF (arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_GREATER' IN TYPEOF (arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_GREATER_EQUAL' 	IN TYPEOF (arg))
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_LESS' IN TYPEOF (arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_LESS_EQUAL' IN TYPEOF (arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.COMPARISON_NOT_EQUAL' IN TYPEOF (arg)) 
	OR ('EXPRESSION_ARM.LIKE_EXPRESSION'  IN TYPEOF (arg)) 
THEN
	RETURN (Is_sql_mappable (arg\COMPARISON_EXPRESSION.OPERANDS[1])
		AND Is_sql_mappable (arg\COMPARISON_EXPRESSION.OPERANDS[2]));
END_IF;
IF 'EXPRESSION_ARM.INTERVAL_EXPRESSION' IN TYPEOF(arg) 
THEN 
	RETURN (Is_sql_mappable(arg\Interval_expression.interval_low) 
		AND Is_sql_mappable(arg\Interval_expression.interval_high)
		AND Is_sql_mappable(arg\Interval_expression.interval_item));
END_IF;
IF ('NUMERIC_FUNCTION_ARM.NUMERIC_DEFINED_FUNCTION' IN TYPEOF(arg)) 
	OR ('NUMERIC_EXPRESSION_ARM.BOOLEAN_DEFINED_FUNCTION' 	IN TYPEOF(arg))
	OR ('EXPRESSION_ARM.STRING_DEFINED_FUNCTION' IN TYPEOF(arg))  
THEN 
		RETURN (FALSE) ;
END_IF;

IF 'EXPRESSION_ARM.SIMPLE_STRING_EXPRESSION' IN TYPEOF(ARG) 
THEN 
	RETURN (TRUE);
END_IF;
IF 	('EXPRESSION_ARM.INDEX_EXPRESSION' IN TYPEOF(arg)) 
	OR ('EXPRESSION_ARM.SUBSTRING_EXPRESSION' IN TYPEOF(arg)) 
	OR ('EXPRESSION_ARM.CONCAT_EXPRESSION' 	IN TYPEOF(arg)) 
	OR ('EXPRESSION_ARM.FORMAT_FUNCTION' IN TYPEOF(arg)) 
THEN 
	RETURN (FALSE);
END_IF;
	RETURN (FALSE);
END_FUNCTION;
(*

Argument definitions:

arg: an Expression.



*)
END_SCHEMA;  -- Numeric_expression_arm
(*


© ISO 2018 — All rights reserved