Adapted to forbidden legacy

git-svn-id: https://svn.inf.ethz.ch/svn/lecturers/a2/trunk@7004 8c9fc860-2736-0410-a75d-ab315db34111

source/Array1dCplx.Mod

@@ -751,7 +751,7 @@ TYPE
 
 	(** Overloaded operators for type:  Array. *)
 (** Monadic Operator -  does not overwrite the argument *)
-	PROCEDURE "-"*( x: Array ): Array;
+	OPERATOR "-"*( x: Array ): Array;
 	VAR minus: Array;
 	BEGIN
 		IF x # NIL THEN minus := CreateCopy( x^ );  Negate( minus^, 0, LEN( minus ) );  ELSE DataErrors.Error( "The supplied vector was NIL." ) END;
@@ -759,7 +759,7 @@ TYPE
 	END "-";
 
 (** Complex conjugate *)
-	PROCEDURE "~"*( x: Array ): Array;
+	OPERATOR "~"*( x: Array ): Array;
 	VAR i, len: Index;  cc: Array;
 	BEGIN
 		IF x # NIL THEN
@@ -772,7 +772,7 @@ TYPE
 
 (** Dyadic Operators *)
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF Value );
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
 		ELSIF LEN( l ) # LEN( r ) THEN NEW( l, LEN( r ) )
@@ -781,7 +781,7 @@ TYPE
 		Copy( l^, r, 0, 0, LEN( r ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array1dRe.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array1dRe.Array );
 	VAR i: Index;
 	BEGIN
 		IF r # NIL THEN
@@ -794,7 +794,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array1dRat.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array1dRat.Array );
 	VAR i: Index;
 	BEGIN
 		IF r # NIL THEN
@@ -807,7 +807,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array1dInt.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array1dInt.Array );
 	VAR i: Index;
 	BEGIN
 		IF r # NIL THEN
@@ -820,7 +820,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF NbrRe.Real );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF NbrRe.Real );
 	VAR i: Index;
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
@@ -830,7 +830,7 @@ TYPE
 		FOR i := 0 TO LEN( r ) - 1 DO l[i] := r[i] END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF NbrRat.Rational );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF NbrRat.Rational );
 	VAR i: Index;
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
@@ -840,7 +840,7 @@ TYPE
 		FOR i := 0 TO LEN( r ) - 1 DO l[i] := r[i] END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF NbrInt.Integer );
 	VAR i: Index;
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
@@ -850,27 +850,27 @@ TYPE
 		FOR i := 0 TO LEN( r ) - 1 DO l[i] := r[i] END
 	END ":=";
 
-	PROCEDURE "="*( l: Array;  VAR r: ARRAY OF Value ): BOOLEAN;
+	OPERATOR "="*( l: Array;  VAR r: ARRAY OF Value ): BOOLEAN;
 	BEGIN
 		IF (l # NIL ) & (LEN( l ) = LEN( r )) THEN RETURN EqualsAA( l^, r, 0, LEN( l ) );  ELSE DataErrors.Error( "The lengths of the two supplied Array vectors were not equal." );  END;
 		RETURN FALSE;
 	END "=";
 
-	PROCEDURE "="*( VAR l: ARRAY OF Value;  r: Array ): BOOLEAN;
+	OPERATOR "="*( VAR l: ARRAY OF Value;  r: Array ): BOOLEAN;
 	BEGIN
 		IF (r # NIL ) & (LEN( l ) = LEN( r )) THEN RETURN EqualsAA( r^, l, 0, LEN( r ) );  ELSE DataErrors.Error( "The lengths of the two supplied Array vectors were not equal." );  END;
 		RETURN FALSE;
 	END "=";
 
 (* filling *)
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l = NIL THEN RETURN END;
 		Fill( r, l^, 0, LEN( l ) );
 	END ":=";
 
 (** Arithmetic. Operators do not overwrite the arguments. *)
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -880,7 +880,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array1dRe.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array1dRe.Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -894,7 +894,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array1dRe.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array1dRe.Array;  r: Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -908,7 +908,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array1dRat.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array1dRat.Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -922,7 +922,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array1dRat.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array1dRat.Array;  r: Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -936,7 +936,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array1dInt.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array1dInt.Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -950,7 +950,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array1dInt.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array1dInt.Array;  r: Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -964,35 +964,35 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Value ): Array;
+	OPERATOR "+"*( l: Array;  r: Value ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  AddAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( r: Value;  l: Array ): Array;
+	OPERATOR "+"*( r: Value;  l: Array ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  AddAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l: Array;  r: Value ): Array;
+	OPERATOR "-"*( l: Array;  r: Value ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  SubtractAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Array ): Array;
+	OPERATOR "-"*( l: Value;  r: Array ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (r # NIL ) THEN NEW( sum, LEN( r ) );  SubtractVA( l, r^, sum^, 0, LEN( r ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "-";
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1002,7 +1002,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array1dRe.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array1dRe.Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1016,7 +1016,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array1dRe.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array1dRe.Array;  r: Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1030,7 +1030,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array1dRat.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array1dRat.Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1044,7 +1044,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array1dRat.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array1dRat.Array;  r: Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1058,7 +1058,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array1dInt.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array1dInt.Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1072,7 +1072,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array1dInt.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array1dInt.Array;  r: Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1087,7 +1087,7 @@ TYPE
 	END "-";
 
 (** Array dot product *)
-	PROCEDURE "*"*( l, r: Array ): Value;
+	OPERATOR "*"*( l, r: Array ): Value;
 	VAR len: Index;  dot: Value;
 	BEGIN
 		dot := 0;
@@ -1098,7 +1098,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dRe.Array ): NbrCplx.Complex;
+	OPERATOR "*"*( l: Array;  r: Array1dRe.Array ): NbrCplx.Complex;
 	VAR i, len: Index;  dot: NbrCplx.Complex;
 	BEGIN
 		dot := 0;
@@ -1113,7 +1113,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dRe.Array;  r: Array ): NbrCplx.Complex;
+	OPERATOR "*"*( l: Array1dRe.Array;  r: Array ): NbrCplx.Complex;
 	VAR i, len: Index;  dot: NbrCplx.Complex;
 	BEGIN
 		dot := 0;
@@ -1128,7 +1128,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dRat.Array ): NbrCplx.Complex;
+	OPERATOR "*"*( l: Array;  r: Array1dRat.Array ): NbrCplx.Complex;
 	VAR i, len: Index;  dot: NbrCplx.Complex;
 	BEGIN
 		dot := 0;
@@ -1143,7 +1143,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dRat.Array;  r: Array ): NbrCplx.Complex;
+	OPERATOR "*"*( l: Array1dRat.Array;  r: Array ): NbrCplx.Complex;
 	VAR i, len: Index;  dot: NbrCplx.Complex;
 	BEGIN
 		dot := 0;
@@ -1158,7 +1158,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dInt.Array ): NbrCplx.Complex;
+	OPERATOR "*"*( l: Array;  r: Array1dInt.Array ): NbrCplx.Complex;
 	VAR i, len: Index;  dot: NbrCplx.Complex;
 	BEGIN
 		dot := 0;
@@ -1173,7 +1173,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dInt.Array;  r: Array ): NbrCplx.Complex;
+	OPERATOR "*"*( l: Array1dInt.Array;  r: Array ): NbrCplx.Complex;
 	VAR i, len: Index;  dot: NbrCplx.Complex;
 	BEGIN
 		dot := 0;
@@ -1189,21 +1189,21 @@ TYPE
 	END "*";
 
 (** Scalar multiplication *)
-	PROCEDURE "*"*( l: Value;  r: Array ): Array;
+	OPERATOR "*"*( l: Value;  r: Array ): Array;
 	VAR len: Index;  prod: Array;
 	BEGIN
 		IF r # NIL THEN len := LEN( r );  NEW( prod, len );  MultAV( r^, l, prod^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Value ): Array;
+	OPERATOR "*"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  prod: Array;
 	BEGIN
 		IF l # NIL THEN len := LEN( l );  NEW( prod, len );  MultAV( l^, r, prod^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRe.Real;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrRe.Real;  r: Array ): Array;
 	VAR i, len: Index;  left: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -1214,7 +1214,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrRe.Real ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrRe.Real ): Array;
 	VAR i, len: Index;  right: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1225,7 +1225,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRat.Rational;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrRat.Rational;  r: Array ): Array;
 	VAR i, len: Index;  left: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -1236,7 +1236,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrRat.Rational ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrRat.Rational ): Array;
 	VAR i, len: Index;  right: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1247,7 +1247,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt.Integer;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrInt.Integer;  r: Array ): Array;
 	VAR i, len: Index;  left: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -1258,7 +1258,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, len: Index;  right: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1270,7 +1270,7 @@ TYPE
 	END "*";
 
 (** Scalar division *)
-	PROCEDURE "/"*( l: Array;  r: Value ): Array;
+	OPERATOR "/"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1280,7 +1280,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrRe.Real ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrRe.Real ): Array;
 	VAR i, len: Index;  right: NbrCplx.Complex;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1295,7 +1295,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrRat.Rational ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrRat.Rational ): Array;
 	VAR i, len: Index;  right: NbrCplx.Complex;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1310,7 +1310,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, len: Index;  right: NbrCplx.Complex;  div: Array;
 	BEGIN
 		IF l # NIL THEN

source/Array1dInt.Mod

@@ -966,7 +966,7 @@ TYPE
 
 	(** Overloaded operators for type:  Array. *)
 (** Monadic Operator -  does not overwrite the argument *)
-	PROCEDURE "-"*( x: Array ): Array;
+	OPERATOR "-"*( x: Array ): Array;
 	VAR minus: Array;
 	BEGIN
 		IF x # NIL THEN minus := CreateCopy( x^ );  Negate( minus^, 0, LEN( minus ) );  ELSE DataErrors.Error( "The supplied vector was NIL." ) END;
@@ -975,7 +975,7 @@ TYPE
 
 (** Dyadic Operators *)
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF Value );
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
 		ELSIF LEN( l ) # LEN( r ) THEN NEW( l, LEN( r ) )
@@ -984,27 +984,27 @@ TYPE
 		Copy( l^, r, 0, 0, LEN( r ) );
 	END ":=";
 
-	PROCEDURE "="*( l: Array;  VAR r: ARRAY OF Value ): BOOLEAN;
+	OPERATOR "="*( l: Array;  VAR r: ARRAY OF Value ): BOOLEAN;
 	BEGIN
 		IF (l # NIL ) & (LEN( l ) = LEN( r )) THEN RETURN EqualsAA( l^, r, 0, LEN( l ) );  ELSE DataErrors.Error( "The lengths of the two supplied Array vectors were not equal." );  END;
 		RETURN FALSE;
 	END "=";
 
-	PROCEDURE "="*( VAR l: ARRAY OF Value;  r: Array ): BOOLEAN;
+	OPERATOR "="*( VAR l: ARRAY OF Value;  r: Array ): BOOLEAN;
 	BEGIN
 		IF (r # NIL ) & (LEN( l ) = LEN( r )) THEN RETURN EqualsAA( r^, l, 0, LEN( r ) );  ELSE DataErrors.Error( "The lengths of the two supplied Array vectors were not equal." );  END;
 		RETURN FALSE;
 	END "=";
 
 (* filling *)
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l = NIL THEN RETURN END;
 		Fill( r, l^, 0, LEN( l ) );
 	END ":=";
 
 (** Arithmetic. Operators do not overwrite the arguments. *)
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1014,35 +1014,35 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Value ): Array;
+	OPERATOR "+"*( l: Array;  r: Value ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  AddAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( r: Value;  l: Array ): Array;
+	OPERATOR "+"*( r: Value;  l: Array ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  AddAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l: Array;  r: Value ): Array;
+	OPERATOR "-"*( l: Array;  r: Value ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  SubtractAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Array ): Array;
+	OPERATOR "-"*( l: Value;  r: Array ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (r # NIL ) THEN NEW( sum, LEN( r ) );  SubtractVA( l, r^, sum^, 0, LEN( r ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "-";
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1053,7 +1053,7 @@ TYPE
 	END "-";
 
 (** Array dot product *)
-	PROCEDURE "*"*( l, r: Array ): Value;
+	OPERATOR "*"*( l, r: Array ): Value;
 	VAR len: Index;  dot: Value;
 	BEGIN
 		dot := 0;
@@ -1065,14 +1065,14 @@ TYPE
 	END "*";
 
 (** Scalar multiplication *)
-	PROCEDURE "*"*( l: Value;  r: Array ): Array;
+	OPERATOR "*"*( l: Value;  r: Array ): Array;
 	VAR len: Index;  prod: Array;
 	BEGIN
 		IF r # NIL THEN len := LEN( r );  NEW( prod, len );  MultAV( r^, l, prod^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Value ): Array;
+	OPERATOR "*"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  prod: Array;
 	BEGIN
 		IF l # NIL THEN len := LEN( l );  NEW( prod, len );  MultAV( l^, r, prod^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
@@ -1080,7 +1080,7 @@ TYPE
 	END "*";
 
 (** Scalar division *)
-	PROCEDURE "DIV"*( l: Array;  r: Value ): Array;
+	OPERATOR "DIV"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1090,14 +1090,14 @@ TYPE
 		RETURN div
 	END "DIV";
 
-	PROCEDURE "DIV"*( l: Value;  r: Array ): Array;
+	OPERATOR "DIV"*( l: Value;  r: Array ): Array;
 	VAR len: Index;  div: Array;
 	BEGIN
 		IF r # NIL THEN len := LEN( r );  NEW( div, len );  DivVA( l, r^, div^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
 		RETURN div
 	END "DIV";
 
-	PROCEDURE "MOD"*( l: Array;  r: Value ): Array;
+	OPERATOR "MOD"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  mod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1107,7 +1107,7 @@ TYPE
 		RETURN mod
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Array ): Array;
+	OPERATOR "MOD"*( l: Value;  r: Array ): Array;
 	VAR len: Index;  div: Array;
 	BEGIN
 		IF r # NIL THEN len := LEN( r );  NEW( div, len );  ModVA( l, r^, div^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;

source/Array1dRat.Mod

@@ -916,7 +916,7 @@ TYPE
 
 	(** Overloaded operators for type:  Array. *)
 (** Monadic Operator -  does not overwrite the argument *)
-	PROCEDURE "-"*( x: Array ): Array;
+	OPERATOR "-"*( x: Array ): Array;
 	VAR minus: Array;
 	BEGIN
 		IF x # NIL THEN minus := CreateCopy( x^ );  Negate( minus^, 0, LEN( minus ) );  ELSE DataErrors.Error( "The supplied vector was NIL." ) END;
@@ -926,7 +926,7 @@ TYPE
 
 (** Dyadic Operators *)
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF Value );
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
 		ELSIF LEN( l ) # LEN( r ) THEN NEW( l, LEN( r ) )
@@ -935,7 +935,7 @@ TYPE
 		Copy( l^, r, 0, 0, LEN( r ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array1dInt.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array1dInt.Array );
 	VAR i: Index;
 	BEGIN
 		IF r # NIL THEN
@@ -948,7 +948,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF NbrInt.Integer );
 	VAR i: Index;
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
@@ -958,13 +958,13 @@ TYPE
 		FOR i := 0 TO LEN( r ) - 1 DO l[i] := r[i] END
 	END ":=";
 
-	PROCEDURE "="*( l: Array;  VAR r: ARRAY OF Value ): BOOLEAN;
+	OPERATOR "="*( l: Array;  VAR r: ARRAY OF Value ): BOOLEAN;
 	BEGIN
 		IF (l # NIL ) & (LEN( l ) = LEN( r )) THEN RETURN EqualsAA( l^, r, 0, LEN( l ) );  ELSE DataErrors.Error( "The lengths of the two supplied Array vectors were not equal." );  END;
 		RETURN FALSE;
 	END "=";
 
-	PROCEDURE "="*( VAR l: ARRAY OF Value;  r: Array ): BOOLEAN;
+	OPERATOR "="*( VAR l: ARRAY OF Value;  r: Array ): BOOLEAN;
 	BEGIN
 		IF (r # NIL ) & (LEN( l ) = LEN( r )) THEN RETURN EqualsAA( r^, l, 0, LEN( r ) );  ELSE DataErrors.Error( "The lengths of the two supplied Array vectors were not equal." );  END;
 		RETURN FALSE;
@@ -972,14 +972,14 @@ TYPE
 
 
 (* filling *)
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l = NIL THEN RETURN END;
 		Fill( r, l^, 0, LEN( l ) );
 	END ":=";
 
 (** Arithmetic. Operators do not overwrite the arguments. *)
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -989,21 +989,21 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Value ): Array;
+	OPERATOR "+"*( l: Array;  r: Value ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  AddAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( r: Value;  l: Array ): Array;
+	OPERATOR "+"*( r: Value;  l: Array ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  AddAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array1dInt.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array1dInt.Array ): Array;
 	VAR i, len: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1017,7 +1017,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array1dInt.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array1dInt.Array;  r: Array ): Array;
 	VAR i, len: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1031,21 +1031,21 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l: Array;  r: Value ): Array;
+	OPERATOR "-"*( l: Array;  r: Value ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  SubtractAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Array ): Array;
+	OPERATOR "-"*( l: Value;  r: Array ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (r # NIL ) THEN NEW( sum, LEN( r ) );  SubtractVA( l, r^, sum^, 0, LEN( r ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "-";
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1055,7 +1055,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array1dInt.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array1dInt.Array ): Array;
 	VAR i, len: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1069,7 +1069,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array1dInt.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array1dInt.Array;  r: Array ): Array;
 	VAR i, len: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1084,7 +1084,7 @@ TYPE
 	END "-";
 
 (** Array dot product *)
-	PROCEDURE "*"*( l, r: Array ): Value;
+	OPERATOR "*"*( l, r: Array ): Value;
 	VAR len: Index;  dot: Value;
 	BEGIN
 		dot := 0;
@@ -1095,7 +1095,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dInt.Array ): NbrRat.Rational;
+	OPERATOR "*"*( l: Array;  r: Array1dInt.Array ): NbrRat.Rational;
 	VAR i, len: NbrInt.Integer;  dot: NbrRat.Rational;
 	BEGIN
 		dot := 0;
@@ -1110,7 +1110,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dInt.Array;  r: Array ): NbrRat.Rational;
+	OPERATOR "*"*( l: Array1dInt.Array;  r: Array ): NbrRat.Rational;
 	VAR i, len: NbrInt.Integer;  dot: NbrRat.Rational;
 	BEGIN
 		dot := 0;
@@ -1126,21 +1126,21 @@ TYPE
 	END "*";
 
 (** Scalar multiplication *)
-	PROCEDURE "*"*( l: Value;  r: Array ): Array;
+	OPERATOR "*"*( l: Value;  r: Array ): Array;
 	VAR len: Index;  prod: Array;
 	BEGIN
 		IF r # NIL THEN len := LEN( r );  NEW( prod, len );  MultAV( r^, l, prod^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Value ): Array;
+	OPERATOR "*"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  prod: Array;
 	BEGIN
 		IF l # NIL THEN len := LEN( l );  NEW( prod, len );  MultAV( l^, r, prod^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt.Integer;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrInt.Integer;  r: Array ): Array;
 	VAR i, len: NbrInt.Integer;  left: NbrRat.Rational;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -1151,7 +1151,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, len: NbrInt.Integer;  right: NbrRat.Rational;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1163,7 +1163,7 @@ TYPE
 	END "*";
 
 (** Scalar division *)
-	PROCEDURE "/"*( l: Array;  r: Value ): Array;
+	OPERATOR "/"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1173,7 +1173,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, len: NbrInt.Integer;  right: NbrRat.Rational;  div: Array;
 	BEGIN
 		IF l # NIL THEN

source/Array1dRe.Mod

@@ -923,7 +923,7 @@ TYPE
 
 	(** Overloaded operators for type:  Array. *)
 (** Monadic Operator -  does not overwrite the argument *)
-	PROCEDURE "-"*( x: Array ): Array;
+	OPERATOR "-"*( x: Array ): Array;
 	VAR minus: Array;
 	BEGIN
 		IF x # NIL THEN minus := CreateCopy( x^ );  Negate( minus^, 0, LEN( minus ) );  ELSE DataErrors.Error( "The supplied vector was NIL." ) END;
@@ -933,7 +933,7 @@ TYPE
 
 (** Dyadic Operators *)
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF Value );
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
 		ELSIF LEN( l ) # LEN( r ) THEN NEW( l, LEN( r ) )
@@ -942,7 +942,7 @@ TYPE
 		Copy( l^, r, 0, 0, LEN( r ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array1dRat.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array1dRat.Array );
 	VAR i: Index;
 	BEGIN
 		IF r # NIL THEN
@@ -955,7 +955,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array1dInt.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array1dInt.Array );
 	VAR i: Index;
 	BEGIN
 		IF r # NIL THEN
@@ -968,7 +968,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF NbrRat.Rational );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF NbrRat.Rational );
 	VAR i: Index;
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
@@ -978,7 +978,7 @@ TYPE
 		FOR i := 0 TO LEN( r ) - 1 DO l[i] := r[i] END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF NbrInt.Integer );
 	VAR i: Index;
 	BEGIN
 		IF l = NIL THEN NEW( l, LEN( r ) )
@@ -988,27 +988,27 @@ TYPE
 		FOR i := 0 TO LEN( r ) - 1 DO l[i] := r[i] END
 	END ":=";
 
-	PROCEDURE "="*( l: Array;  VAR r: ARRAY OF Value ): BOOLEAN;
+	OPERATOR "="*( l: Array;  VAR r: ARRAY OF Value ): BOOLEAN;
 	BEGIN
 		IF (l # NIL ) & (LEN( l ) = LEN( r )) THEN RETURN EqualsAA( l^, r, 0, LEN( l ) );  ELSE DataErrors.Error( "The lengths of the two supplied Array vectors were not equal." );  END;
 		RETURN FALSE;
 	END "=";
 
-	PROCEDURE "="*( VAR l: ARRAY OF Value;  r: Array ): BOOLEAN;
+	OPERATOR "="*( VAR l: ARRAY OF Value;  r: Array ): BOOLEAN;
 	BEGIN
 		IF (r # NIL ) & (LEN( l ) = LEN( r )) THEN RETURN EqualsAA( r^, l, 0, LEN( r ) );  ELSE DataErrors.Error( "The lengths of the two supplied Array vectors were not equal." );  END;
 		RETURN FALSE;
 	END "=";
 
 (* filling *)
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l = NIL THEN RETURN END;
 		Fill( r, l^, 0, LEN( l ) );
 	END ":=";
 
 (** Arithmetic. Operators do not overwrite the arguments. *)
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1018,7 +1018,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array1dRat.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array1dRat.Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1032,7 +1032,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array1dRat.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array1dRat.Array;  r: Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1046,7 +1046,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array1dInt.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array1dInt.Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1060,7 +1060,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array1dInt.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array1dInt.Array;  r: Array ): Array;
 	VAR i, len: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1074,35 +1074,35 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Value ): Array;
+	OPERATOR "+"*( l: Array;  r: Value ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  AddAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( r: Value;  l: Array ): Array;
+	OPERATOR "+"*( r: Value;  l: Array ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  AddAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l: Array;  r: Value ): Array;
+	OPERATOR "-"*( l: Array;  r: Value ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (l # NIL ) THEN NEW( sum, LEN( l ) );  SubtractAV( l^, r, sum^, 0, LEN( l ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Array ): Array;
+	OPERATOR "-"*( l: Value;  r: Array ): Array;
 	VAR sum: Array;
 	BEGIN
 		IF (r # NIL ) THEN NEW( sum, LEN( r ) );  SubtractVA( l, r^, sum^, 0, LEN( r ) );  ELSE DataErrors.Error( "Supplied Array was NIL" );  END;
 		RETURN sum
 	END "-";
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1112,7 +1112,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array1dRat.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array1dRat.Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1126,7 +1126,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array1dRat.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array1dRat.Array;  r: Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1140,7 +1140,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array1dInt.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array1dInt.Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1154,7 +1154,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array1dInt.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array1dInt.Array;  r: Array ): Array;
 	VAR i, len: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -1169,7 +1169,7 @@ TYPE
 	END "-";
 
 (** Array dot product *)
-	PROCEDURE "*"*( l, r: Array ): Value;
+	OPERATOR "*"*( l, r: Array ): Value;
 	VAR len: Index;  dot: Value;
 	BEGIN
 		dot := 0;
@@ -1180,7 +1180,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dRat.Array ): NbrRe.Real;
+	OPERATOR "*"*( l: Array;  r: Array1dRat.Array ): NbrRe.Real;
 	VAR i, len: Index;  dot: NbrRe.Real;  sum: NbrRe.Real;
 	BEGIN
 		dot := 0;
@@ -1197,7 +1197,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dRat.Array;  r: Array ): NbrRe.Real;
+	OPERATOR "*"*( l: Array1dRat.Array;  r: Array ): NbrRe.Real;
 	VAR i, len: Index;  dot: NbrRe.Real;  sum: NbrRe.Real;
 	BEGIN
 		dot := 0;
@@ -1214,7 +1214,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dInt.Array ): NbrRe.Real;
+	OPERATOR "*"*( l: Array;  r: Array1dInt.Array ): NbrRe.Real;
 	VAR i, len: Index;  dot, sum: NbrRe.Real;
 	BEGIN
 		dot := 0;
@@ -1231,7 +1231,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dInt.Array;  r: Array ): NbrRe.Real;
+	OPERATOR "*"*( l: Array1dInt.Array;  r: Array ): NbrRe.Real;
 	VAR i, len: Index;  dot, sum: NbrRe.Real;
 	BEGIN
 		dot := 0;
@@ -1249,21 +1249,21 @@ TYPE
 	END "*";
 
 (** Scalar multiplication *)
-	PROCEDURE "*"*( l: Value;  r: Array ): Array;
+	OPERATOR "*"*( l: Value;  r: Array ): Array;
 	VAR len: Index;  prod: Array;
 	BEGIN
 		IF r # NIL THEN len := LEN( r );  NEW( prod, len );  MultAV( r^, l, prod^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Value ): Array;
+	OPERATOR "*"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  prod: Array;
 	BEGIN
 		IF l # NIL THEN len := LEN( l );  NEW( prod, len );  MultAV( l^, r, prod^, 0, len );  ELSE DataErrors.Error( "The supplied Array vector was NIL." ) END;
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRat.Rational;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrRat.Rational;  r: Array ): Array;
 	VAR i, len: Index;  left: NbrRe.Real;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -1274,7 +1274,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrRat.Rational ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrRat.Rational ): Array;
 	VAR i, len: Index;  right: NbrRe.Real;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1285,7 +1285,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt.Integer;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrInt.Integer;  r: Array ): Array;
 	VAR i, len: Index;  left: NbrRe.Real;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -1296,7 +1296,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, len: Index;  right: NbrRe.Real;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1308,7 +1308,7 @@ TYPE
 	END "*";
 
 (** Scalar division *)
-	PROCEDURE "/"*( l: Array;  r: Value ): Array;
+	OPERATOR "/"*( l: Array;  r: Value ): Array;
 	VAR len: Index;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1318,7 +1318,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrRat.Rational ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrRat.Rational ): Array;
 	VAR i, len: Index;  right: NbrRe.Real;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -1333,7 +1333,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, len: Index;  right: NbrRe.Real;  div: Array;
 	BEGIN
 		IF l # NIL THEN

source/Array2dCplx.Mod

@@ -123,7 +123,7 @@ TYPE
 
 	(** Monadic Operators - do not overwrite the argument *)
 (** Negative *)
-	PROCEDURE "-"*( x: Array ): Array;
+	OPERATOR "-"*( x: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  minus: Array;
 	BEGIN
 		IF x # NIL THEN
@@ -137,7 +137,7 @@ TYPE
 	END "-";
 
 (** Complex Conjugate *)
-	PROCEDURE "~"*( x: Array ): Array;
+	OPERATOR "~"*( x: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  cc: Array;
 	BEGIN
 		IF x # NIL THEN
@@ -151,12 +151,12 @@ TYPE
 	END "~";
 
 (** Dyadic Operators *)
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l # NIL THEN Fill( r, l^, 0, 0, LEN( l[0] ), LEN( l ) );  ELSE DataErrors.Error( "The supplied instance of Array2dRe.Array was NIL." ) END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array2dRe.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array2dRe.Array );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		IF r # NIL THEN
@@ -172,7 +172,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array2dRat.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array2dRat.Array );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		IF r # NIL THEN
@@ -188,7 +188,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array2dInt.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array2dInt.Array );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		IF r # NIL THEN
@@ -204,7 +204,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrCplx.Complex );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrCplx.Complex );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -217,7 +217,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrRe.Real );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrRe.Real );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -230,7 +230,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrRat.Rational );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrRat.Rational );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -243,7 +243,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrInt.Integer );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -257,7 +257,7 @@ TYPE
 	END ":=";
 
 (** Arithmetic. Operators do not overwrite the arguments. *)
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -273,7 +273,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array2dRe.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array2dRe.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -289,7 +289,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array2dRe.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array2dRe.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -305,7 +305,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array2dRat.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array2dRat.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -321,7 +321,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array2dRat.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array2dRat.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -337,7 +337,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -353,7 +353,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array2dInt.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -369,7 +369,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -385,7 +385,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array2dRe.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array2dRe.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -401,7 +401,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array2dRe.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array2dRe.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -417,7 +417,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array2dRat.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array2dRat.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -433,7 +433,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array2dRat.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array2dRat.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -449,7 +449,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -465,7 +465,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array2dInt.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -482,7 +482,7 @@ TYPE
 	END "-";
 
 (** Array dot products *)
-	PROCEDURE "*"*( l, r: Array ): Array;
+	OPERATOR "*"*( l, r: Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -502,7 +502,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array2dRe.Array ): Array;
+	OPERATOR "*"*( l: Array;  r: Array2dRe.Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -522,7 +522,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array2dRe.Array;  r: Array ): Array;
+	OPERATOR "*"*( l: Array2dRe.Array;  r: Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -542,7 +542,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array2dRat.Array ): Array;
+	OPERATOR "*"*( l: Array;  r: Array2dRat.Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -562,7 +562,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array2dRat.Array;  r: Array ): Array;
+	OPERATOR "*"*( l: Array2dRat.Array;  r: Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -582,7 +582,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "*"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -602,7 +602,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "*"*( l: Array2dInt.Array;  r: Array ): Array;
 	(** Caution:  Use brackets to ensure proper matrix multiplication when contracting three or more matrices,
 				e.g., A*(B*C) is correct, whereas A*B*C is not.  This is because matrix multiplician is from right to left;
 				whereas, the Oberon programming languages multiplies from left to right. *)
@@ -626,7 +626,7 @@ TYPE
 	END "*";
 
 (** Array-Array contractions,  returns  x = A v  or x[i] = A[i, k] v[k] *)
-	PROCEDURE "*"*( l: Array;  r: Array1dCplx.Array ): Array1dCplx.Array;
+	OPERATOR "*"*( l: Array;  r: Array1dCplx.Array ): Array1dCplx.Array;
 	VAR i, k, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array1dCplx.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -644,7 +644,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dRe.Array ): Array1dCplx.Array;
+	OPERATOR "*"*( l: Array;  r: Array1dRe.Array ): Array1dCplx.Array;
 	VAR i, k, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array1dCplx.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -662,7 +662,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dRat.Array ): Array1dCplx.Array;
+	OPERATOR "*"*( l: Array;  r: Array1dRat.Array ): Array1dCplx.Array;
 	VAR i, k, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array1dCplx.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -680,7 +680,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dInt.Array ): Array1dCplx.Array;
+	OPERATOR "*"*( l: Array;  r: Array1dInt.Array ): Array1dCplx.Array;
 	VAR i, k, dummy, rows: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array1dCplx.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -699,7 +699,7 @@ TYPE
 	END "*";
 
 (** Array-Array contractions,  returns  x = ATv = vTA  or x[i] = A[k, i] v[k] = v[k] A[k, i]  *)
-	PROCEDURE "*"*( l: Array1dCplx.Array;  r: Array ): Array1dCplx.Array;
+	OPERATOR "*"*( l: Array1dCplx.Array;  r: Array ): Array1dCplx.Array;
 	VAR i, k, cols, dummy: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array1dCplx.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -717,7 +717,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dRe.Array;  r: Array ): Array1dCplx.Array;
+	OPERATOR "*"*( l: Array1dRe.Array;  r: Array ): Array1dCplx.Array;
 	VAR i, k, cols, dummy: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array1dCplx.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -735,7 +735,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dRat.Array;  r: Array ): Array1dCplx.Array;
+	OPERATOR "*"*( l: Array1dRat.Array;  r: Array ): Array1dCplx.Array;
 	VAR i, k, cols, dummy: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array1dCplx.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -753,7 +753,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dInt.Array;  r: Array ): Array1dCplx.Array;
+	OPERATOR "*"*( l: Array1dInt.Array;  r: Array ): Array1dCplx.Array;
 	VAR i, k, cols, dummy: NbrInt.Integer;  sum: NbrCplx.Complex;  dot: Array1dCplx.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -772,7 +772,7 @@ TYPE
 	END "*";
 
 (** Scalar multiplications *)
-	PROCEDURE "*"*( l: NbrCplx.Complex;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrCplx.Complex;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -785,7 +785,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrCplx.Complex ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrCplx.Complex ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -798,7 +798,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRe.Real;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrRe.Real;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  left: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -811,7 +811,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrRe.Real ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrRe.Real ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -824,7 +824,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRat.Rational;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrRat.Rational;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  left: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -837,7 +837,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrRat.Rational ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrRat.Rational ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -850,7 +850,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt.Integer;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrInt.Integer;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  left: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -863,7 +863,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrCplx.Complex;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -877,7 +877,7 @@ TYPE
 	END "*";
 
 (** Scalar divisions *)
-	PROCEDURE "/"*( l: Array;  r: NbrCplx.Complex ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrCplx.Complex ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -893,7 +893,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrRe.Real ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrRe.Real ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrCplx.Complex;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -910,7 +910,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrRat.Rational ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrRat.Rational ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrCplx.Complex;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -927,7 +927,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrCplx.Complex;  div: Array;
 	BEGIN
 		IF l # NIL THEN

source/Array2dInt.Mod

@@ -150,7 +150,7 @@ TYPE
 
 
 (** Monadic Operator - does not overwrite the argument *)
-	PROCEDURE "-"*( x: Array ): Array;
+	OPERATOR "-"*( x: Array ): Array;
 	VAR i, k, cols, rows: Index;  minus: Array;
 	BEGIN
 		IF x # NIL THEN
@@ -163,12 +163,12 @@ TYPE
 		RETURN minus
 	END "-";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l # NIL THEN Fill( r, l^, 0, 0, LEN( l[0] ), LEN( l ) );  ELSE DataErrors.Error( "The supplied instance of Array2dInt.Array was NIL." ) END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF Value );
 	VAR i, k, cols, rows: Index;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -182,7 +182,7 @@ TYPE
 	END ":=";
 
 (** Arithmetic. Operators do not overwrite the arguments. *)
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR i, k, cols, rows: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -198,7 +198,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR i, k, cols, rows: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -215,7 +215,7 @@ TYPE
 	END "-";
 
 (** Array dot product *)
-	PROCEDURE "*"*( l, r: Array ): Array;
+	OPERATOR "*"*( l, r: Array ): Array;
 	(** Caution:  Use brackets to ensure proper matrix multiplication when contracting three or more matrices,
 				e.g., A*(B*C) is correct, whereas A*B*C is not.  This is because matrix multiplician is from right to left;
 				whereas, the Oberon programming languages multiplies from left to right. *)
@@ -239,7 +239,7 @@ TYPE
 	END "*";
 
 (** Array-Vector contraction,  returns  x = A v  or x[i] = A[i, k] v[k] *)
-	PROCEDURE "*"*( l: Array;  r: ArrayXd.Array1 ): ArrayXd.Array1;
+	OPERATOR "*"*( l: Array;  r: ArrayXd.Array1 ): ArrayXd.Array1;
 	VAR i, k, dummy, rows, sum: Index;  dot: ArrayXd.Array1;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -258,7 +258,7 @@ TYPE
 	END "*";
 
 (** Vector-Array contraction,  returns  x = ATv = vTA  or x[i] = A[k, i] v[k] = v[k] A[k, i]  *)
-	PROCEDURE "*"*( l: ArrayXd.Array1;  r: Array ): ArrayXd.Array1;
+	OPERATOR "*"*( l: ArrayXd.Array1;  r: Array ): ArrayXd.Array1;
 	VAR i, k, cols, dummy, sum: Index;  dot: ArrayXd.Array1;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -277,7 +277,7 @@ TYPE
 	END "*";
 
 (** Scalar multiplication *)
-	PROCEDURE "*"*( l: Value;  r: Array ): Array;
+	OPERATOR "*"*( l: Value;  r: Array ): Array;
 	VAR i, k, cols, rows: Index;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -290,7 +290,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Value ): Array;
+	OPERATOR "*"*( l: Array;  r: Value ): Array;
 	VAR i, k, cols, rows: Index;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -304,7 +304,7 @@ TYPE
 	END "*";
 
 (** Scalar division *)
-	PROCEDURE "DIV"*( l: Array;  r: Value ): Array;
+	OPERATOR "DIV"*( l: Array;  r: Value ): Array;
 	VAR i, k, cols, rows: Index;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -320,7 +320,7 @@ TYPE
 		RETURN div
 	END "DIV";
 
-	PROCEDURE "MOD"*( l: Array;  r: Value ): Array;
+	OPERATOR "MOD"*( l: Array;  r: Value ): Array;
 	VAR i, k, cols, rows: Index;  mod: Array;
 	BEGIN
 		IF l # NIL THEN

source/Array2dRat.Mod

@@ -149,7 +149,7 @@ TYPE
 
 
 (** Monadic Operator - does not overwrite the argument *)
-	PROCEDURE "-"*( x: Array ): Array;
+	OPERATOR "-"*( x: Array ): Array;
 	VAR i, k, cols, rows: Index;  minus: Array;
 	BEGIN
 		IF x # NIL THEN
@@ -162,12 +162,12 @@ TYPE
 		RETURN minus
 	END "-";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l # NIL THEN Fill( r, l^, 0, 0, LEN( l[0] ), LEN( l ) );  ELSE DataErrors.Error( "The supplied instance of Array2dRe.Array was NIL." ) END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF Value );
 	VAR i, k, cols, rows: Index;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -180,7 +180,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array2dInt.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array2dInt.Array );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		IF r # NIL THEN
@@ -196,7 +196,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrInt.Integer );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -210,7 +210,7 @@ TYPE
 	END ":=";
 
 (** Arithmetic. Operators do not overwrite the arguments. *)
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR i, k, cols, rows: Index;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -226,7 +226,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -242,7 +242,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array2dInt.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -258,7 +258,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR i, k, cols, rows: Index;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -274,7 +274,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -290,7 +290,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array2dInt.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -307,7 +307,7 @@ TYPE
 	END "-";
 
 (** Array dot product *)
-	PROCEDURE "*"*( l, r: Array ): Array;
+	OPERATOR "*"*( l, r: Array ): Array;
 	(** Caution:  Use brackets to ensure proper matrix multiplication when contracting three or more matrices,
 				e.g., A*(B*C) is correct, whereas A*B*C is not.  This is because matrix multiplician is from right to left;
 				whereas, the Oberon programming languages multiplies from left to right. *)
@@ -330,7 +330,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "*"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: NbrRat.Rational;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -350,7 +350,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "*"*( l: Array2dInt.Array;  r: Array ): Array;
 	(** Caution:  Use brackets to ensure proper matrix multiplication when contracting three or more matrices,
 				e.g., A*(B*C) is correct, whereas A*B*C is not.  This is because matrix multiplician is from right to left;
 				whereas, the Oberon programming languages multiplies from left to right. *)
@@ -374,7 +374,7 @@ TYPE
 	END "*";
 
 (** Array-Vector contraction,  returns  x = A v  or x[i] = A[i, k] v[k] *)
-	PROCEDURE "*"*( l: Array;  r: Array1d.Array ): Array1d.Array;
+	OPERATOR "*"*( l: Array;  r: Array1d.Array ): Array1d.Array;
 	VAR i, k, dummy, rows: Index;  dot: Array1d.Array;  sum: Value;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -393,7 +393,7 @@ TYPE
 	END "*";
 
 (** Vector-Array contraction,  returns  x = ATv = vTA  or x[i] = A[k, i] v[k] = v[k] A[k, i]  *)
-	PROCEDURE "*"*( l: Array1d.Array;  r: Array ): Array1d.Array;
+	OPERATOR "*"*( l: Array1d.Array;  r: Array ): Array1d.Array;
 	VAR i, k, cols, dummy: Index;  dot: Array1d.Array;  sum: Value;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -411,7 +411,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dInt.Array ): Array1d.Array;
+	OPERATOR "*"*( l: Array;  r: Array1dInt.Array ): Array1d.Array;
 	VAR i, k, dummy, rows: NbrInt.Integer;  sum: NbrRat.Rational;  dot: Array1d.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -429,7 +429,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dInt.Array;  r: Array ): Array1d.Array;
+	OPERATOR "*"*( l: Array1dInt.Array;  r: Array ): Array1d.Array;
 	VAR i, k, cols, dummy: NbrInt.Integer;  sum: NbrRat.Rational;  dot: Array1d.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -449,7 +449,7 @@ TYPE
 
 
 (** Scalar multiplication *)
-	PROCEDURE "*"*( l: Value;  r: Array ): Array;
+	OPERATOR "*"*( l: Value;  r: Array ): Array;
 	VAR i, k, cols, rows: Index;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -462,7 +462,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Value ): Array;
+	OPERATOR "*"*( l: Array;  r: Value ): Array;
 	VAR i, k, cols, rows: Index;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -475,7 +475,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt.Integer;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrInt.Integer;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  left: NbrRat.Rational;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -488,7 +488,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrRat.Rational;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -502,7 +502,7 @@ TYPE
 	END "*";
 
 (** Scalar division *)
-	PROCEDURE "/"*( l: Array;  r: Value ): Array;
+	OPERATOR "/"*( l: Array;  r: Value ): Array;
 	VAR i, k, cols, rows: Index;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -518,7 +518,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrRat.Rational;  div: Array;
 	BEGIN
 		IF l # NIL THEN

source/Array2dRe.Mod

@@ -153,7 +153,7 @@ TYPE
 	(** Overloaded operators for type:  Array. *)
 
 (** Monadic Operator - does not overwrite the argument *)
-	PROCEDURE "-"*( x: Array ): Array;
+	OPERATOR "-"*( x: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  minus: Array;
 	BEGIN
 		IF x # NIL THEN
@@ -166,12 +166,12 @@ TYPE
 		RETURN minus
 	END "-";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l # NIL THEN Fill( r, l^, 0, 0, LEN( l[0] ), LEN( l ) );  ELSE DataErrors.Error( "The supplied instance of Array2dRe.Array was NIL." ) END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array2dRat.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array2dRat.Array );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		IF r # NIL THEN
@@ -187,7 +187,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: Array2dInt.Array );
+	OPERATOR ":="*( VAR l: Array;  r: Array2dInt.Array );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		IF r # NIL THEN
@@ -203,7 +203,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrRe.Real );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrRe.Real );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -216,7 +216,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrRat.Rational );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrRat.Rational );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -229,7 +229,7 @@ TYPE
 		END
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF NbrInt.Integer );
 	VAR i, k, cols, rows: NbrInt.Integer;
 	BEGIN
 		rows := LEN( r, 0 );  cols := LEN( r, 1 );
@@ -242,7 +242,7 @@ TYPE
 		END
 	END ":=";
 (** Arithmetic. Operators do not overwrite the arguments. *)
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -258,7 +258,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array2dRat.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array2dRat.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -274,7 +274,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array2dRat.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array2dRat.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -290,7 +290,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "+"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -306,7 +306,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "+"*( l: Array2dInt.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  sum: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -322,7 +322,7 @@ TYPE
 		RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -338,7 +338,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array2dRat.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array2dRat.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -354,7 +354,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array2dRat.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array2dRat.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -370,7 +370,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "-"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -386,7 +386,7 @@ TYPE
 		RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "-"*( l: Array2dInt.Array;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  diff: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -402,7 +402,7 @@ TYPE
 		RETURN diff
 	END "-";
 (** Array dot products *)
-	PROCEDURE "*"*( l, r: Array ): Array;
+	OPERATOR "*"*( l, r: Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: Value;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -422,7 +422,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array2dRat.Array ): Array;
+	OPERATOR "*"*( l: Array;  r: Array2dRat.Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: Value;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -442,7 +442,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array2dRat.Array;  r: Array ): Array;
+	OPERATOR "*"*( l: Array2dRat.Array;  r: Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: Value;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -462,7 +462,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array2dInt.Array ): Array;
+	OPERATOR "*"*( l: Array;  r: Array2dInt.Array ): Array;
 	VAR i, j, k, cols, dummy, rows: NbrInt.Integer;  sum: Value;  dot: Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -482,7 +482,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array2dInt.Array;  r: Array ): Array;
+	OPERATOR "*"*( l: Array2dInt.Array;  r: Array ): Array;
 	(** Caution:  Use brackets to ensure proper matrix multiplication when contracting three or more matrices,
 				e.g., A*(B*C) is correct, whereas A*B*C is not.  This is because matrix multiplician is from right to left;
 				whereas, the Oberon programming languages multiplies from left to right. *)
@@ -506,7 +506,7 @@ TYPE
 	END "*";
 
 (** Array-Array contractions,  returns  x = A v  or x[i] = A[i, k] v[k] *)
-	PROCEDURE "*"*( l: Array;  r: Array1dRe.Array ): Array1dRe.Array;
+	OPERATOR "*"*( l: Array;  r: Array1dRe.Array ): Array1dRe.Array;
 	VAR i, k, dummy, rows: NbrInt.Integer;  sum: Value;  dot: Array1dRe.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -524,7 +524,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dRat.Array ): Array1dRe.Array;
+	OPERATOR "*"*( l: Array;  r: Array1dRat.Array ): Array1dRe.Array;
 	VAR i, k, dummy, rows: NbrInt.Integer;  sum: Value;  dot: Array1dRe.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -542,7 +542,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: Array1dInt.Array ): Array1dRe.Array;
+	OPERATOR "*"*( l: Array;  r: Array1dInt.Array ): Array1dRe.Array;
 	VAR i, k, dummy, rows: NbrInt.Integer;  sum: Value;  dot: Array1dRe.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -561,7 +561,7 @@ TYPE
 	END "*";
 
 (** Array-Array contractions,  returns  x = ATv = vTA  or x[i] = A[k, i] v[k] = v[k] A[k, i]  *)
-	PROCEDURE "*"*( l: Array1dRe.Array;  r: Array ): Array1dRe.Array;
+	OPERATOR "*"*( l: Array1dRe.Array;  r: Array ): Array1dRe.Array;
 	VAR i, k, cols, dummy: NbrInt.Integer;  sum: Value;  dot: Array1dRe.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -579,7 +579,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dRat.Array;  r: Array ): Array1dRe.Array;
+	OPERATOR "*"*( l: Array1dRat.Array;  r: Array ): Array1dRe.Array;
 	VAR i, k, cols, dummy: NbrInt.Integer;  sum: Value;  dot: Array1dRe.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -597,7 +597,7 @@ TYPE
 		RETURN dot
 	END "*";
 
-	PROCEDURE "*"*( l: Array1dInt.Array;  r: Array ): Array1dRe.Array;
+	OPERATOR "*"*( l: Array1dInt.Array;  r: Array ): Array1dRe.Array;
 	VAR i, k, cols, dummy: NbrInt.Integer;  sum: Value;  dot: Array1dRe.Array;
 	BEGIN
 		IF (l # NIL ) & (r # NIL ) THEN
@@ -616,7 +616,7 @@ TYPE
 	END "*";
 
 (** Scalar multiplications *)
-	PROCEDURE "*"*( l: NbrRe.Real;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrRe.Real;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -629,7 +629,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrRe.Real ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrRe.Real ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -642,7 +642,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRat.Rational;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrRat.Rational;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  left: NbrRe.Real;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -655,7 +655,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrRat.Rational ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrRat.Rational ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrRe.Real;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -668,7 +668,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt.Integer;  r: Array ): Array;
+	OPERATOR "*"*( l: NbrInt.Integer;  r: Array ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  left: NbrRe.Real;  prod: Array;
 	BEGIN
 		IF r # NIL THEN
@@ -681,7 +681,7 @@ TYPE
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "*"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrRe.Real;  prod: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -695,7 +695,7 @@ TYPE
 	END "*";
 
 (** Scalar divisions *)
-	PROCEDURE "/"*( l: Array;  r: NbrRe.Real ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrRe.Real ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -711,7 +711,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrRat.Rational ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrRat.Rational ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrRe.Real;  div: Array;
 	BEGIN
 		IF l # NIL THEN
@@ -728,7 +728,7 @@ TYPE
 		RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Array;  r: NbrInt.Integer ): Array;
+	OPERATOR "/"*( l: Array;  r: NbrInt.Integer ): Array;
 	VAR i, k, cols, rows: NbrInt.Integer;  right: NbrRe.Real;  div: Array;
 	BEGIN
 		IF l # NIL THEN

source/ArrayXdCplx.Mod

@@ -873,7 +873,7 @@ VAR
 		END;
 	END CopyArrayToArrayPartB;
 
-	PROCEDURE ":="*( VAR l: Array1;  r: Array );
+	OPERATOR ":="*( VAR l: Array1;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 1, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  *)
@@ -881,7 +881,7 @@ VAR
 		ArrayXdBytes.CopyArrayToMemory( r, ADDRESSOF( l[0] ), LEN( l, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array2;  r: Array );
+	OPERATOR ":="*( VAR l: Array2;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 2, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  *)
@@ -889,7 +889,7 @@ VAR
 		ArrayXdBytes.CopyArrayToMemory( r, ADDRESSOF( l[0, 0] ), LEN( l, 0 ) * LEN( l, 1 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array3;  r: Array );
+	OPERATOR ":="*( VAR l: Array3;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 3, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  ArrayXdBytes.CheckEQ( r.origin[2], 0 );  *)
@@ -898,7 +898,7 @@ VAR
 	END ":=";
 
 (*
-	PROCEDURE ":="( VAR l: Array4;  r: Array );
+	OPERATOR ":="( VAR l: Array4;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 4, r.dim );   (* ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  ArrayXdBytes.CheckEQ( r.origin[2], 0 );
@@ -915,24 +915,24 @@ VAR
 		Array1d.Fill( r, l.data^, 0, LEN( l.data ) );
 	END Fill;
 
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l # NIL THEN Fill( l, r ) END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: ArrayXdRe.Value );
+	OPERATOR ":="*( VAR l: Array;  r: ArrayXdRe.Value );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: ArrayXdRat.Value );
+	OPERATOR ":="*( VAR l: Array;  r: ArrayXdRat.Value );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: IntValue );
+	OPERATOR ":="*( VAR l: Array;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
@@ -943,7 +943,7 @@ VAR
 		ArrayXdBytes.CheckEqDimensions( l, r );  Array1d.AddAA( l.data^, r.data^, res.data^, 0, LEN( res.data ) );
 	END Add;
 
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  Add( l, r, res );  RETURN res;
@@ -954,7 +954,7 @@ VAR
 		ArrayXdBytes.CheckEqDimensions( l, r );  Array1d.SubtractAA( l.data^, r.data^, res.data^, 0, LEN( res.data ) );
 	END Sub;
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  Sub( l, r, res );  RETURN res;
@@ -983,27 +983,27 @@ VAR
 	END AddAV;
 
 (*
-	PROCEDURE "+"( l: Array;  r: Value ): Array;
+	OPERATOR "+"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  AddAV( l, r, res );  RETURN res;
 	END "+";
 *)
 
-	PROCEDURE "+"( l: Array;  r: IntValue ): Array;
+	OPERATOR "+"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;  r1: Value;
 	BEGIN
 		NEW( res, l.origin, l.len );  r1 := r;  AddAV( l, r1, res );  RETURN res;
 	END "+";
 
 (*
-	PROCEDURE "+"( l: Value;  r: Array ): Array;
+	OPERATOR "+"( l: Value;  r: Array ): Array;
 	BEGIN
 		RETURN r + l
 	END "+";
 *)
 
-	PROCEDURE "+"( l: IntValue;  r: Array ): Array;
+	OPERATOR "+"( l: IntValue;  r: Array ): Array;
 	BEGIN
 		RETURN r + l
 	END "+";
@@ -1014,25 +1014,25 @@ VAR
 	END MulAV;
 
 (*
-	PROCEDURE "*"( l: Array;  r: Value ): Array;
+	OPERATOR "*"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"( l: Value;  r: Array ): Array;
+	OPERATOR "*"( l: Value;  r: Array ): Array;
 	BEGIN
 		RETURN r * l
 	END "*";
 *)
 
-	PROCEDURE "*"( l: Array;  r: IntValue ): Array;
+	OPERATOR "*"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;  r1: Value;
 	BEGIN
 		NEW( res, l.origin, l.len );  r1 := r;  MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"( l: IntValue;  r: Array ): Array;
+	OPERATOR "*"( l: IntValue;  r: Array ): Array;
 	BEGIN
 		RETURN r * l
 	END "*";
@@ -1043,13 +1043,13 @@ VAR
 	END DivAV;
 
 (*
-	PROCEDURE "/"( l: Array;  r: Value ): Array;
+	OPERATOR "/"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"( l: Array;  r: IntValue ): Array;
+	OPERATOR "/"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;  r1: Value;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  r1 := r;  DivAV( l, r1, res );  RETURN res;
@@ -1062,13 +1062,13 @@ VAR
 	END DivVA;
 
 (*
-	PROCEDURE "/"( l: Value;  r: Array ): Array;
+	OPERATOR "/"( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"( l: IntValue;  r: Array ): Array;
+	OPERATOR "/"( l: IntValue;  r: Array ): Array;
 	VAR res: Array;  l1: Value;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  l1 := l;  DivVA( l1, r, res );  RETURN res;
@@ -1081,7 +1081,7 @@ VAR
 		Array1d.ModAV( l.data^, r, res.data^, 0, LEN( res.data ) );
 	END ModAV;
 
-	PROCEDURE "MOD"( l: Array;  r: Value ): Array;
+	OPERATOR "MOD"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  ModAV( l, r, res );  RETURN res;
@@ -1092,7 +1092,7 @@ VAR
 		Array1d.ModVA( l, r.data^, res.data^, 0, LEN( res.data ) );
 	END ModVA;
 
-	PROCEDURE "MOD"( l: Value;  r: Array ): Array;
+	OPERATOR "MOD"( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  ModVA( l, r, res );  RETURN res;
@@ -1105,13 +1105,13 @@ VAR
 	END SubAV;
 
 (*
-	PROCEDURE "-"( l: Array;  r: Value ): Array;
+	OPERATOR "-"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"( l: Array;  r: IntValue ): Array;
+	OPERATOR "-"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;  r1: Value;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  r1 := r;  SubAV( l, r1, res );  RETURN res;
@@ -1123,13 +1123,13 @@ VAR
 		Array1d.SubtractVA( l, r.data^, res.data^, 0, LEN( res.data ) );
 	END SubVA;
 
-	PROCEDURE "-"*( l: Value;  r: Array ): Array;
+	OPERATOR "-"*( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin, r.len );  SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Array ): Array;
+	OPERATOR "-"*( l: IntValue;  r: Array ): Array;
 	VAR res: Array;  l1: Value;
 	BEGIN
 		NEW( res, r.origin, r.len );  l1 := l;  SubVA( l1, r, res );  RETURN res;

source/ArrayXdInt.Mod

@@ -883,7 +883,7 @@ TYPE
 		END;
 	END CopyArrayToArrayPartB;
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(* IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN l := New4d( 0, LEN( r, 3 ), 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) );
@@ -892,7 +892,7 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0, 0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ) * LEN( r, 3 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*	IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN l := New3d( 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) );
@@ -902,7 +902,7 @@ TYPE
 	END ":=";
 
 (*
-	PROCEDURE ":="( VAR l: Array;  VAR r: ARRAY OF ARRAY OF Value );
+	OPERATOR ":="( VAR l: Array;  VAR r: ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN l := New2d( 0, LEN( r, 1 ), 0, LEN( r, 0 ) )
@@ -911,7 +911,7 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) );
 	END ":=";
 
-	PROCEDURE ":="( VAR l: Array;  VAR r: ARRAY OF Value );
+	OPERATOR ":="( VAR l: Array;  VAR r: ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN l := New1d( 0, LEN( r, 0 ) )
@@ -923,7 +923,7 @@ TYPE
 
 (***!never do this : *
 
-		PROCEDURE ":="( VAR l: Array;  r: Vector );
+		OPERATOR ":="( VAR l: Array;  r: Vector );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		IF l = NIL THEN NEW( l, r.origin^, r.len^ ) ELSE l.NewRangeX( r.origin^, r.len^, TRUE );  END;
@@ -931,7 +931,7 @@ TYPE
 	END ":=";
  *)
 
-	PROCEDURE ":="*( VAR l: Array1;  r: Array );
+	OPERATOR ":="*( VAR l: Array1;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 1, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  *)
@@ -939,7 +939,7 @@ TYPE
 		ArrayXdBytes.CopyArrayToMemory( r, ADDRESSOF( l[0] ), LEN( l, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array2;  r: Array );
+	OPERATOR ":="*( VAR l: Array2;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 2, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  *)
@@ -947,7 +947,7 @@ TYPE
 		ArrayXdBytes.CopyArrayToMemory( r, ADDRESSOF( l[0, 0] ), LEN( l, 0 ) * LEN( l, 1 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array3;  r: Array );
+	OPERATOR ":="*( VAR l: Array3;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 3, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  ArrayXdBytes.CheckEQ( r.origin[2], 0 );  *)
@@ -956,7 +956,7 @@ TYPE
 	END ":=";
 
 (*
-	PROCEDURE ":="( VAR l: Array4;  r: Array );
+	OPERATOR ":="( VAR l: Array4;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 4, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  ArrayXdBytes.CheckEQ( r.origin[2], 0 );
@@ -973,7 +973,7 @@ TYPE
 		Array1d.Fill( r, l.data^, 0, LEN( l.data ) );
 	END Fill;
 
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l # NIL THEN Fill( l, r ) END;
 	END ":=";
@@ -983,7 +983,7 @@ TYPE
 		ArrayXdBytes.CheckEqDimensions( l, r );  Array1d.AddAA( l.data^, r.data^, res.data^, 0, LEN( res.data ) );
 	END Add;
 
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  Add( l, r, res );  RETURN res;
@@ -994,7 +994,7 @@ TYPE
 		ArrayXdBytes.CheckEqDimensions( l, r );  Array1d.SubtractAA( l.data^, r.data^, res.data^, 0, LEN( res.data ) );
 	END Sub;
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len);  Sub( l, r, res );  RETURN res;
@@ -1020,13 +1020,13 @@ TYPE
 		Array1d.AddAV( l.data^, r, res.data^, 0, LEN( res.data ) );
 	END AddAV;
 
-	PROCEDURE "+"( l: Array;  r: Value ): Array;
+	OPERATOR "+"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"( l: Value;  r: Array ): Array;
+	OPERATOR "+"( l: Value;  r: Array ): Array;
 	BEGIN
 		RETURN r + l
 	END "+";
@@ -1036,13 +1036,13 @@ TYPE
 		Array1d.MultAV( l.data^, r, res.data^, 0, LEN( res.data ) );
 	END MulAV;
 
-	PROCEDURE "*"( l: Array;  r: Value ): Array;
+	OPERATOR "*"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"( l: Value;  r: Array ): Array;
+	OPERATOR "*"( l: Value;  r: Array ): Array;
 	BEGIN
 		RETURN r * l
 	END "*";
@@ -1053,7 +1053,7 @@ TYPE
 	END DivAV;
 
 (*
-	PROCEDURE "DIV"( l: Array;  r: Value ): Array;
+	OPERATOR "DIV"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  DivAV( l, r, res );  RETURN res;
@@ -1066,7 +1066,7 @@ TYPE
 	END DivVA;
 
 (*
-	PROCEDURE "DIV"( l: Value;  r: Array ): Array;
+	OPERATOR "DIV"( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  DivVA( l, r, res );  RETURN res;
@@ -1079,7 +1079,7 @@ TYPE
 	END ModAV;
 
 (*
-	PROCEDURE "MOD"( l: Array;  r: Value ): Array;
+	OPERATOR "MOD"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  ModAV( l, r, res );  RETURN res;
@@ -1092,7 +1092,7 @@ TYPE
 	END ModVA;
 
 (*
-	PROCEDURE "MOD"( l: Value;  r: Array ): Array;
+	OPERATOR "MOD"( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  ModVA( l, r, res );  RETURN res;
@@ -1105,7 +1105,7 @@ TYPE
 	END SubAV;
 
 (*
-	PROCEDURE "-"( l: Array;  r: Value ): Array;
+	OPERATOR "-"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  SubAV( l, r, res );  RETURN res;
@@ -1117,7 +1117,7 @@ TYPE
 		Array1d.SubtractVA( l, r.data^, res.data^, 0, LEN( res.data ) );
 	END SubVA;
 
-	PROCEDURE "-"*( l: Value;  r: Array ): Array;
+	OPERATOR "-"*( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin, r.len );  SubVA( l, r, res );  RETURN res;

source/ArrayXdRat.Mod

@@ -873,7 +873,7 @@ VAR
 		END;
 	END CopyArrayToArrayPartB;
 
-	PROCEDURE ":="*( VAR l: Array1;  r: Array );
+	OPERATOR ":="*( VAR l: Array1;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 1, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  *)
@@ -881,7 +881,7 @@ VAR
 		ArrayXdBytes.CopyArrayToMemory( r, ADDRESSOF( l[0] ), LEN( l, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array2;  r: Array );
+	OPERATOR ":="*( VAR l: Array2;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 2, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  *)
@@ -889,7 +889,7 @@ VAR
 		ArrayXdBytes.CopyArrayToMemory( r, ADDRESSOF( l[0, 0] ), LEN( l, 0 ) * LEN( l, 1 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array3;  r: Array );
+	OPERATOR ":="*( VAR l: Array3;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 3, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  ArrayXdBytes.CheckEQ( r.origin[2], 0 ); *)
@@ -898,7 +898,7 @@ VAR
 	END ":=";
 
 (*
-	PROCEDURE ":="( VAR l: Array4;  r: Array );
+	OPERATOR ":="( VAR l: Array4;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 4, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  ArrayXdBytes.CheckEQ( r.origin[2], 0 );
@@ -916,12 +916,12 @@ VAR
 	END Fill;
 
 (*
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l # NIL THEN Fill( l, r ) END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: IntValue );
+	OPERATOR ":="*( VAR l: Array;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 	  r1 := r; l := r1;
@@ -933,7 +933,7 @@ VAR
 		ArrayXdBytes.CheckEqDimensions( l, r );  Array1d.AddAA( l.data^, r.data^, res.data^, 0, LEN( res.data ) );
 	END Add;
 
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  Add( l, r, res );  RETURN res;
@@ -944,7 +944,7 @@ VAR
 		ArrayXdBytes.CheckEqDimensions( l, r );  Array1d.SubtractAA( l.data^, r.data^, res.data^, 0, LEN( res.data ) );
 	END Sub;
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  Sub( l, r, res );  RETURN res;
@@ -973,27 +973,27 @@ VAR
 	END AddAV;
 
 (*
-	PROCEDURE "+"( l: Array;  r: Value ): Array;
+	OPERATOR "+"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  AddAV( l, r, res );  RETURN res;
 	END "+";
 *)
 
-	PROCEDURE "+"( l: Array;  r: IntValue ): Array;
+	OPERATOR "+"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;  r1: Value;
 	BEGIN
 		NEW( res, l.origin, l.len );  r1 := r;  AddAV( l, r1, res );  RETURN res;
 	END "+";
 
 (*
-	PROCEDURE "+"( l: Value;  r: Array ): Array;
+	OPERATOR "+"( l: Value;  r: Array ): Array;
 	BEGIN
 		RETURN r + l
 	END "+";
 *)
 
-	PROCEDURE "+"( l: IntValue;  r: Array ): Array;
+	OPERATOR "+"( l: IntValue;  r: Array ): Array;
 	BEGIN
 		RETURN r + l
 	END "+";
@@ -1004,7 +1004,7 @@ VAR
 	END MulAV;
 
 (*
-	PROCEDURE "*"( l: Array;  r: Value ): Array;
+	OPERATOR "*"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  MulAV( l, r, res );  RETURN res;
@@ -1012,19 +1012,19 @@ VAR
 *)
 
 (*
-	PROCEDURE "*"( l: Value;  r: Array ): Array;
+	OPERATOR "*"( l: Value;  r: Array ): Array;
 	BEGIN
 		RETURN r * l
 	END "*";
 *)
 
-	PROCEDURE "*"( l: Array;  r: IntValue ): Array;
+	OPERATOR "*"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;  r1: Value;
 	BEGIN
 		NEW( res, l.origin, l.len );  r1 := r;  MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"( l: IntValue;  r: Array ): Array;
+	OPERATOR "*"( l: IntValue;  r: Array ): Array;
 	BEGIN
 		RETURN r * l
 	END "*";
@@ -1035,13 +1035,13 @@ VAR
 	END DivAV;
 
 (*
-	PROCEDURE "/"( l: Array;  r: Value ): Array;
+	OPERATOR "/"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"( l: Array;  r: IntValue ): Array;
+	OPERATOR "/"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;  r1: Value;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  r1 := r;  DivAV( l, r1, res );  RETURN res;
@@ -1054,14 +1054,14 @@ VAR
 	END DivVA;
 
 (*
-	PROCEDURE "/"( l: Value;  r: Array ): Array;
+	OPERATOR "/"( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  DivVA( l, r, res );  RETURN res;
 	END "/";
 *)
 
-	PROCEDURE "/"( l: IntValue;  r: Array ): Array;
+	OPERATOR "/"( l: IntValue;  r: Array ): Array;
 	VAR res: Array;  l1: Value;
 	BEGIN
 		NEW( res, r.origin, r.len );  l1 := l;  DivVA( l1, r, res );  RETURN res;
@@ -1073,7 +1073,7 @@ VAR
 		Array1d.ModAV( l.data^, r, res.data^, 0, LEN( res.data ) );
 	END ModAV;
 
-	PROCEDURE "MOD"( l: Array;  r: Value ): Array;
+	OPERATOR "MOD"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  ModAV( l, r, res );  RETURN res;
@@ -1084,7 +1084,7 @@ VAR
 		Array1d.ModVA( l, r.data^, res.data^, 0, LEN( res.data ) );
 	END ModVA;
 
-	PROCEDURE "MOD"( l: Value;  r: Array ): Array;
+	OPERATOR "MOD"( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  ModVA( l, r, res );  RETURN res;
@@ -1097,13 +1097,13 @@ VAR
 	END SubAV;
 
 (*
-	PROCEDURE "-"( l: Array;  r: Value ): Array;
+	OPERATOR "-"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"( l: Array;  r: IntValue ): Array;
+	OPERATOR "-"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;  r1: Value;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  r1 := r;  SubAV( l, r1, res );  RETURN res;
@@ -1115,13 +1115,13 @@ VAR
 		Array1d.SubtractVA( l, r.data^, res.data^, 0, LEN( res.data ) );
 	END SubVA;
 
-	PROCEDURE "-"*( l: Value;  r: Array ): Array;
+	OPERATOR "-"*( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin, r.len );  SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Array ): Array;
+	OPERATOR "-"*( l: IntValue;  r: Array ): Array;
 	VAR res: Array;  l1: Value;
 	BEGIN
 		NEW( res, r.origin, r.len );  l1 := l;  SubVA( l1, r, res );  RETURN res;

source/ArrayXdRe.Mod

@@ -864,7 +864,7 @@ TYPE
 		END;
 	END CopyArrayToArrayPartB;
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(* IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN l := New4d( 0, LEN( r, 3 ), 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) );
@@ -873,7 +873,7 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0, 0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ) * LEN( r, 3 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Array;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*	IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN l := New3d( 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) );
@@ -883,7 +883,7 @@ TYPE
 	END ":=";
 
 (*
-	PROCEDURE ":="( VAR l: Array;  VAR r: ARRAY OF ARRAY OF Value );
+	OPERATOR ":="( VAR l: Array;  VAR r: ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN l := New2d( 0, LEN( r, 1 ), 0, LEN( r, 0 ) )
@@ -892,7 +892,7 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) );
 	END ":=";
 
-	PROCEDURE ":="( VAR l: Array;  VAR r: ARRAY OF Value );
+	OPERATOR ":="( VAR l: Array;  VAR r: ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN l := New1d( 0, LEN( r, 0 ) )
@@ -901,7 +901,7 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0] ), l, LEN( r, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="( VAR l: Array;  r: ArrayXdInt.Array );
+	OPERATOR ":="( VAR l: Array;  r: ArrayXdInt.Array );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -911,7 +911,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="( VAR l: Array;  r: ArrayXdRat.Array );
+	OPERATOR ":="( VAR l: Array;  r: ArrayXdRat.Array );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -924,14 +924,14 @@ TYPE
 
 (***!never do this : *
 
-		PROCEDURE ":="( VAR l: Array;  r: Vector );
+		OPERATOR ":="( VAR l: Array;  r: Vector );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		IF l = NIL THEN NEW( l, r.origin^, r.len^ ) ELSE l.NewRangeX( r.origin^, r.len^, TRUE );  END;
 		r.CopyElements( r.origin^, r.len^, l, l.origin^, l.len^ );
 	END ":=";
  *)
-	PROCEDURE ":="*( VAR l: Array1;  r: Array );
+	OPERATOR ":="*( VAR l: Array1;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 1, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  *)
@@ -939,7 +939,7 @@ TYPE
 		ArrayXdBytes.CopyArrayToMemory( r, ADDRESSOF( l[0] ), LEN( l, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array2;  r: Array );
+	OPERATOR ":="*( VAR l: Array2;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 2, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  *)
@@ -947,7 +947,7 @@ TYPE
 		ArrayXdBytes.CopyArrayToMemory( r, ADDRESSOF( l[0, 0] ), LEN( l, 0 ) * LEN( l, 1 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array3;  r: Array );
+	OPERATOR ":="*( VAR l: Array3;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 3, r.dim );   (*ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  ArrayXdBytes.CheckEQ( r.origin[2], 0 );  *)
@@ -956,7 +956,7 @@ TYPE
 	END ":=";
 
 (*
-	PROCEDURE ":="( VAR l: Array4;  r: Array );
+	OPERATOR ":="( VAR l: Array4;  r: Array );
 	BEGIN
 		IF r = NIL THEN l := NIL;  RETURN END;
 		ArrayXdBytes.CheckEQ( 4, r.dim );   (* ArrayXdBytes.CheckEQ( r.origin[0], 0 );  ArrayXdBytes.CheckEQ( r.origin[1], 0 );  ArrayXdBytes.CheckEQ( r.origin[2], 0 );
@@ -973,18 +973,18 @@ TYPE
 		Array1d.Fill( r, l.data^, 0, LEN( l.data ) );
 	END Fill;
 
-	PROCEDURE ":="*( VAR l: Array;  r: Value );
+	OPERATOR ":="*( VAR l: Array;  r: Value );
 	BEGIN
 		IF l # NIL THEN Fill( l, r ) END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: ArrayXdRat.Value );
+	OPERATOR ":="*( VAR l: Array;  r: ArrayXdRat.Value );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Array;  r: IntValue );
+	OPERATOR ":="*( VAR l: Array;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
@@ -995,7 +995,7 @@ TYPE
 		ArrayXdBytes.CheckEqDimensions( l, r );  Array1d.AddAA( l.data^, r.data^, res.data^, 0, LEN( res.data ) );
 	END Add;
 
-	PROCEDURE "+"*( l, r: Array ): Array;
+	OPERATOR "+"*( l, r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  Add( l, r, res );  RETURN res;
@@ -1006,7 +1006,7 @@ TYPE
 		ArrayXdBytes.CheckEqDimensions( l, r );  Array1d.SubtractAA( l.data^, r.data^, res.data^, 0, LEN( res.data ) );
 	END Sub;
 
-	PROCEDURE "-"*( l, r: Array ): Array;
+	OPERATOR "-"*( l, r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  Sub( l, r, res );  RETURN res;
@@ -1034,27 +1034,27 @@ TYPE
 		Array1d.AddAV( l.data^, r, res.data^, 0, LEN( res.data ) );
 	END AddAV;
 
-	PROCEDURE "+"( l: Array;  r: Value ): Array;
+	OPERATOR "+"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  AddAV( l, r, res );  RETURN res;
 	END "+";
 
 (*
-	PROCEDURE "+"( l: Array;  r: IntValue ): Array;
+	OPERATOR "+"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  AddAV( l, r, res );  RETURN res;
 	END "+";
 *)
 
-	PROCEDURE "+"( l: Value;  r: Array ): Array;
+	OPERATOR "+"( l: Value;  r: Array ): Array;
 	BEGIN
 		RETURN r + l
 	END "+";
 
 (*
-	PROCEDURE "+"( l: IntValue;  r: Array ): Array;
+	OPERATOR "+"( l: IntValue;  r: Array ): Array;
 	BEGIN
 		RETURN r + l
 	END "+";
@@ -1065,25 +1065,25 @@ TYPE
 		Array1d.MultAV( l.data^, r, res.data^, 0, LEN( res.data ) );
 	END MulAV;
 
-	PROCEDURE "*"( l: Array;  r: Value ): Array;
+	OPERATOR "*"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin, l.len );  MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"( l: Value;  r: Array ): Array;
+	OPERATOR "*"( l: Value;  r: Array ): Array;
 	BEGIN
 		RETURN r * l
 	END "*";
 
 (*
-	PROCEDURE "*"( l: Array;  r: IntValue ): Array;
+	OPERATOR "*"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"( l: IntValue;  r: Array ): Array;
+	OPERATOR "*"( l: IntValue;  r: Array ): Array;
 	BEGIN
 		RETURN r * l
 	END "*";
@@ -1095,13 +1095,13 @@ TYPE
 	END DivAV;
 
 (*
-	PROCEDURE "/"( l: Array;  r: Value ): Array;
+	OPERATOR "/"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"( l: Array;  r: IntValue ): Array;
+	OPERATOR "/"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  DivAV( l, r, res );  RETURN res;
@@ -1114,13 +1114,13 @@ TYPE
 	END DivVA;
 
 (*
-	PROCEDURE "/"( l: Value;  r: Array ): Array;
+	OPERATOR "/"( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"( l: IntValue;  r: Array ): Array;
+	OPERATOR "/"( l: IntValue;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  DivVA( l, r, res );  RETURN res;
@@ -1133,7 +1133,7 @@ TYPE
 		Array1d.ModAV( l.data^, r, res.data^, 0, LEN( res.data ) );
 	END ModAV;
 
-	PROCEDURE "MOD"( l: Array;  r: Value ): Array;
+	OPERATOR "MOD"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  ModAV( l, r, res );  RETURN res;
@@ -1144,7 +1144,7 @@ TYPE
 		Array1d.ModVA( l, r.data^, res.data^, 0, LEN( res.data ) );
 	END ModVA;
 
-	PROCEDURE "MOD"( l: Value;  r: Array ): Array;
+	OPERATOR "MOD"( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin^, r.len^ );  ModVA( l, r, res );  RETURN res;
@@ -1157,13 +1157,13 @@ TYPE
 	END SubAV;
 
 (*
-	PROCEDURE "-"( l: Array;  r: Value ): Array;
+	OPERATOR "-"( l: Array;  r: Value ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"( l: Array;  r: IntValue ): Array;
+	OPERATOR "-"( l: Array;  r: IntValue ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, l.origin^, l.len^ );  SubAV( l, r, res );  RETURN res;
@@ -1175,13 +1175,13 @@ TYPE
 		Array1d.SubtractVA( l, r.data^, res.data^, 0, LEN( res.data ) );
 	END SubVA;
 
-	PROCEDURE "-"*( l: Value;  r: Array ): Array;
+	OPERATOR "-"*( l: Value;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin, r.len );  SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Array ): Array;
+	OPERATOR "-"*( l: IntValue;  r: Array ): Array;
 	VAR res: Array;
 	BEGIN
 		NEW( res, r.origin, r.len );  SubVA( l, r, res );  RETURN res;

source/CubeCplx.Mod

@@ -235,14 +235,14 @@ TYPE
 
 	END Cube;
 
-	PROCEDURE ":="*( VAR l: Cube;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Cube;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*	IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) );  ELSE l.NewRange( 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: CubeInt.Cube );
+	OPERATOR ":="*( VAR l: Cube;  r: CubeInt.Cube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -252,7 +252,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: CubeRat.Cube );
+	OPERATOR ":="*( VAR l: Cube;  r: CubeRat.Cube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -262,7 +262,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: CubeRe.Cube );
+	OPERATOR ":="*( VAR l: Cube;  r: CubeRe.Cube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -272,225 +272,225 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: Value );
+	OPERATOR ":="*( VAR l: Cube;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: ReValue );
+	OPERATOR ":="*( VAR l: Cube;  r: ReValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: RatValue );
+	OPERATOR ":="*( VAR l: Cube;  r: RatValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: IntValue );
+	OPERATOR ":="*( VAR l: Cube;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Cube ): Cube;
+	OPERATOR "+"*( l, r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Cube ): Cube;
+	OPERATOR "-"*( l, r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "+"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "+"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Cube;  r: RatValue ): Cube;
+	OPERATOR "+"*( l: Cube;  r: RatValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Cube;  r: ReValue ): Cube;
+	OPERATOR "+"*( l: Cube;  r: ReValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "+"*( l: Value;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: ReValue;  r: Cube ): Cube;
+	OPERATOR "+"*( l: ReValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: RatValue;  r: Cube ): Cube;
+	OPERATOR "+"*( l: RatValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "+"*( l: IntValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "-"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube;  r: ReValue ): Cube;
+	OPERATOR "-"*( l: Cube;  r: ReValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube;  r: RatValue ): Cube;
+	OPERATOR "-"*( l: Cube;  r: RatValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "-"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "-"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: ReValue;  r: Cube ): Cube;
+	OPERATOR "-"*( l: ReValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: RatValue;  r: Cube ): Cube;
+	OPERATOR "-"*( l: RatValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "-"*( l: IntValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube ): Cube;
+	OPERATOR "-"*( l: Cube ): Cube;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "*"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Cube;  r: ReValue ): Cube;
+	OPERATOR "*"*( l: Cube;  r: ReValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Cube;  r: RatValue ): Cube;
+	OPERATOR "*"*( l: Cube;  r: RatValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "*"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "*"*( l: Value;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: ReValue;  r: Cube ): Cube;
+	OPERATOR "*"*( l: ReValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: RatValue;  r: Cube ): Cube;
+	OPERATOR "*"*( l: RatValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "*"*( l: IntValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "/"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Cube;  r: ReValue ): Cube;
+	OPERATOR "/"*( l: Cube;  r: ReValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Cube;  r: RatValue ): Cube;
+	OPERATOR "/"*( l: Cube;  r: RatValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "/"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "/"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: ReValue;  r: Cube ): Cube;
+	OPERATOR "/"*( l: ReValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: RatValue;  r: Cube ): Cube;
+	OPERATOR "/"*( l: RatValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "/"*( l: IntValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;

source/CubeInt.Mod

@@ -233,88 +233,88 @@ TYPE
 
 	END Cube;
 
-	PROCEDURE ":="*( VAR l: Cube;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Cube;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*	IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) );  ELSE l.NewRange( 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: Value );
+	OPERATOR ":="*( VAR l: Cube;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Cube ): Cube;
+	OPERATOR "+"*( l, r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Cube ): Cube;
+	OPERATOR "-"*( l, r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "+"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "+"*( l: Value;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "-"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "-"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube ): Cube;
+	OPERATOR "-"*( l: Cube ): Cube;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "*"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "*"*( l: Value;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "DIV"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "DIV"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "DIV";
 
-	PROCEDURE "DIV"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "DIV"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "DIV";
 
-	PROCEDURE "MOD"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "MOD"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "MOD"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;

source/CubeRat.Mod

@@ -233,14 +233,14 @@ TYPE
 
 	END Cube;
 
-	PROCEDURE ":="*( VAR l: Cube;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Cube;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*	IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) );  ELSE l.NewRange( 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: CubeInt.Cube );
+	OPERATOR ":="*( VAR l: Cube;  r: CubeInt.Cube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -250,121 +250,121 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: Value );
+	OPERATOR ":="*( VAR l: Cube;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: IntValue );
+	OPERATOR ":="*( VAR l: Cube;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Cube ): Cube;
+	OPERATOR "+"*( l, r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Cube ): Cube;
+	OPERATOR "-"*( l, r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "+"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "+"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "+"*( l: Value;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "+"*( l: IntValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "-"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "-"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "-"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "-"*( l: IntValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube ): Cube;
+	OPERATOR "-"*( l: Cube ): Cube;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "*"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "*"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "*"*( l: Value;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "*"*( l: IntValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "/"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "/"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "/"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "/"*( l: IntValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;

source/CubeRe.Mod

@@ -234,14 +234,14 @@ TYPE
 
 	END Cube;
 
-	PROCEDURE ":="*( VAR l: Cube;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Cube;  VAR r: ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*	IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) );  ELSE l.NewRange( 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: CubeInt.Cube );
+	OPERATOR ":="*( VAR l: Cube;  r: CubeInt.Cube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -251,7 +251,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: CubeRat.Cube );
+	OPERATOR ":="*( VAR l: Cube;  r: CubeRat.Cube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -261,173 +261,173 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: Value );
+	OPERATOR ":="*( VAR l: Cube;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: RatValue );
+	OPERATOR ":="*( VAR l: Cube;  r: RatValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Cube;  r: IntValue );
+	OPERATOR ":="*( VAR l: Cube;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Cube ): Cube;
+	OPERATOR "+"*( l, r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Cube ): Cube;
+	OPERATOR "-"*( l, r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "+"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "+"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Cube;  r: RatValue ): Cube;
+	OPERATOR "+"*( l: Cube;  r: RatValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "+"*( l: Value;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: RatValue;  r: Cube ): Cube;
+	OPERATOR "+"*( l: RatValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "+"*( l: IntValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "-"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube;  r: RatValue ): Cube;
+	OPERATOR "-"*( l: Cube;  r: RatValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "-"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "-"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: RatValue;  r: Cube ): Cube;
+	OPERATOR "-"*( l: RatValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "-"*( l: IntValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Cube ): Cube;
+	OPERATOR "-"*( l: Cube ): Cube;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "*"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Cube;  r: RatValue ): Cube;
+	OPERATOR "*"*( l: Cube;  r: RatValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "*"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "*"*( l: Value;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: RatValue;  r: Cube ): Cube;
+	OPERATOR "*"*( l: RatValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "*"*( l: IntValue;  r: Cube ): Cube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Cube;  r: Value ): Cube;
+	OPERATOR "/"*( l: Cube;  r: Value ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Cube;  r: RatValue ): Cube;
+	OPERATOR "/"*( l: Cube;  r: RatValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Cube;  r: IntValue ): Cube;
+	OPERATOR "/"*( l: Cube;  r: IntValue ): Cube;
 	VAR res: Cube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Cube ): Cube;
+	OPERATOR "/"*( l: Value;  r: Cube ): Cube;
 	VAR res: Cube;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: RatValue;  r: Cube ): Cube;
+	OPERATOR "/"*( l: RatValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Cube ): Cube;
+	OPERATOR "/"*( l: IntValue;  r: Cube ): Cube;
 	VAR res: Cube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;

source/Data.Mod

@@ -88,74 +88,74 @@ VAR
 
 
 	(** Assignment operators for Keys. *)
-	PROCEDURE ":="*( VAR l: Key;  r: NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Key;  r: NbrInt.Integer );
 	BEGIN
 		l.k := r
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Key;  r: NbrInt64.Integer );
+	OPERATOR ":="*( VAR l: Key;  r: NbrInt64.Integer );
 	BEGIN
 		l.k := r
 	END ":=";
 
 (** Comparison Operators between Keys. *)
-	PROCEDURE "="*( l, r: Key ): BOOLEAN;
+	OPERATOR "="*( l, r: Key ): BOOLEAN;
 	BEGIN
 		RETURN l.k = r.k
 	END "=";
 
-	PROCEDURE "#"*( l, r: Key ): BOOLEAN;
+	OPERATOR "#"*( l, r: Key ): BOOLEAN;
 	BEGIN
 		RETURN l.k # r.k
 	END "#";
 
-	PROCEDURE "<"*( l, r: Key ): BOOLEAN;
+	OPERATOR "<"*( l, r: Key ): BOOLEAN;
 	BEGIN
 		RETURN l.k < r.k
 	END "<";
 
-	PROCEDURE ">"*( l, r: Key ): BOOLEAN;
+	OPERATOR ">"*( l, r: Key ): BOOLEAN;
 	BEGIN
 		RETURN l.k > r.k
 	END ">";
 
-	PROCEDURE "<="*( l, r: Key ): BOOLEAN;
+	OPERATOR "<="*( l, r: Key ): BOOLEAN;
 	BEGIN
 		RETURN l.k <= r.k
 	END "<=";
 
-	PROCEDURE ">="*( l, r: Key ): BOOLEAN;
+	OPERATOR ">="*( l, r: Key ): BOOLEAN;
 	BEGIN
 		RETURN l.k >= r.k
 	END ">=";
 
 (** Comparison Operators between Data. *)
-	PROCEDURE "="*( l, r: Datum ): BOOLEAN;
+	OPERATOR "="*( l, r: Datum ): BOOLEAN;
 	BEGIN
 		RETURN l.key = r.key
 	END "=";
 
-	PROCEDURE "#"*( l, r: Datum ): BOOLEAN;
+	OPERATOR "#"*( l, r: Datum ): BOOLEAN;
 	BEGIN
 		RETURN l.key # r.key
 	END "#";
 
-	PROCEDURE "<"*( l, r: Datum ): BOOLEAN;
+	OPERATOR "<"*( l, r: Datum ): BOOLEAN;
 	BEGIN
 		RETURN l.key < r.key
 	END "<";
 
-	PROCEDURE ">"*( l, r: Datum ): BOOLEAN;
+	OPERATOR ">"*( l, r: Datum ): BOOLEAN;
 	BEGIN
 		RETURN l.key > r.key
 	END ">";
 
-	PROCEDURE "<="*( l, r: Datum ): BOOLEAN;
+	OPERATOR "<="*( l, r: Datum ): BOOLEAN;
 	BEGIN
 		RETURN l.key <= r.key
 	END "<=";
 
-	PROCEDURE ">="*( l, r: Datum ): BOOLEAN;
+	OPERATOR ">="*( l, r: Datum ): BOOLEAN;
 	BEGIN
 		RETURN l.key >= r.key
 	END ">=";

source/HCubeCplx.Mod

@@ -240,7 +240,7 @@ TYPE
 
 	END HCube;
 
-	PROCEDURE ":="*( VAR l: HCube;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: HCube;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(* IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 3 ), 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) )
@@ -249,7 +249,7 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ) * LEN( r, 3 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: HCubeInt.HCube );
+	OPERATOR ":="*( VAR l: HCube;  r: HCubeInt.HCube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -259,7 +259,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: HCubeRat.HCube );
+	OPERATOR ":="*( VAR l: HCube;  r: HCubeRat.HCube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -269,7 +269,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: HCubeRe.HCube );
+	OPERATOR ":="*( VAR l: HCube;  r: HCubeRe.HCube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -279,225 +279,225 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: Value );
+	OPERATOR ":="*( VAR l: HCube;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: ReValue );
+	OPERATOR ":="*( VAR l: HCube;  r: ReValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: RatValue );
+	OPERATOR ":="*( VAR l: HCube;  r: RatValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: IntValue );
+	OPERATOR ":="*( VAR l: HCube;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: HCube ): HCube;
+	OPERATOR "+"*( l, r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: HCube ): HCube;
+	OPERATOR "-"*( l, r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "+"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: HCube;  r: ReValue ): HCube;
+	OPERATOR "+"*( l: HCube;  r: ReValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: HCube;  r: RatValue ): HCube;
+	OPERATOR "+"*( l: HCube;  r: RatValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "+"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "+"*( l: Value;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: ReValue;  r: HCube ): HCube;
+	OPERATOR "+"*( l: ReValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: RatValue;  r: HCube ): HCube;
+	OPERATOR "+"*( l: RatValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "+"*( l: IntValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "-"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube;  r: ReValue ): HCube;
+	OPERATOR "-"*( l: HCube;  r: ReValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube;  r: RatValue ): HCube;
+	OPERATOR "-"*( l: HCube;  r: RatValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "-"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "-"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: ReValue;  r: HCube ): HCube;
+	OPERATOR "-"*( l: ReValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: RatValue;  r: HCube ): HCube;
+	OPERATOR "-"*( l: RatValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "-"*( l: IntValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube ): HCube;
+	OPERATOR "-"*( l: HCube ): HCube;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "*"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: HCube;  r: ReValue ): HCube;
+	OPERATOR "*"*( l: HCube;  r: ReValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: HCube;  r: RatValue ): HCube;
+	OPERATOR "*"*( l: HCube;  r: RatValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "*"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "*"*( l: Value;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: ReValue;  r: HCube ): HCube;
+	OPERATOR "*"*( l: ReValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: RatValue;  r: HCube ): HCube;
+	OPERATOR "*"*( l: RatValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "*"*( l: IntValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "/"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: HCube;  r: ReValue ): HCube;
+	OPERATOR "/"*( l: HCube;  r: ReValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: HCube;  r: RatValue ): HCube;
+	OPERATOR "/"*( l: HCube;  r: RatValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "/"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "/"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: ReValue;  r: HCube ): HCube;
+	OPERATOR "/"*( l: ReValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: RatValue;  r: HCube ): HCube;
+	OPERATOR "/"*( l: RatValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "/"*( l: IntValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;

source/HCubeInt.Mod

@@ -239,7 +239,7 @@ TYPE
 
 	END HCube;
 
-	PROCEDURE ":="*( VAR l: HCube;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: HCube;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(* IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 3 ), 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) )
@@ -248,81 +248,81 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ) * LEN( r, 3 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: Value );
+	OPERATOR ":="*( VAR l: HCube;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: HCube ): HCube;
+	OPERATOR "+"*( l, r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: HCube ): HCube;
+	OPERATOR "-"*( l, r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "+"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "+"*( l: Value;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "-"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "-"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube ): HCube;
+	OPERATOR "-"*( l: HCube ): HCube;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "*"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "*"*( l: Value;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "DIV"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "DIV"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "DIV";
 
-	PROCEDURE "DIV"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "DIV"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "DIV";
 
-	PROCEDURE "MOD"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "MOD"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "MOD"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;

source/HCubeRat.Mod

@@ -240,7 +240,7 @@ TYPE
 
 	END HCube;
 
-	PROCEDURE ":="*( VAR l: HCube;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: HCube;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(* IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 3 ), 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) )
@@ -249,7 +249,7 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ) * LEN( r, 3 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: HCubeInt.HCube );
+	OPERATOR ":="*( VAR l: HCube;  r: HCubeInt.HCube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -259,121 +259,121 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: Value );
+	OPERATOR ":="*( VAR l: HCube;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: IntValue );
+	OPERATOR ":="*( VAR l: HCube;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: HCube ): HCube;
+	OPERATOR "+"*( l, r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: HCube ): HCube;
+	OPERATOR "-"*( l, r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "+"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "+"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "+"*( l: Value;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "+"*( l: IntValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "-"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "-"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "-"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "-"*( l: IntValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube ): HCube;
+	OPERATOR "-"*( l: HCube ): HCube;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "*"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "*"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "*"*( l: Value;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "*"*( l: IntValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "/"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "/"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "/"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "/"*( l: IntValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;

source/HCubeRe.Mod

@@ -241,7 +241,7 @@ TYPE
 
 	END HCube;
 
-	PROCEDURE ":="*( VAR l: HCube;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: HCube;  VAR r: ARRAY OF ARRAY OF ARRAY OF ARRAY OF Value );
 	BEGIN
 		(* IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 3 ), 0, LEN( r, 2 ), 0, LEN( r, 1 ), 0, LEN( r, 0 ) )
@@ -250,7 +250,7 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0, 0, 0] ), l, LEN( r, 0 ) * LEN( r, 1 ) * LEN( r, 2 ) * LEN( r, 3 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: HCubeInt.HCube );
+	OPERATOR ":="*( VAR l: HCube;  r: HCubeInt.HCube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -260,7 +260,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: HCubeRat.HCube );
+	OPERATOR ":="*( VAR l: HCube;  r: HCubeRat.HCube );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -270,173 +270,173 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: Value );
+	OPERATOR ":="*( VAR l: HCube;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: RatValue );
+	OPERATOR ":="*( VAR l: HCube;  r: RatValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: HCube;  r: IntValue );
+	OPERATOR ":="*( VAR l: HCube;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: HCube ): HCube;
+	OPERATOR "+"*( l, r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: HCube ): HCube;
+	OPERATOR "-"*( l, r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "+"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: HCube;  r: RatValue ): HCube;
+	OPERATOR "+"*( l: HCube;  r: RatValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "+"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "+"*( l: Value;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: RatValue;  r: HCube ): HCube;
+	OPERATOR "+"*( l: RatValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "+"*( l: IntValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "-"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube;  r: RatValue ): HCube;
+	OPERATOR "-"*( l: HCube;  r: RatValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "-"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "-"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: RatValue;  r: HCube ): HCube;
+	OPERATOR "-"*( l: RatValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "-"*( l: IntValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: HCube ): HCube;
+	OPERATOR "-"*( l: HCube ): HCube;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "*"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: HCube;  r: RatValue ): HCube;
+	OPERATOR "*"*( l: HCube;  r: RatValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "*"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "*"*( l: Value;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: RatValue;  r: HCube ): HCube;
+	OPERATOR "*"*( l: RatValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "*"*( l: IntValue;  r: HCube ): HCube;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: HCube;  r: Value ): HCube;
+	OPERATOR "/"*( l: HCube;  r: Value ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: HCube;  r: RatValue ): HCube;
+	OPERATOR "/"*( l: HCube;  r: RatValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: HCube;  r: IntValue ): HCube;
+	OPERATOR "/"*( l: HCube;  r: IntValue ): HCube;
 	VAR res: HCube;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: HCube ): HCube;
+	OPERATOR "/"*( l: Value;  r: HCube ): HCube;
 	VAR res: HCube;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: RatValue;  r: HCube ): HCube;
+	OPERATOR "/"*( l: RatValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: HCube ): HCube;
+	OPERATOR "/"*( l: IntValue;  r: HCube ): HCube;
 	VAR res: HCube;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;

source/I386.NbrInt64.Mod

@@ -28,218 +28,218 @@ CONST
 	END Compare;
 
 (** Comparison Operators*)
-	PROCEDURE ">"*( a, b: Integer ): BOOLEAN;
+	OPERATOR ">"*( a, b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Compare() = Gt
 	END ">";
 
-	PROCEDURE ">"*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
+	OPERATOR ">"*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a > Long( b )
 	END ">";
 
-	PROCEDURE ">"*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
+	OPERATOR ">"*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a > Long( NbrInt32.Long( b ) )
 	END ">";
 
-	PROCEDURE ">"*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
+	OPERATOR ">"*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a > Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END ">";
 
-	PROCEDURE ">"*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR ">"*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( a ) > b
 	END ">";
 
-	PROCEDURE ">"*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR ">"*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) > b
 	END ">";
 
-	PROCEDURE ">"*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR ">"*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) > b
 	END ">";
 
-	PROCEDURE ">="*( a, b: Integer ): BOOLEAN;
+	OPERATOR ">="*( a, b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Compare() # Lt
 	END ">=";
 
-	PROCEDURE ">="*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
+	OPERATOR ">="*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a >= Long( b )
 	END ">=";
 
-	PROCEDURE ">="*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
+	OPERATOR ">="*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a >= Long( NbrInt32.Long( b ) )
 	END ">=";
 
-	PROCEDURE ">="*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
+	OPERATOR ">="*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a >= Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END ">=";
 
-	PROCEDURE ">="*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR ">="*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( a ) >= b
 	END ">=";
 
-	PROCEDURE ">="*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR ">="*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) >= b
 	END ">=";
 
-	PROCEDURE ">="*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR ">="*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) >= b
 	END ">=";
 
-	PROCEDURE "<"*( a, b: Integer ): BOOLEAN;
+	OPERATOR "<"*( a, b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Compare() = Lt
 	END "<";
 
-	PROCEDURE "<"*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
+	OPERATOR "<"*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a < Long( b )
 	END "<";
 
-	PROCEDURE "<"*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
+	OPERATOR "<"*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a < Long( NbrInt32.Long( b ) )
 	END "<";
 
-	PROCEDURE "<"*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
+	OPERATOR "<"*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a < Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "<";
 
-	PROCEDURE "<"*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "<"*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( a ) < b
 	END "<";
 
-	PROCEDURE "<"*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "<"*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) < b
 	END "<";
 
-	PROCEDURE "<"*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "<"*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) < b
 	END "<";
 
-	PROCEDURE "<="*( a, b: Integer ): BOOLEAN;
+	OPERATOR "<="*( a, b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Compare() # Gt
 	END "<=";
 
-	PROCEDURE "<="*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
+	OPERATOR "<="*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a <= Long( b )
 	END "<=";
 
-	PROCEDURE "<="*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
+	OPERATOR "<="*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a <= Long( NbrInt32.Long( b ) )
 	END "<=";
 
-	PROCEDURE "<="*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
+	OPERATOR "<="*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a <= Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "<=";
 
-	PROCEDURE "<="*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "<="*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( a ) <= b
 	END "<=";
 
-	PROCEDURE "<="*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "<="*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) <= b
 	END "<=";
 
-	PROCEDURE "<="*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "<="*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) <= b
 	END "<=";
 
-	PROCEDURE "="*( a, b: Integer ): BOOLEAN;
+	OPERATOR "="*( a, b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Compare() = Eq
 	END "=";
 
-	PROCEDURE "="*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
+	OPERATOR "="*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a = Long( b )
 	END "=";
 
-	PROCEDURE "="*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
+	OPERATOR "="*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a = Long( NbrInt32.Long( b ) )
 	END "=";
 
-	PROCEDURE "="*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
+	OPERATOR "="*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a = Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "=";
 
-	PROCEDURE "="*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "="*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( a ) = b
 	END "=";
 
-	PROCEDURE "="*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "="*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) = b
 	END "=";
 
-	PROCEDURE "="*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "="*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) = b
 	END "=";
 
-	PROCEDURE "#"*( a, b: Integer ): BOOLEAN;
+	OPERATOR "#"*( a, b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Compare() # Eq
 	END "#";
 
-	PROCEDURE "#"*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
+	OPERATOR "#"*( a: Integer;  b: NbrInt32.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a # Long( b )
 	END "#";
 
-	PROCEDURE "#"*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
+	OPERATOR "#"*( a: Integer;  b: NbrInt16.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a # Long( NbrInt32.Long( b ) )
 	END "#";
 
-	PROCEDURE "#"*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
+	OPERATOR "#"*( a: Integer;  b: NbrInt8.Integer ): BOOLEAN;
 	BEGIN
 		RETURN a # Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "#";
 
-	PROCEDURE "#"*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "#"*( a: NbrInt32.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( a ) # b
 	END "#";
 
-	PROCEDURE "#"*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "#"*( a: NbrInt16.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) # b
 	END "#";
 
-	PROCEDURE "#"*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
+	OPERATOR "#"*( a: NbrInt8.Integer;  b: Integer ): BOOLEAN;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) # b
 	END "#";
 
 (** Monadic Arithmetic Operators*)
-	PROCEDURE "-"*( a: Integer ): Integer;
+	OPERATOR "-"*( a: Integer ): Integer;
 	CODE {SYSTEM.i386, SYSTEM.FPU}
 		MOV	EAX, [EBP+12]
 		MOV	EBX, [EBP+8]
@@ -252,24 +252,24 @@ CONST
 	END "-";
 
 (** Dyadic Assignment Operators *)
-	PROCEDURE ":="*( VAR a: Integer;  b: NbrInt32.Integer );
+	OPERATOR ":="*( VAR a: Integer;  b: NbrInt32.Integer );
 	BEGIN
 		a := Long( b )
 	END ":=";
 
-	PROCEDURE ":="*( VAR a: Integer;  b: NbrInt16.Integer );
+	OPERATOR ":="*( VAR a: Integer;  b: NbrInt16.Integer );
 	BEGIN
 		a := Long( NbrInt32.Long( b ) )
 	END ":=";
 
-	PROCEDURE ":="*( VAR a: Integer;  b: NbrInt8.Integer );
+	OPERATOR ":="*( VAR a: Integer;  b: NbrInt8.Integer );
 	BEGIN
 		a := Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END ":=";
 
 	(** Dyadic Arithmetic Operators*)
 (*ASM Version *)
-	PROCEDURE "+"*( a, b: Integer ): Integer;
+	OPERATOR "+"*( a, b: Integer ): Integer;
 	CODE {SYSTEM.i386}
 		MOV	EAX, [EBP+16]
 		MOV	EBX, [EBP+20]
@@ -280,38 +280,38 @@ CONST
 		MOV	[EDX+4], EBX
 	END "+";
 
-	PROCEDURE "+"*( a: Integer;  b: NbrInt32.Integer ): Integer;
+	OPERATOR "+"*( a: Integer;  b: NbrInt32.Integer ): Integer;
 	BEGIN
 		RETURN a + Long( b )
 	END "+";
 
-	PROCEDURE "+"*( a: Integer;  b: NbrInt16.Integer ): Integer;
+	OPERATOR "+"*( a: Integer;  b: NbrInt16.Integer ): Integer;
 	BEGIN
 		RETURN a + Long( NbrInt32.Long( b ) )
 	END "+";
 
-	PROCEDURE "+"*( a: Integer;  b: NbrInt8.Integer ): Integer;
+	OPERATOR "+"*( a: Integer;  b: NbrInt8.Integer ): Integer;
 	BEGIN
 		RETURN a + Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "+";
 
-	PROCEDURE "+"*( a: NbrInt32.Integer;  b: Integer ): Integer;
+	OPERATOR "+"*( a: NbrInt32.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( a ) + b
 	END "+";
 
-	PROCEDURE "+"*( a: NbrInt16.Integer;  b: Integer ): Integer;
+	OPERATOR "+"*( a: NbrInt16.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) + b
 	END "+";
 
-	PROCEDURE "+"*( a: NbrInt8.Integer;  b: Integer ): Integer;
+	OPERATOR "+"*( a: NbrInt8.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) + b
 	END "+";
 
 (* ASM Version*)
-	PROCEDURE "-"*( a, b: Integer ): Integer;
+	OPERATOR "-"*( a, b: Integer ): Integer;
 	CODE {SYSTEM.i386}
 		MOV	EAX, [EBP+16]
 		MOV	EBX, [EBP+20]
@@ -322,37 +322,37 @@ CONST
 		MOV	[EDX+4], EBX
 	END "-";
 
-	PROCEDURE "-"*( a: Integer;  b: NbrInt32.Integer ): Integer;
+	OPERATOR "-"*( a: Integer;  b: NbrInt32.Integer ): Integer;
 	BEGIN
 		RETURN a - Long( b )
 	END "-";
 
-	PROCEDURE "-"*( a: Integer;  b: NbrInt16.Integer ): Integer;
+	OPERATOR "-"*( a: Integer;  b: NbrInt16.Integer ): Integer;
 	BEGIN
 		RETURN a - Long( NbrInt32.Long( b ) )
 	END "-";
 
-	PROCEDURE "-"*( a: Integer;  b: NbrInt8.Integer ): Integer;
+	OPERATOR "-"*( a: Integer;  b: NbrInt8.Integer ): Integer;
 	BEGIN
 		RETURN a - Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "-";
 
-	PROCEDURE "-"*( a: NbrInt32.Integer;  b: Integer ): Integer;
+	OPERATOR "-"*( a: NbrInt32.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( a ) - b
 	END "-";
 
-	PROCEDURE "-"*( a: NbrInt16.Integer;  b: Integer ): Integer;
+	OPERATOR "-"*( a: NbrInt16.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) - b
 	END "-";
 
-	PROCEDURE "-"*( a: NbrInt8.Integer;  b: Integer ): Integer;
+	OPERATOR "-"*( a: NbrInt8.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) - b
 	END "-";
 
-	PROCEDURE "*"*( a, b: Integer ): Integer;
+	OPERATOR "*"*( a, b: Integer ): Integer;
 	CODE {SYSTEM.i386, SYSTEM.FPU}
 		FILD	QWORD [EBP+a]
 		FILD	QWORD [EBP+b]
@@ -362,37 +362,37 @@ CONST
 		FWAIT
 	END "*";
 
-	PROCEDURE "*"*( a: Integer;  b: NbrInt32.Integer ): Integer;
+	OPERATOR "*"*( a: Integer;  b: NbrInt32.Integer ): Integer;
 	BEGIN
 		RETURN a * Long( b )
 	END "*";
 
-	PROCEDURE "*"*( a: Integer;  b: NbrInt16.Integer ): Integer;
+	OPERATOR "*"*( a: Integer;  b: NbrInt16.Integer ): Integer;
 	BEGIN
 		RETURN a * Long( NbrInt32.Long( b ) )
 	END "*";
 
-	PROCEDURE "*"*( a: Integer;  b: NbrInt8.Integer ): Integer;
+	OPERATOR "*"*( a: Integer;  b: NbrInt8.Integer ): Integer;
 	BEGIN
 		RETURN a * Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "*";
 
-	PROCEDURE "*"*( a: NbrInt32.Integer;  b: Integer ): Integer;
+	OPERATOR "*"*( a: NbrInt32.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( a ) * b
 	END "*";
 
-	PROCEDURE "*"*( a: NbrInt16.Integer;  b: Integer ): Integer;
+	OPERATOR "*"*( a: NbrInt16.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) * b
 	END "*";
 
-	PROCEDURE "*"*( a: NbrInt8.Integer;  b: Integer ): Integer;
+	OPERATOR "*"*( a: NbrInt8.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) * b
 	END "*";
 
-	PROCEDURE "DIV"*( a, b: Integer ): Integer;
+	OPERATOR "DIV"*( a, b: Integer ): Integer;
 	VAR cw, cw0: INTEGER;
 	CODE {SYSTEM.i386, SYSTEM.FPU}
 		MOV	EAX, [EBP+12]	;  b must be positive(check msb)
@@ -414,37 +414,37 @@ CONST
 		FWAIT
 	END "DIV";
 
-	PROCEDURE "DIV"*( a: Integer;  b: NbrInt32.Integer ): Integer;
+	OPERATOR "DIV"*( a: Integer;  b: NbrInt32.Integer ): Integer;
 	BEGIN
 		RETURN a DIV Long( b )
 	END "DIV";
 
-	PROCEDURE "DIV"*( a: Integer;  b: NbrInt16.Integer ): Integer;
+	OPERATOR "DIV"*( a: Integer;  b: NbrInt16.Integer ): Integer;
 	BEGIN
 		RETURN a DIV Long( NbrInt32.Long( b ) )
 	END "DIV";
 
-	PROCEDURE "DIV"*( a: Integer;  b: NbrInt8.Integer ): Integer;
+	OPERATOR "DIV"*( a: Integer;  b: NbrInt8.Integer ): Integer;
 	BEGIN
 		RETURN a DIV Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "DIV";
 
-	PROCEDURE "DIV"*( a: NbrInt32.Integer;  b: Integer ): Integer;
+	OPERATOR "DIV"*( a: NbrInt32.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( a ) DIV b
 	END "DIV";
 
-	PROCEDURE "DIV"*( a: NbrInt16.Integer;  b: Integer ): Integer;
+	OPERATOR "DIV"*( a: NbrInt16.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) DIV b
 	END "DIV";
 
-	PROCEDURE "DIV"*( a: NbrInt8.Integer;  b: Integer ): Integer;
+	OPERATOR "DIV"*( a: NbrInt8.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) DIV b
 	END "DIV";
 
-	PROCEDURE "MOD"*( a, b: Integer ): Integer;
+	OPERATOR "MOD"*( a, b: Integer ): Integer;
 	VAR cw, cw0: INTEGER;
 	CODE {SYSTEM.i386, SYSTEM.FPU}
 		MOV	EAX, [EBP+12]	;  b must be positive(check msb)
@@ -470,32 +470,32 @@ CONST
 		FWAIT
 	END "MOD";
 
-	PROCEDURE "MOD"*( a: Integer;  b: NbrInt32.Integer ): Integer;
+	OPERATOR "MOD"*( a: Integer;  b: NbrInt32.Integer ): Integer;
 	BEGIN
 		RETURN a MOD Long( b )
 	END "MOD";
 
-	PROCEDURE "MOD"*( a: Integer;  b: NbrInt16.Integer ): Integer;
+	OPERATOR "MOD"*( a: Integer;  b: NbrInt16.Integer ): Integer;
 	BEGIN
 		RETURN a MOD Long( NbrInt32.Long( b ) )
 	END "MOD";
 
-	PROCEDURE "MOD"*( a: Integer;  b: NbrInt8.Integer ): Integer;
+	OPERATOR "MOD"*( a: Integer;  b: NbrInt8.Integer ): Integer;
 	BEGIN
 		RETURN a MOD Long( NbrInt32.Long( NbrInt16.Long( b ) ) )
 	END "MOD";
 
-	PROCEDURE "MOD"*( a: NbrInt32.Integer;  b: Integer ): Integer;
+	OPERATOR "MOD"*( a: NbrInt32.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( a ) MOD b
 	END "MOD";
 
-	PROCEDURE "MOD"*( a: NbrInt16.Integer;  b: Integer ): Integer;
+	OPERATOR "MOD"*( a: NbrInt16.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( a ) ) MOD b
 	END "MOD";
 
-	PROCEDURE "MOD"*( a: NbrInt8.Integer;  b: Integer ): Integer;
+	OPERATOR "MOD"*( a: NbrInt8.Integer;  b: Integer ): Integer;
 	BEGIN
 		RETURN Long( NbrInt32.Long( NbrInt16.Long( a ) ) ) MOD b
 	END "MOD";

source/I386.NbrRe32.Mod

@@ -34,109 +34,109 @@ VAR
 	END RealToInt64;
 
 (** Type Conversion *)
-	PROCEDURE ":="*( VAR l: Real;  r: NbrInt64.Integer );
+	OPERATOR ":="*( VAR l: Real;  r: NbrInt64.Integer );
 	BEGIN
 		l := Int64ToReal( r )
 	END ":=";
 
 (** Comparison Operators *)
-	PROCEDURE "="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR "="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l = Int64ToReal( r )
 	END "=";
 
-	PROCEDURE "="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR "="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) = r
 	END "=";
 
-	PROCEDURE "#"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR "#"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l # Int64ToReal( r )
 	END "#";
 
-	PROCEDURE "#"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR "#"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) # r
 	END "#";
 
-	PROCEDURE "<"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR "<"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l < Int64ToReal( r )
 	END "<";
 
-	PROCEDURE "<"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR "<"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) < r
 	END "<";
 
-	PROCEDURE ">"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR ">"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l > Int64ToReal( r )
 	END ">";
 
-	PROCEDURE ">"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR ">"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) > r
 	END ">";
 
-	PROCEDURE "<="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR "<="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l <= Int64ToReal( r )
 	END "<=";
 
-	PROCEDURE "<="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR "<="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) <= r
 	END "<=";
 
-	PROCEDURE ">="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR ">="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l >= Int64ToReal( r )
 	END ">=";
 
-	PROCEDURE ">="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR ">="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) >= r
 	END ">=";
 
 (** Arithmetic *)
-	PROCEDURE "+"*( l: Real;  r: NbrInt64.Integer ): Real;
+	OPERATOR "+"*( l: Real;  r: NbrInt64.Integer ): Real;
 	BEGIN
 		RETURN l + Int64ToReal( r )
 	END "+";
 
-	PROCEDURE "+"*( l: NbrInt64.Integer;  r: Real ): Real;
+	OPERATOR "+"*( l: NbrInt64.Integer;  r: Real ): Real;
 	BEGIN
 		RETURN Int64ToReal( l ) + r
 	END "+";
 
-	PROCEDURE "-"*( l: Real;  r: NbrInt64.Integer ): Real;
+	OPERATOR "-"*( l: Real;  r: NbrInt64.Integer ): Real;
 	BEGIN
 		RETURN l - Int64ToReal( r )
 	END "-";
 
-	PROCEDURE "-"*( l: NbrInt64.Integer;  r: Real ): Real;
+	OPERATOR "-"*( l: NbrInt64.Integer;  r: Real ): Real;
 	BEGIN
 		RETURN Int64ToReal( l ) - r
 	END "-";
 
-	PROCEDURE "*"*( l: Real;  r: NbrInt64.Integer ): Real;
+	OPERATOR "*"*( l: Real;  r: NbrInt64.Integer ): Real;
 	BEGIN
 		RETURN l * Int64ToReal( r )
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt64.Integer;  r: Real ): Real;
+	OPERATOR "*"*( l: NbrInt64.Integer;  r: Real ): Real;
 	BEGIN
 		RETURN Int64ToReal( l ) * r
 	END "*";
 
-	PROCEDURE "/"*( l: Real;  r: NbrInt64.Integer ): Real;
+	OPERATOR "/"*( l: Real;  r: NbrInt64.Integer ): Real;
 	BEGIN
 		RETURN l / Int64ToReal( r )
 	END "/";
 
-	PROCEDURE "/"*( l: NbrInt64.Integer;  r: Real ): Real;
+	OPERATOR "/"*( l: NbrInt64.Integer;  r: Real ): Real;
 	BEGIN
 		RETURN Int64ToReal( l ) / r
 	END "/";

source/I386.NbrRe64.Mod

@@ -34,109 +34,109 @@ VAR
 	END RealToInt64;
 
 (** Type Conversion *)
-	PROCEDURE ":="*( VAR l: Real;  r: NbrInt64.Integer );
+	OPERATOR ":="*( VAR l: Real;  r: NbrInt64.Integer );
 	BEGIN
 		l := Int64ToReal( r )
 	END ":=";
 
 (** Comparison Operators *)
-	PROCEDURE "="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR "="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l = Int64ToReal( r )
 	END "=";
 
-	PROCEDURE "="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR "="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) = r
 	END "=";
 
-	PROCEDURE "#"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR "#"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l # Int64ToReal( r )
 	END "#";
 
-	PROCEDURE "#"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR "#"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) # r
 	END "#";
 
-	PROCEDURE "<"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR "<"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l < Int64ToReal( r )
 	END "<";
 
-	PROCEDURE "<"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR "<"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) < r
 	END "<";
 
-	PROCEDURE ">"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR ">"*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l > Int64ToReal( r )
 	END ">";
 
-	PROCEDURE ">"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR ">"*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) > r
 	END ">";
 
-	PROCEDURE "<="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR "<="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l <= Int64ToReal( r )
 	END "<=";
 
-	PROCEDURE "<="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR "<="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) <= r
 	END "<=";
 
-	PROCEDURE ">="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
+	OPERATOR ">="*( l: Real;  r: NbrInt64.Integer ): BOOLEAN;
 	BEGIN
 		RETURN l >= Int64ToReal( r )
 	END ">=";
 
-	PROCEDURE ">="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
+	OPERATOR ">="*( l: NbrInt64.Integer;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN Int64ToReal( l ) >= r
 	END ">=";
 
 (** Arithmetic *)
-	PROCEDURE "+"*( l: Real;  r: NbrInt64.Integer ): Real;
+	OPERATOR "+"*( l: Real;  r: NbrInt64.Integer ): Real;
 	BEGIN
 		RETURN l + Int64ToReal( r )
 	END "+";
 
-	PROCEDURE "+"*( l: NbrInt64.Integer;  r: Real ): Real;
+	OPERATOR "+"*( l: NbrInt64.Integer;  r: Real ): Real;
 	BEGIN
 		RETURN Int64ToReal( l ) + r
 	END "+";
 
-	PROCEDURE "-"*( l: Real;  r: NbrInt64.Integer ): Real;
+	OPERATOR "-"*( l: Real;  r: NbrInt64.Integer ): Real;
 	BEGIN
 		RETURN l - Int64ToReal( r )
 	END "-";
 
-	PROCEDURE "-"*( l: NbrInt64.Integer;  r: Real ): Real;
+	OPERATOR "-"*( l: NbrInt64.Integer;  r: Real ): Real;
 	BEGIN
 		RETURN Int64ToReal( l ) - r
 	END "-";
 
-	PROCEDURE "*"*( l: Real;  r: NbrInt64.Integer ): Real;
+	OPERATOR "*"*( l: Real;  r: NbrInt64.Integer ): Real;
 	BEGIN
 		RETURN l * Int64ToReal( r )
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt64.Integer;  r: Real ): Real;
+	OPERATOR "*"*( l: NbrInt64.Integer;  r: Real ): Real;
 	BEGIN
 		RETURN Int64ToReal( l ) * r
 	END "*";
 
-	PROCEDURE "/"*( l: Real;  r: NbrInt64.Integer ): Real;
+	OPERATOR "/"*( l: Real;  r: NbrInt64.Integer ): Real;
 	BEGIN
 		RETURN l / Int64ToReal( r )
 	END "/";
 
-	PROCEDURE "/"*( l: NbrInt64.Integer;  r: Real ): Real;
+	OPERATOR "/"*( l: NbrInt64.Integer;  r: Real ): Real;
 	BEGIN
 		RETURN Int64ToReal( l ) / r
 	END "/";

source/MtxCplx.Mod

@@ -327,7 +327,7 @@ TYPE
 		res := u.Copy();  res.Transpose;  RETURN res;
 	END Transpose;
 
-	PROCEDURE ":="*( VAR l: Matrix;  VAR r: ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Matrix;  VAR r: ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 1 ), 0, LEN( r, 0 ) ) ELSE l.NewRange( 0, LEN( r, 1 ), 0, LEN( r, 0 ), FALSE );  END;
@@ -335,14 +335,14 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0] ), l, LEN( r, 1 ) * LEN( r, 0 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: Vec.Vector );
+	OPERATOR ":="*( VAR l: Matrix;  r: Vec.Vector );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, 1, 0, r.len[0] ) ELSE l.NewRange( 0, 1, 0, r.len[0], FALSE );  END;
 		ArrayXdBytes.CopyDataRaw( r, l );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: MtxInt.Matrix );
+	OPERATOR ":="*( VAR l: Matrix;  r: MtxInt.Matrix );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -352,7 +352,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: MtxRat.Matrix );
+	OPERATOR ":="*( VAR l: Matrix;  r: MtxRat.Matrix );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -362,7 +362,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: MtxRe.Matrix );
+	OPERATOR ":="*( VAR l: Matrix;  r: MtxRe.Matrix );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -372,225 +372,225 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: Value );
+	OPERATOR ":="*( VAR l: Matrix;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: ReValue );
+	OPERATOR ":="*( VAR l: Matrix;  r: ReValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: RatValue );
+	OPERATOR ":="*( VAR l: Matrix;  r: RatValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: IntValue );
+	OPERATOR ":="*( VAR l: Matrix;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Matrix ): Matrix;
+	OPERATOR "+"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Matrix ): Matrix;
+	OPERATOR "-"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Matrix;  r: ReValue ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: ReValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Matrix;  r: RatValue ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: RatValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: Value;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: ReValue;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: ReValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: RatValue;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: RatValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: IntValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix;  r: ReValue ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: ReValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix;  r: RatValue ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: RatValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: ReValue;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: ReValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: RatValue;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: RatValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: IntValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix ): Matrix;
+	OPERATOR "-"*( l: Matrix ): Matrix;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: ReValue ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: ReValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: RatValue ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: RatValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: Value;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: ReValue;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: ReValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: RatValue;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: RatValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: IntValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Matrix;  r: ReValue ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: ReValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Matrix;  r: RatValue ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: RatValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: ReValue;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: ReValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: RatValue;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: RatValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: IntValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
@@ -598,20 +598,20 @@ TYPE
 
 
 (*
-	PROCEDURE "MOD"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "MOD"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "MOD"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;
 	END "MOD";
 *)
 
-	PROCEDURE "*"*( l: Vec.Vector;  r: Matrix ): Vec.Vector;
+	OPERATOR "*"*( l: Vec.Vector;  r: Matrix ): Vec.Vector;
 	VAR res: Vec.Vector;  rc, rr, lc, i, j: LONGINT;  sum: Value;
 	BEGIN
 		rc := r.cols;  rr := r.rows;  lc := l.lenx;
@@ -628,7 +628,7 @@ TYPE
 		RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: Vec.Vector ): Vec.Vector;
+	OPERATOR "*"*( l: Matrix;  r: Vec.Vector ): Vec.Vector;
 	VAR res: Vec.Vector;  lr, lc, rr, i, j: LONGINT;  sum: Value;
 	BEGIN
 		lr := l.rows;  lc := l.cols;  rr := r.lenx;
@@ -644,7 +644,7 @@ TYPE
 		RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l, r: Matrix ): Matrix;
+	OPERATOR "*"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;  rr, rc, lr, lc, i, j, k: LONGINT;  sum: Value;
 		(**! far from opimal: use internal routines of ArrayXdBytes *)
 	BEGIN

source/MtxInt.Mod

@@ -323,101 +323,101 @@ TYPE
 		res := u.Copy();  res.Transpose;  RETURN res;
 	END Transpose;
 
-	PROCEDURE ":="*( VAR l: Matrix;  VAR r: ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Matrix;  VAR r: ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 1 ), 0, LEN( r, 0 ) ) ELSE l.NewRange( 0, LEN( r, 1 ), 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0] ), l, LEN( r, 1 ) * LEN( r, 0 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: Vec.Vector );
+	OPERATOR ":="*( VAR l: Matrix;  r: Vec.Vector );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, 1, 0, r.len[0] ) ELSE l.NewRange( 0, 1, 0, r.len[0], FALSE );  END;
 		ArrayXdBytes.CopyDataRaw( r, l );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: Value );
+	OPERATOR ":="*( VAR l: Matrix;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Matrix ): Matrix;
+	OPERATOR "+"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Matrix ): Matrix;
+	OPERATOR "-"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: Value;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix ): Matrix;
+	OPERATOR "-"*( l: Matrix ): Matrix;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: Value;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "DIV"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "DIV"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "DIV";
 
-	PROCEDURE "DIV"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "DIV"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "DIV";
 
-	PROCEDURE "MOD"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "MOD"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "MOD"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "*"*( l: Vec.Vector;  r: Matrix ): Vec.Vector;
+	OPERATOR "*"*( l: Vec.Vector;  r: Matrix ): Vec.Vector;
 	VAR res: Vec.Vector;  rc, rr, lc, i, j: LONGINT;  sum: Value;
 	BEGIN
 		rc := r.cols;  rr := r.rows;  lc := l.lenx;
@@ -434,7 +434,7 @@ TYPE
 		RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: Vec.Vector ): Vec.Vector;
+	OPERATOR "*"*( l: Matrix;  r: Vec.Vector ): Vec.Vector;
 	VAR res: Vec.Vector;  lr, lc, rr, i, j: LONGINT;  sum: Value;
 	BEGIN
 		lr := l.rows;  lc := l.cols;  rr := r.lenx;
@@ -450,7 +450,7 @@ TYPE
 		RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l, r: Matrix ): Matrix;
+	OPERATOR "*"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;  rr, rc, lr, lc, i, j, k: LONGINT;  sum: Value;
 		(**! far from opimal: use internal routines of ArrayXdBytes *)
 	BEGIN

source/MtxRat.Mod

@@ -326,7 +326,7 @@ TYPE
 		res := u.Copy();  res.Transpose;  RETURN res;
 	END Transpose;
 
-	PROCEDURE ":="*( VAR l: Matrix;  VAR r: ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Matrix;  VAR r: ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 1 ), 0, LEN( r, 0 ) ) ELSE l.NewRange( 0, LEN( r, 1 ), 0, LEN( r, 0 ), FALSE );  END;
@@ -334,14 +334,14 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0] ), l, LEN( r, 1 ) * LEN( r, 0 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: Vec.Vector );
+	OPERATOR ":="*( VAR l: Matrix;  r: Vec.Vector );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, 1, 0, r.len[0] ) ELSE l.NewRange( 0, 1, 0, r.len[0], FALSE );  END;
 		ArrayXdBytes.CopyDataRaw( r, l );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: MtxInt.Matrix );
+	OPERATOR ":="*( VAR l: Matrix;  r: MtxInt.Matrix );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -351,141 +351,141 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: Value );
+	OPERATOR ":="*( VAR l: Matrix;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: IntValue );
+	OPERATOR ":="*( VAR l: Matrix;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Matrix ): Matrix;
+	OPERATOR "+"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Matrix ): Matrix;
+	OPERATOR "-"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: Value;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: IntValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: IntValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix ): Matrix;
+	OPERATOR "-"*( l: Matrix ): Matrix;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: Value;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: IntValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: IntValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
 (*
-	PROCEDURE "MOD"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "MOD"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "MOD"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;
 	END "MOD";
 *)
 
-	PROCEDURE "*"*( l: Vec.Vector;  r: Matrix ): Vec.Vector;
+	OPERATOR "*"*( l: Vec.Vector;  r: Matrix ): Vec.Vector;
 	VAR res: Vec.Vector;  rc, rr, lc, i, j: LONGINT;  sum: Value;
 	BEGIN
 		rc := r.cols;  rr := r.rows;  lc := l.lenx;
@@ -502,7 +502,7 @@ TYPE
 		RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: Vec.Vector ): Vec.Vector;
+	OPERATOR "*"*( l: Matrix;  r: Vec.Vector ): Vec.Vector;
 	VAR res: Vec.Vector;  lr, lc, rr, i, j: LONGINT;  sum: Value;
 	BEGIN
 		lr := l.rows;  lc := l.cols;  rr := r.lenx;
@@ -518,7 +518,7 @@ TYPE
 		RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l, r: Matrix ): Matrix;
+	OPERATOR "*"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;  rr, rc, lr, lc, i, j, k: LONGINT;  sum: Value;
 		(**! far from opimal: use internal routines of ArrayXdBytes *)
 	BEGIN

source/MtxRe.Mod

@@ -325,7 +325,7 @@ TYPE
 		res := u.Copy();  res.Transpose;  RETURN res;
 	END Transpose;
 
-	PROCEDURE ":="*( VAR l: Matrix;  VAR r: ARRAY OF ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Matrix;  VAR r: ARRAY OF ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 1 ), 0, LEN( r, 0 ) ) ELSE l.NewRange( 0, LEN( r, 1 ), 0, LEN( r, 0 ), FALSE );  END;
@@ -333,14 +333,14 @@ TYPE
 		ArrayXdBytes.CopyMemoryToArrayPart( ADDRESSOF( r[0, 0] ), l, LEN( r, 1 ) * LEN( r, 0 ), NIL , NIL );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: Vec.Vector );
+	OPERATOR ":="*( VAR l: Matrix;  r: Vec.Vector );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, 1, 0, r.len[0] ) ELSE l.NewRange( 0, 1, 0, r.len[0], FALSE );  END;
 		ArrayXdBytes.CopyDataRaw( r, l );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: MtxInt.Matrix );
+	OPERATOR ":="*( VAR l: Matrix;  r: MtxInt.Matrix );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -350,7 +350,7 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: MtxRat.Matrix );
+	OPERATOR ":="*( VAR l: Matrix;  r: MtxRat.Matrix );
 	VAR i, last: LONGINT;
 	BEGIN
 		IF r = NIL THEN l := NIL ELSE
@@ -360,173 +360,173 @@ TYPE
 		END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: Value );
+	OPERATOR ":="*( VAR l: Matrix;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: RatValue );
+	OPERATOR ":="*( VAR l: Matrix;  r: RatValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Matrix;  r: IntValue );
+	OPERATOR ":="*( VAR l: Matrix;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Matrix ): Matrix;
+	OPERATOR "+"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Matrix ): Matrix;
+	OPERATOR "-"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Matrix;  r: RatValue ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: RatValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "+"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: Value;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: RatValue;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: RatValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "+"*( l: IntValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix;  r: RatValue ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: RatValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "-"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: RatValue;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: RatValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "-"*( l: IntValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Matrix ): Matrix;
+	OPERATOR "-"*( l: Matrix ): Matrix;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: RatValue ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: RatValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "*"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: Value;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: RatValue;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: RatValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "*"*( l: IntValue;  r: Matrix ): Matrix;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Matrix;  r: RatValue ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: RatValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Matrix;  r: IntValue ): Matrix;
+	OPERATOR "/"*( l: Matrix;  r: IntValue ): Matrix;
 	VAR res: Matrix;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: RatValue;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: RatValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Matrix ): Matrix;
+	OPERATOR "/"*( l: IntValue;  r: Matrix ): Matrix;
 	VAR res: Matrix;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
@@ -534,20 +534,20 @@ TYPE
 
 
 (*
-	PROCEDURE "MOD"*( l: Matrix;  r: Value ): Matrix;
+	OPERATOR "MOD"*( l: Matrix;  r: Value ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Matrix ): Matrix;
+	OPERATOR "MOD"*( l: Value;  r: Matrix ): Matrix;
 	VAR res: Matrix;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;
 	END "MOD";
 *)
 
-	PROCEDURE "*"*( l: Vec.Vector;  r: Matrix ): Vec.Vector;
+	OPERATOR "*"*( l: Vec.Vector;  r: Matrix ): Vec.Vector;
 	VAR res: Vec.Vector;  rc, rr, lc, i, j: LONGINT;  sum: Value;
 	BEGIN
 		rc := r.cols;  rr := r.rows;  lc := l.lenx;
@@ -564,7 +564,7 @@ TYPE
 		RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Matrix;  r: Vec.Vector ): Vec.Vector;
+	OPERATOR "*"*( l: Matrix;  r: Vec.Vector ): Vec.Vector;
 	VAR res: Vec.Vector;  lr, lc, rr, i, j: LONGINT;  sum: Value;
 	BEGIN
 		lr := l.rows;  lc := l.cols;  rr := r.lenx;
@@ -580,7 +580,7 @@ TYPE
 		RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l, r: Matrix ): Matrix;
+	OPERATOR "*"*( l, r: Matrix ): Matrix;
 	VAR res: Matrix;  rr, rc, lr, lc, i, j, k: LONGINT;  sum: Value;
 		(**! far from opimal: use internal routines of ArrayXdBytes *)
 	BEGIN

source/NbrCplx.Mod

@@ -32,14 +32,14 @@ VAR
 
 	(** Monadic Operators *)
 (** Negative, i.e., -z = -x - i y *)
-	PROCEDURE "-"*( x: Complex ): Complex;
+	OPERATOR "-"*( x: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := -x.re;  cplx.im := -x.im;  RETURN cplx
 	END "-";
 
 (** Complex conjugate, i.e., ~z = x - i y  *)
-	PROCEDURE "~"*( x: Complex ): Complex;
+	OPERATOR "~"*( x: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := x.re;  cplx.im := -x.im;  RETURN cplx
@@ -47,221 +47,221 @@ VAR
 
 	(** Dyadic Operators *)
 (** Type Conversions *)
-	PROCEDURE ":="*( VAR l: Complex;  r: NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Complex;  r: NbrInt.Integer );
 	BEGIN
 		l.re := r;  l.im := 0
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Complex;  r: NbrRat.Rational );
+	OPERATOR ":="*( VAR l: Complex;  r: NbrRat.Rational );
 	BEGIN
 		l.re := r;  l.im := 0
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Complex;  r: NbrRe.Real );
+	OPERATOR ":="*( VAR l: Complex;  r: NbrRe.Real );
 	BEGIN
 		l.re := r;  l.im := 0
 	END ":=";
 
 (** Comparison Operators *)
-	PROCEDURE "="*( l, r: Complex ): BOOLEAN;
+	OPERATOR "="*( l, r: Complex ): BOOLEAN;
 	BEGIN
 		RETURN (l.re = r.re) & (l.im = r.im)
 	END "=";
 
-	PROCEDURE "="*( l: Complex;  r: NbrRe.Real ): BOOLEAN;
+	OPERATOR "="*( l: Complex;  r: NbrRe.Real ): BOOLEAN;
 	BEGIN
 		RETURN (l.re = r) & (l.im = 0)
 	END "=";
 
-	PROCEDURE "="*( l: Complex;  r: NbrRat.Rational ): BOOLEAN;
+	OPERATOR "="*( l: Complex;  r: NbrRat.Rational ): BOOLEAN;
 	BEGIN
 		RETURN (l.re = r) & (l.im = 0)
 	END "=";
 
-	PROCEDURE "="*( l: Complex;  r: NbrInt.Integer ): BOOLEAN;
+	OPERATOR "="*( l: Complex;  r: NbrInt.Integer ): BOOLEAN;
 	BEGIN
 		RETURN (l.re = r) & (l.im = 0)
 	END "=";
 
-	PROCEDURE "="*( l: NbrRe.Real;  r: Complex ): BOOLEAN;
+	OPERATOR "="*( l: NbrRe.Real;  r: Complex ): BOOLEAN;
 	BEGIN
 		RETURN (l = r.re) & (r.im = 0)
 	END "=";
 
-	PROCEDURE "="*( l: NbrRat.Rational;  r: Complex ): BOOLEAN;
+	OPERATOR "="*( l: NbrRat.Rational;  r: Complex ): BOOLEAN;
 	BEGIN
 		RETURN (l = r.re) & (r.im = 0)
 	END "=";
 
-	PROCEDURE "="*( l: NbrInt.Integer;  r: Complex ): BOOLEAN;
+	OPERATOR "="*( l: NbrInt.Integer;  r: Complex ): BOOLEAN;
 	BEGIN
 		RETURN (l = r.re) & (r.im = 0)
 	END "=";
 
-	PROCEDURE "#"*( l, r: Complex ): BOOLEAN;
+	OPERATOR "#"*( l, r: Complex ): BOOLEAN;
 	BEGIN
 		RETURN (l.re # r.re) OR (l.im # r.im)
 	END "#";
 
-	PROCEDURE "#"*( l: Complex;  r: NbrRe.Real ): BOOLEAN;
+	OPERATOR "#"*( l: Complex;  r: NbrRe.Real ): BOOLEAN;
 	BEGIN
 		RETURN (l.re # r) OR (l.im # 0)
 	END "#";
 
-	PROCEDURE "#"*( l: Complex;  r: NbrRat.Rational ): BOOLEAN;
+	OPERATOR "#"*( l: Complex;  r: NbrRat.Rational ): BOOLEAN;
 	BEGIN
 		RETURN (l.re # r) OR (l.im # 0)
 	END "#";
 
-	PROCEDURE "#"*( l: Complex;  r: NbrInt.Integer ): BOOLEAN;
+	OPERATOR "#"*( l: Complex;  r: NbrInt.Integer ): BOOLEAN;
 	BEGIN
 		RETURN (l.re # r) OR (l.im # 0)
 	END "#";
 
-	PROCEDURE "#"*( l: NbrRe.Real;  r: Complex ): BOOLEAN;
+	OPERATOR "#"*( l: NbrRe.Real;  r: Complex ): BOOLEAN;
 	BEGIN
 		RETURN (l # r.re) OR (r.im # 0)
 	END "#";
 
-	PROCEDURE "#"*( l: NbrRat.Rational;  r: Complex ): BOOLEAN;
+	OPERATOR "#"*( l: NbrRat.Rational;  r: Complex ): BOOLEAN;
 	BEGIN
 		RETURN (l # r.re) OR (r.im # 0)
 	END "#";
 
-	PROCEDURE "#"*( l: NbrInt.Integer;  r: Complex ): BOOLEAN;
+	OPERATOR "#"*( l: NbrInt.Integer;  r: Complex ): BOOLEAN;
 	BEGIN
 		RETURN (l # r.re) OR (r.im # 0)
 	END "#";
 
 (** Arithmetic *)
-	PROCEDURE "+"*( l, r: Complex ): Complex;
+	OPERATOR "+"*( l, r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re + r.re;  cplx.im := l.im + r.im;  RETURN cplx
 	END "+";
 
-	PROCEDURE "+"*( l: Complex;  r: NbrRe.Real ): Complex;
+	OPERATOR "+"*( l: Complex;  r: NbrRe.Real ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re + r;  cplx.im := l.im;  RETURN cplx
 	END "+";
 
-	PROCEDURE "+"*( l: Complex;  r: NbrRat.Rational ): Complex;
+	OPERATOR "+"*( l: Complex;  r: NbrRat.Rational ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re + r;  cplx.im := l.im;  RETURN cplx
 	END "+";
 
-	PROCEDURE "+"*( l: Complex;  r: NbrInt.Integer ): Complex;
+	OPERATOR "+"*( l: Complex;  r: NbrInt.Integer ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re + r;  cplx.im := l.im;  RETURN cplx
 	END "+";
 
-	PROCEDURE "+"*( l: NbrRe.Real;  r: Complex ): Complex;
+	OPERATOR "+"*( l: NbrRe.Real;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l + r.re;  cplx.im := r.im;  RETURN cplx
 	END "+";
 
-	PROCEDURE "+"*( l: NbrRat.Rational;  r: Complex ): Complex;
+	OPERATOR "+"*( l: NbrRat.Rational;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l + r.re;  cplx.im := r.im;  RETURN cplx
 	END "+";
 
-	PROCEDURE "+"*( l: NbrInt.Integer;  r: Complex ): Complex;
+	OPERATOR "+"*( l: NbrInt.Integer;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l + r.re;  cplx.im := r.im;  RETURN cplx
 	END "+";
 
-	PROCEDURE "-"*( l, r: Complex ): Complex;
+	OPERATOR "-"*( l, r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re - r.re;  cplx.im := l.im - r.im;  RETURN cplx
 	END "-";
 
-	PROCEDURE "-"*( l: Complex;  r: NbrRe.Real ): Complex;
+	OPERATOR "-"*( l: Complex;  r: NbrRe.Real ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re - r;  cplx.im := l.im;  RETURN cplx
 	END "-";
 
-	PROCEDURE "-"*( l: Complex;  r: NbrRat.Rational ): Complex;
+	OPERATOR "-"*( l: Complex;  r: NbrRat.Rational ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re - r;  cplx.im := l.im;  RETURN cplx
 	END "-";
 
-	PROCEDURE "-"*( l: Complex;  r: NbrInt.Integer ): Complex;
+	OPERATOR "-"*( l: Complex;  r: NbrInt.Integer ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re - r;  cplx.im := l.im;  RETURN cplx
 	END "-";
 
-	PROCEDURE "-"*( l: NbrRe.Real;  r: Complex ): Complex;
+	OPERATOR "-"*( l: NbrRe.Real;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l - r.re;  cplx.im := -r.im;  RETURN cplx
 	END "-";
 
-	PROCEDURE "-"*( l: NbrRat.Rational;  r: Complex ): Complex;
+	OPERATOR "-"*( l: NbrRat.Rational;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l - r.re;  cplx.im := -r.im;  RETURN cplx
 	END "-";
 
-	PROCEDURE "-"*( l: NbrInt.Integer;  r: Complex ): Complex;
+	OPERATOR "-"*( l: NbrInt.Integer;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l - r.re;  cplx.im := -r.im;  RETURN cplx
 	END "-";
 
-	PROCEDURE "*"*( l, r: Complex ): Complex;
+	OPERATOR "*"*( l, r: Complex ): Complex;
 	VAR cplx: Complex;  left, right: NbrRe.Real;
 	BEGIN
 		left := l.re * r.re;  right := l.im * r.im;  cplx.re := left - right;  left := l.re * r.im;  right := l.im * r.re;
 		cplx.im := left + right;  RETURN cplx
 	END "*";
 
-	PROCEDURE "*"*( l: Complex;  r: NbrRe.Real ): Complex;
+	OPERATOR "*"*( l: Complex;  r: NbrRe.Real ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re * r;  cplx.im := l.im * r;  RETURN cplx
 	END "*";
 
-	PROCEDURE "*"*( l: Complex;  r: NbrRat.Rational ): Complex;
+	OPERATOR "*"*( l: Complex;  r: NbrRat.Rational ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re * r;  cplx.im := l.im * r;  RETURN cplx
 	END "*";
 
-	PROCEDURE "*"*( l: Complex;  r: NbrInt.Integer ): Complex;
+	OPERATOR "*"*( l: Complex;  r: NbrInt.Integer ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l.re * r;  cplx.im := l.im * r;  RETURN cplx
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRe.Real;  r: Complex ): Complex;
+	OPERATOR "*"*( l: NbrRe.Real;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l * r.re;  cplx.im := l * r.im;  RETURN cplx
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRat.Rational;  r: Complex ): Complex;
+	OPERATOR "*"*( l: NbrRat.Rational;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l * r.re;  cplx.im := l * r.im;  RETURN cplx
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt.Integer;  r: Complex ): Complex;
+	OPERATOR "*"*( l: NbrInt.Integer;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx.re := l * r.re;  cplx.im := l * r.im;  RETURN cplx
 	END "*";
 
-	PROCEDURE "/"*( l, r: Complex ): Complex;
+	OPERATOR "/"*( l, r: Complex ): Complex;
 	(* Algorithm can be found in Press et al. *)
 	VAR cplx: Complex;  denom, ratio: NbrRe.Real;
 	BEGIN
@@ -275,37 +275,37 @@ VAR
 		RETURN cplx
 	END "/";
 
-	PROCEDURE "/"*( l: Complex;  r: NbrRe.Real ): Complex;
+	OPERATOR "/"*( l: Complex;  r: NbrRe.Real ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx := l * (1 / r);  RETURN cplx
 	END "/";
 
-	PROCEDURE "/"*( l: Complex;  r: NbrRat.Rational ): Complex;
+	OPERATOR "/"*( l: Complex;  r: NbrRat.Rational ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx := l * (1 / r);  RETURN cplx
 	END "/";
 
-	PROCEDURE "/"*( l: Complex;  r: NbrInt.Integer ): Complex;
+	OPERATOR "/"*( l: Complex;  r: NbrInt.Integer ): Complex;
 	VAR re: NbrRe.Real;  cplx: Complex;
 	BEGIN
 		re := r;  cplx := l * (1 / re);  RETURN cplx
 	END "/";
 
-	PROCEDURE "/"*( l: NbrRe.Real;  r: Complex ): Complex;
+	OPERATOR "/"*( l: NbrRe.Real;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx := l * Reciprocal( r );  RETURN cplx
 	END "/";
 
-	PROCEDURE "/"*( l: NbrRat.Rational;  r: Complex ): Complex;
+	OPERATOR "/"*( l: NbrRat.Rational;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx := l * Reciprocal( r );  RETURN cplx
 	END "/";
 
-	PROCEDURE "/"*( l: NbrInt.Integer;  r: Complex ): Complex;
+	OPERATOR "/"*( l: NbrInt.Integer;  r: Complex ): Complex;
 	VAR cplx: Complex;
 	BEGIN
 		cplx := l * Reciprocal( r );  RETURN cplx

source/NbrRat.Mod

@@ -43,7 +43,7 @@ VAR
 	END Simplify;
 
 (** Monadic Operator *)
-	PROCEDURE "-"*( x: Rational ): Rational;
+	OPERATOR "-"*( x: Rational ): Rational;
 	VAR n: Rational;
 	BEGIN
 		n.n := -x.n;  n.d := x.d;  RETURN n
@@ -51,43 +51,43 @@ VAR
 
 	(** Dyadic Operators *)
 (** Type Conversion *)
-	PROCEDURE ":="*( VAR l: Rational;  r: NbrInt.Integer );
+	OPERATOR ":="*( VAR l: Rational;  r: NbrInt.Integer );
 	BEGIN
 		l.n := r;  l.d := 1
 	END ":=";
 
 (** Comparison Operators *)
-	PROCEDURE "="*( l, r: Rational ): BOOLEAN;
+	OPERATOR "="*( l, r: Rational ): BOOLEAN;
 	BEGIN
 		RETURN (l.n = r.n) & (l.d = r.d)
 	END "=";
 
-	PROCEDURE "="*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
+	OPERATOR "="*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
 	BEGIN
 		RETURN (l.n = r) & (l.d = 1)
 	END "=";
 
-	PROCEDURE "="*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
+	OPERATOR "="*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
 	BEGIN
 		RETURN (l = r.n) & (r.d = 1)
 	END "=";
 
-	PROCEDURE "#"*( l, r: Rational ): BOOLEAN;
+	OPERATOR "#"*( l, r: Rational ): BOOLEAN;
 	BEGIN
 		RETURN (l.n # r.n) OR (l.d # r.d)
 	END "#";
 
-	PROCEDURE "#"*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
+	OPERATOR "#"*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
 	BEGIN
 		RETURN (l.n # r) OR (l.d # 1)
 	END "#";
 
-	PROCEDURE "#"*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
+	OPERATOR "#"*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
 	BEGIN
 		RETURN (l # r.n) OR (r.d # 1)
 	END "#";
 
-	PROCEDURE "<"*( l, r: Rational ): BOOLEAN;
+	OPERATOR "<"*( l, r: Rational ): BOOLEAN;
 	VAR a, b: NbrInt64.Integer;
 	BEGIN
 		a := l.n DIV l.d;  b := r.n DIV r.d;
@@ -98,12 +98,12 @@ VAR
 		END
 	END "<";
 
-	PROCEDURE "<"*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
+	OPERATOR "<"*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
 	BEGIN
 		IF (l.n DIV l.d) < r THEN RETURN TRUE ELSE RETURN FALSE END
 	END "<";
 
-	PROCEDURE "<"*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
+	OPERATOR "<"*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
 	VAR b: NbrInt64.Integer;
 	BEGIN
 		b := r.n DIV r.d;
@@ -114,7 +114,7 @@ VAR
 		END
 	END "<";
 
-	PROCEDURE ">"*( l, r: Rational ): BOOLEAN;
+	OPERATOR ">"*( l, r: Rational ): BOOLEAN;
 	VAR a, b: NbrInt64.Integer;
 	BEGIN
 		a := l.n DIV l.d;  b := r.n DIV r.d;
@@ -125,7 +125,7 @@ VAR
 		END
 	END ">";
 
-	PROCEDURE ">"*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
+	OPERATOR ">"*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
 	VAR a: NbrInt64.Integer;
 	BEGIN
 		a := l.n DIV l.d;
@@ -136,115 +136,115 @@ VAR
 		END
 	END ">";
 
-	PROCEDURE ">"*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
+	OPERATOR ">"*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
 	BEGIN
 		IF l > (r.n DIV r.d) THEN RETURN TRUE ELSE RETURN FALSE END
 	END ">";
 
-	PROCEDURE "<="*( l, r: Rational ): BOOLEAN;
+	OPERATOR "<="*( l, r: Rational ): BOOLEAN;
 	BEGIN
 		RETURN ~(l > r)
 	END "<=";
 
-	PROCEDURE "<="*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
+	OPERATOR "<="*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
 	BEGIN
 		RETURN ~(l > r)
 	END "<=";
 
-	PROCEDURE "<="*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
+	OPERATOR "<="*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
 	BEGIN
 		RETURN ~(l > r)
 	END "<=";
 
-	PROCEDURE ">="*( l, r: Rational ): BOOLEAN;
+	OPERATOR ">="*( l, r: Rational ): BOOLEAN;
 	BEGIN
 		RETURN ~(l < r)
 	END ">=";
 
-	PROCEDURE ">="*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
+	OPERATOR ">="*( l: Rational;  r: NbrInt.Integer ): BOOLEAN;
 	BEGIN
 		RETURN ~(l < r)
 	END ">=";
 
-	PROCEDURE ">="*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
+	OPERATOR ">="*( l: NbrInt.Integer;  r: Rational ): BOOLEAN;
 	BEGIN
 		RETURN ~(l < r)
 	END ">=";
 
 (** Arithmetic *)
-	PROCEDURE "+"*( l, r: Rational ): Rational;
+	OPERATOR "+"*( l, r: Rational ): Rational;
 	VAR cd, ld, rd: NbrInt64.Integer;  sum: Rational;
 	BEGIN
 		CommonDenominator( l.d, r.d, cd );  ld := l.d DIV cd;  rd := r.d DIV cd;  sum.n := l.n * rd + r.n * ld;  sum.d := l.d * rd;
 		Simplify( sum );  RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: Rational;  r: NbrInt.Integer ): Rational;
+	OPERATOR "+"*( l: Rational;  r: NbrInt.Integer ): Rational;
 	VAR sum: Rational;
 	BEGIN
 		sum.n := l.n + r * l.d;  sum.d := l.d;  Simplify( sum );  RETURN sum
 	END "+";
 
-	PROCEDURE "+"*( l: NbrInt.Integer;  r: Rational ): Rational;
+	OPERATOR "+"*( l: NbrInt.Integer;  r: Rational ): Rational;
 	VAR sum: Rational;
 	BEGIN
 		sum.n := l * r.d + r.n;  sum.d := r.d;  Simplify( sum );  RETURN sum
 	END "+";
 
-	PROCEDURE "-"*( l, r: Rational ): Rational;
+	OPERATOR "-"*( l, r: Rational ): Rational;
 	VAR cd, ld, rd: NbrInt64.Integer;  diff: Rational;
 	BEGIN
 		CommonDenominator( l.d, r.d, cd );  ld := l.d DIV cd;  rd := r.d DIV cd;  diff.n := l.n * rd - r.n * ld;  diff.d := l.d * rd;
 		Simplify( diff );  RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: Rational;  r: NbrInt.Integer ): Rational;
+	OPERATOR "-"*( l: Rational;  r: NbrInt.Integer ): Rational;
 	VAR diff: Rational;
 	BEGIN
 		diff.n := l.n - r * l.d;  diff.d := l.d;  Simplify( diff );  RETURN diff
 	END "-";
 
-	PROCEDURE "-"*( l: NbrInt.Integer;  r: Rational ): Rational;
+	OPERATOR "-"*( l: NbrInt.Integer;  r: Rational ): Rational;
 	VAR diff: Rational;
 	BEGIN
 		diff.n := l * r.d - r.n;  diff.d := r.d;  Simplify( diff );  RETURN diff
 	END "-";
 
-	PROCEDURE "*"*( l, r: Rational ): Rational;
+	OPERATOR "*"*( l, r: Rational ): Rational;
 	VAR cd, ld, ln, rd, rn: NbrInt64.Integer;  prod: Rational;
 	BEGIN
 		CommonDenominator( l.n, r.d, cd );  ln := l.n DIV cd;  ld := r.d DIV cd;  CommonDenominator( r.n, l.d, cd );
 		rn := r.n DIV cd;  rd := l.d DIV cd;  prod.n := ln * rn;  prod.d := ld * rd;  Simplify( prod );  RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: Rational;  r: NbrInt.Integer ): Rational;
+	OPERATOR "*"*( l: Rational;  r: NbrInt.Integer ): Rational;
 	VAR cd, int: NbrInt64.Integer;  prod: Rational;
 	BEGIN
 		int := r;  CommonDenominator( l.d, int, cd );  prod.n := l.n * (int DIV cd);  prod.d := l.d DIV cd;  Simplify( prod );
 		RETURN prod
 	END "*";
 
-	PROCEDURE "*"*( l: NbrInt.Integer;  r: Rational ): Rational;
+	OPERATOR "*"*( l: NbrInt.Integer;  r: Rational ): Rational;
 	VAR cd, int: NbrInt64.Integer;  prod: Rational;
 	BEGIN
 		int := l;  CommonDenominator( int, r.d, cd );  prod.n := (int DIV cd) * r.n;  prod.d := r.d DIV cd;  Simplify( prod );
 		RETURN prod
 	END "*";
 
-	PROCEDURE "/"*( l, r: Rational ): Rational;
+	OPERATOR "/"*( l, r: Rational ): Rational;
 	VAR cd, ld, ln, rd, rn: NbrInt64.Integer;  div: Rational;
 	BEGIN
 		CommonDenominator( l.n, r.n, cd );  ln := l.n DIV cd;  ld := r.n DIV cd;  CommonDenominator( r.d, l.d, cd );
 		rn := r.d DIV cd;  rd := l.d DIV cd;  div.n := ln * rn;  div.d := ld * rd;  Simplify( div );  RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: Rational;  r: NbrInt.Integer ): Rational;
+	OPERATOR "/"*( l: Rational;  r: NbrInt.Integer ): Rational;
 	VAR cd, int: NbrInt64.Integer;  div: Rational;
 	BEGIN
 		int := r;  CommonDenominator( l.n, int, cd );  div.n := l.n DIV cd;  div.d := l.d * (int DIV cd);  Simplify( div );  RETURN div
 	END "/";
 
-	PROCEDURE "/"*( l: NbrInt.Integer;  r: Rational ): Rational;
+	OPERATOR "/"*( l: NbrInt.Integer;  r: Rational ): Rational;
 	VAR cd, int: NbrInt64.Integer;  div: Rational;
 	BEGIN
 		int := l;  CommonDenominator( int, r.n, cd );  div.n := (int DIV cd) * r.d;  div.d := r.n DIV cd;  Simplify( div );  RETURN div

source/NbrRe.Mod

@@ -36,7 +36,7 @@ VAR
 		RETURN r
 	END RatToRe;
 
-	PROCEDURE ":="*( VAR l: Real;  r: NbrRat.Rational );
+	OPERATOR ":="*( VAR l: Real;  r: NbrRat.Rational );
 	BEGIN
 		l := RatToRe( r )
 	END ":=";
@@ -75,103 +75,103 @@ VAR
 	END ReToRat;
 
 (** Comparison Operators *)
-	PROCEDURE "="*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
+	OPERATOR "="*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
 	BEGIN
 		RETURN l = RatToRe( r )
 	END "=";
 
-	PROCEDURE "="*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
+	OPERATOR "="*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN RatToRe( l ) = r
 	END "=";
 
-	PROCEDURE "#"*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
+	OPERATOR "#"*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
 	BEGIN
 		RETURN l # RatToRe( r )
 	END "#";
 
-	PROCEDURE "#"*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
+	OPERATOR "#"*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN RatToRe( l ) # r
 	END "#";
 
-	PROCEDURE "<"*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
+	OPERATOR "<"*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
 	BEGIN
 		RETURN l < RatToRe( r )
 	END "<";
 
-	PROCEDURE "<"*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
+	OPERATOR "<"*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN RatToRe( l ) < r
 	END "<";
 
-	PROCEDURE ">"*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
+	OPERATOR ">"*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
 	BEGIN
 		RETURN l > RatToRe( r )
 	END ">";
 
-	PROCEDURE ">"*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
+	OPERATOR ">"*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN RatToRe( l ) > r
 	END ">";
 
-	PROCEDURE "<="*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
+	OPERATOR "<="*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
 	BEGIN
 		RETURN l <= RatToRe( r )
 	END "<=";
 
-	PROCEDURE "<="*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
+	OPERATOR "<="*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN RatToRe( l ) <= r
 	END "<=";
 
-	PROCEDURE ">="*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
+	OPERATOR ">="*( l: Real;  r: NbrRat.Rational ): BOOLEAN;
 	BEGIN
 		RETURN l >= RatToRe( r )
 	END ">=";
 
-	PROCEDURE ">="*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
+	OPERATOR ">="*( l: NbrRat.Rational;  r: Real ): BOOLEAN;
 	BEGIN
 		RETURN RatToRe( l ) >= r
 	END ">=";
 
 (** Arithmetic *)
-	PROCEDURE "+"*( l: Real;  r: NbrRat.Rational ): Real;
+	OPERATOR "+"*( l: Real;  r: NbrRat.Rational ): Real;
 	BEGIN
 		RETURN l + RatToRe( r )
 	END "+";
 
-	PROCEDURE "+"*( l: NbrRat.Rational;  r: Real ): Real;
+	OPERATOR "+"*( l: NbrRat.Rational;  r: Real ): Real;
 	BEGIN
 		RETURN RatToRe( l ) + r
 	END "+";
 
-	PROCEDURE "-"*( l: Real;  r: NbrRat.Rational ): Real;
+	OPERATOR "-"*( l: Real;  r: NbrRat.Rational ): Real;
 	BEGIN
 		RETURN l - RatToRe( r )
 	END "-";
 
-	PROCEDURE "-"*( l: NbrRat.Rational;  r: Real ): Real;
+	OPERATOR "-"*( l: NbrRat.Rational;  r: Real ): Real;
 	BEGIN
 		RETURN RatToRe( l ) - r
 	END "-";
 
-	PROCEDURE "*"*( l: Real;  r: NbrRat.Rational ): Real;
+	OPERATOR "*"*( l: Real;  r: NbrRat.Rational ): Real;
 	BEGIN
 		RETURN l * RatToRe( r )
 	END "*";
 
-	PROCEDURE "*"*( l: NbrRat.Rational;  r: Real ): Real;
+	OPERATOR "*"*( l: NbrRat.Rational;  r: Real ): Real;
 	BEGIN
 		RETURN RatToRe( l ) * r
 	END "*";
 
-	PROCEDURE "/"*( l: Real;  r: NbrRat.Rational ): Real;
+	OPERATOR "/"*( l: Real;  r: NbrRat.Rational ): Real;
 	BEGIN
 		RETURN l / RatToRe( r )
 	END "/";
 
-	PROCEDURE "/"*( l: NbrRat.Rational;  r: Real ): Real;
+	OPERATOR "/"*( l: NbrRat.Rational;  r: Real ): Real;
 	BEGIN
 		RETURN RatToRe( l ) / r
 	END "/";

source/NbrStrings.Mod

@@ -15,77 +15,77 @@ TYPE
 	String* = POINTER TO ARRAY OF CHAR;
 
 	(** Assignment Operators *)
-	PROCEDURE ":="*( VAR string: String;  x: CHAR );
+	OPERATOR ":="*( VAR string: String;  x: CHAR );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < 2) THEN NEW( string, 2 );  END;
 		string[0] := x;  string[1] := 0X
 	END ":=";
 
-	PROCEDURE ":="*( VAR string: String;  x: ARRAY OF CHAR );
+	OPERATOR ":="*( VAR string: String;  x: ARRAY OF CHAR );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < LEN( x )) THEN NEW( string, LEN( x ) );  END;
 		COPY( x, string^ )
 	END ":=";
 
 (** String conversion for the core numeric types. *)
-	PROCEDURE ":="*( VAR string: String;  x: NbrInt8.Integer );
+	OPERATOR ":="*( VAR string: String;  x: NbrInt8.Integer );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < sIntStringLen) THEN NEW( string, sIntStringLen );  END;
 		NbrInt8.IntToString( x, string^ )
 	END ":=";
 
-	PROCEDURE ":="*( VAR string: String;  x: NbrInt16.Integer );
+	OPERATOR ":="*( VAR string: String;  x: NbrInt16.Integer );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < intStringLen) THEN NEW( string, intStringLen );  END;
 		NbrInt16.IntToString( x, string^ )
 	END ":=";
 
-(**  PROCEDURE ":="*( VAR string: String;  x: NbrRe32.Integer )
+(**  OPERATOR ":="*( VAR string: String;  x: NbrRe32.Integer )
 	is not needed because NbrInt.Integer = NbrInt32.Integer.  *)
 
-	PROCEDURE ":="*( VAR string: String;  x: NbrInt64.Integer );
+	OPERATOR ":="*( VAR string: String;  x: NbrInt64.Integer );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < hIntStringLen) THEN NEW( string, hIntStringLen );  END;
 		NbrInt64.IntToString( x, string^ )
 	END ":=";
 
-(**  PROCEDURE ":="*( VAR string: String;  x: NbrRe32.Real )
+(**  OPERATOR ":="*( VAR string: String;  x: NbrRe32.Real )
 	is not needed because NbrRe.Real = NbrRe32.Real.  *)
 
-	PROCEDURE ":="*( VAR string: String;  x: NbrRe64.Real );
+	OPERATOR ":="*( VAR string: String;  x: NbrRe64.Real );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < lReStringLen) THEN NEW( string, lReStringLen );  END;
 		NbrRe64.ReToString( x, 15, string^ )
 	END ":=";
 
 (** String conversion for the base numeric types. *)
-	PROCEDURE ":="*( VAR string: String;  x: NbrInt.Integer );
+	OPERATOR ":="*( VAR string: String;  x: NbrInt.Integer );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < lIntStringLen) THEN NEW( string, lIntStringLen );  END;
 		NbrInt.IntToString( x, string^ )
 	END ":=";
 
-	PROCEDURE ":="*( VAR string: String;  x: NbrRat.Rational );
+	OPERATOR ":="*( VAR string: String;  x: NbrRat.Rational );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < ratStringLen) THEN NEW( string, ratStringLen );  END;
 		NbrRat.RatToString( x, string^ )
 	END ":=";
 
-	PROCEDURE ":="*( VAR string: String;  x: NbrRe.Real );
+	OPERATOR ":="*( VAR string: String;  x: NbrRe.Real );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < reStringLen) THEN NEW( string, reStringLen );  END;
 		NbrRe.ReToString( x, 7, string^ )
 	END ":=";
 
 (** The returned string will be in Cartesian format.  To get a string in polar format use:  NbrCplx.CplxToPolarString. *)
-	PROCEDURE ":="*( VAR string: String;  x: NbrCplx.Complex );
+	OPERATOR ":="*( VAR string: String;  x: NbrCplx.Complex );
 	BEGIN
 		IF (string = NIL ) OR (LEN( string ) < cplxStringLen) THEN NEW( string, cplxStringLen );  END;
 		NbrCplx.CplxToString( x, 7, string^ );
 	END ":=";
 
 (** String concatination *)
-	PROCEDURE "+"*( l, r: String ): String;
+	OPERATOR "+"*( l, r: String ): String;
 	VAR i, j: NbrInt32.Integer;  res: String;
 
 		PROCEDURE Copy( src: String ): String;
@@ -114,25 +114,25 @@ TYPE
 		END;
 	END "+";
 
-	PROCEDURE "+"*( l: String;  r: CHAR ): String;
+	OPERATOR "+"*( l: String;  r: CHAR ): String;
 	VAR res: String;
 	BEGIN
 		res := r;  res := l + res;  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: CHAR;  r: String ): String;
+	OPERATOR "+"*( l: CHAR;  r: String ): String;
 	VAR res: String;
 	BEGIN
 		res := l;  res := res + r;  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: String;  r: ARRAY OF CHAR ): String;
+	OPERATOR "+"*( l: String;  r: ARRAY OF CHAR ): String;
 	VAR res: String;
 	BEGIN
 		res := r;  res := l + res;  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: ARRAY OF CHAR;  r: String ): String;
+	OPERATOR "+"*( l: ARRAY OF CHAR;  r: String ): String;
 	VAR res: String;
 	BEGIN
 		res := l;  res := res + r;  RETURN res;
@@ -141,20 +141,20 @@ TYPE
 	(* nopov *)
 	(* the following procedures (operators) are not conforming to the new rules:
 	
-	PROCEDURE "+"*( l, r: ARRAY OF CHAR ): String;
+	OPERATOR "+"*( l, r: ARRAY OF CHAR ): String;
 	VAR res: String;
 	BEGIN
 		res := l;  res := res + r;  RETURN res;
 	END "+";
 
 (** Mixing CHAR and ARRAY OF CHAR isn't a problem since CHAR+CHAR is not defined. *)
-	PROCEDURE "+"*( l: ARRAY OF CHAR;  r: CHAR ): String;
+	OPERATOR "+"*( l: ARRAY OF CHAR;  r: CHAR ): String;
 	VAR res: String;
 	BEGIN
 		res := l;  res := res + r;  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: CHAR;  r: ARRAY OF CHAR ): String;
+	OPERATOR "+"*( l: CHAR;  r: ARRAY OF CHAR ): String;
 	VAR res: String;
 	BEGIN
 		res := l;  res := res + r;  RETURN res;

source/Release.Tool

@@ -184,7 +184,7 @@ BUILDS
 		EXTENSION "GofW"
 		SYMBOLEXTENSION "SymW"
 		PATH "AOS:"
-		EXCLUDEPACKAGES "OberonApplications OberonDocumentation OberonVoyager OberonAnts TrueTypeFonts CjkFonts Pr3Fonts ScreenFonts Pr6Fonts"
+		EXCLUDEPACKAGES ""
 		DISABLED "FALSE"
 	}
 	A2_64 {

source/VecCplx.Mod

@@ -252,232 +252,232 @@ TYPE
 
 	END Vector;
 
-	PROCEDURE ":="*( VAR l: Vector;  VAR r: ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Vector;  VAR r: ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 0 ) ) ELSE l.NewRange( 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0] ), l, LEN( r, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: Value );
+	OPERATOR ":="*( VAR l: Vector;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: ReValue );
+	OPERATOR ":="*( VAR l: Vector;  r: ReValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: RatValue );
+	OPERATOR ":="*( VAR l: Vector;  r: RatValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: IntValue );
+	OPERATOR ":="*( VAR l: Vector;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Vector ): Vector;
+	OPERATOR "+"*( l, r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Vector ): Vector;
+	OPERATOR "-"*( l, r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "+"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Vector;  r: ReValue ): Vector;
+	OPERATOR "+"*( l: Vector;  r: ReValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Vector;  r: RatValue ): Vector;
+	OPERATOR "+"*( l: Vector;  r: RatValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "+"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "+"*( l: Value;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: ReValue;  r: Vector ): Vector;
+	OPERATOR "+"*( l: ReValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: RatValue;  r: Vector ): Vector;
+	OPERATOR "+"*( l: RatValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "+"*( l: IntValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "-"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "-"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector;  r: RatValue ): Vector;
+	OPERATOR "-"*( l: Vector;  r: RatValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector;  r: ReValue ): Vector;
+	OPERATOR "-"*( l: Vector;  r: ReValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "-"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: ReValue;  r: Vector ): Vector;
+	OPERATOR "-"*( l: ReValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: RatValue;  r: Vector ): Vector;
+	OPERATOR "-"*( l: RatValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "-"*( l: IntValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector ): Vector;
+	OPERATOR "-"*( l: Vector ): Vector;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "*"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Vector;  r: ReValue ): Vector;
+	OPERATOR "*"*( l: Vector;  r: ReValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Vector;  r: RatValue ): Vector;
+	OPERATOR "*"*( l: Vector;  r: RatValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "*"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "*"*( l: Value;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: ReValue;  r: Vector ): Vector;
+	OPERATOR "*"*( l: ReValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: RatValue;  r: Vector ): Vector;
+	OPERATOR "*"*( l: RatValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "*"*( l: IntValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "/"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Vector;  r: ReValue ): Vector;
+	OPERATOR "/"*( l: Vector;  r: ReValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Vector;  r: RatValue ): Vector;
+	OPERATOR "/"*( l: Vector;  r: RatValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "/"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "/"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: ReValue;  r: Vector ): Vector;
+	OPERATOR "/"*( l: ReValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: RatValue;  r: Vector ): Vector;
+	OPERATOR "/"*( l: RatValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "/"*( l: IntValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
@@ -485,20 +485,20 @@ TYPE
 
 (*
 
-	PROCEDURE "MOD"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "MOD"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "MOD"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;
 	END "MOD";
 *)
 
-	PROCEDURE "*"*( l, r: Vector ): Value;   (* scalar product *)
+	OPERATOR "*"*( l, r: Vector ): Value;   (* scalar product *)
 	(*! replace by operation on memory *)
 	VAR res: Value;  i: LONGINT;
 	BEGIN

source/VecInt.Mod

@@ -257,94 +257,94 @@ TYPE
 
 	END Vector;
 
-	PROCEDURE ":="*( VAR l: Vector;  VAR r: ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Vector;  VAR r: ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 0 ) ) ELSE l.NewRange( 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0] ), l, LEN( r, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: Value );
+	OPERATOR ":="*( VAR l: Vector;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r ) END;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Vector ): Vector;
+	OPERATOR "+"*( l, r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Vector ): Vector;
+	OPERATOR "-"*( l, r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "+"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "+"*( l: Value;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "-"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "-"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector ): Vector;
+	OPERATOR "-"*( l: Vector ): Vector;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "*"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "*"*( l: Value;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "DIV"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "DIV"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "DIV";
 
-	PROCEDURE "DIV"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "DIV"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "DIV";
 
-	PROCEDURE "MOD"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "MOD"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "MOD"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "*"*( l, r: Vector ): Value;   (* scalar product *)
+	OPERATOR "*"*( l, r: Vector ): Value;   (* scalar product *)
 	(*! replace by operation on memory *)
 	VAR res: Value;  i: LONGINT;
 	BEGIN

source/VecRat.Mod

@@ -256,128 +256,128 @@ TYPE
 
 	END Vector;
 
-	PROCEDURE ":="*( VAR l: Vector;  VAR r: ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Vector;  VAR r: ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 0 ) ) ELSE l.NewRange( 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0] ), l, LEN( r, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: Value );
+	OPERATOR ":="*( VAR l: Vector;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: IntValue );
+	OPERATOR ":="*( VAR l: Vector;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Vector ): Vector;
+	OPERATOR "+"*( l, r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Vector ): Vector;
+	OPERATOR "-"*( l, r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "+"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "+"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "+"*( l: Value;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "+"*( l: IntValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "-"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "-"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "-"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "-"*( l: IntValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector ): Vector;
+	OPERATOR "-"*( l: Vector ): Vector;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "*"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "*"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "*"*( l: Value;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "*"*( l: IntValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "/"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "/"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "/"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "/"*( l: IntValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
@@ -385,20 +385,20 @@ TYPE
 
 (*
 
-	PROCEDURE "MOD"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "MOD"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "MOD"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;
 	END "MOD";
 *)
 
-	PROCEDURE "*"*( l, r: Vector ): Value;   (* scalar product *)
+	OPERATOR "*"*( l, r: Vector ): Value;   (* scalar product *)
 	(*! replace by operation on memory *)
 	VAR res: Value;  i: LONGINT;
 	BEGIN

source/VecRe.Mod

@@ -257,180 +257,180 @@ TYPE
 
 	END Vector;
 
-	PROCEDURE ":="*( VAR l: Vector;  VAR r: ARRAY OF Value );
+	OPERATOR ":="*( VAR l: Vector;  VAR r: ARRAY OF Value );
 	BEGIN
 		(*		IF r = NIL THEN l := NIL;  RETURN END;  *)
 		IF l = NIL THEN NEW( l, 0, LEN( r, 0 ) ) ELSE l.NewRange( 0, LEN( r, 0 ), FALSE );  END;
 		ArrayXdBytes.CopyMemoryToArray( ADDRESSOF( r[0] ), l, LEN( r, 0 ) );
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: Value );
+	OPERATOR ":="*( VAR l: Vector;  r: Value );
 	BEGIN
 		IF l # NIL THEN ArrayXd.Fill( l, r );  END;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: RatValue );
+	OPERATOR ":="*( VAR l: Vector;  r: RatValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE ":="*( VAR l: Vector;  r: IntValue );
+	OPERATOR ":="*( VAR l: Vector;  r: IntValue );
 	VAR r1: Value;
 	BEGIN
 		r1 := r;  l := r1;
 	END ":=";
 
-	PROCEDURE "+"*( l, r: Vector ): Vector;
+	OPERATOR "+"*( l, r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.Add( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "-"*( l, r: Vector ): Vector;
+	OPERATOR "-"*( l, r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.Sub( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "+"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "+"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.AddAV( l, r, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Vector;  r: RatValue ): Vector;
+	OPERATOR "+"*( l: Vector;  r: RatValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "+"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.AddAV( l, r1, res );  RETURN res;
 	END "+";
 
-	PROCEDURE "+"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "+"*( l: Value;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: RatValue;  r: Vector ): Vector;
+	OPERATOR "+"*( l: RatValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "+"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "+"*( l: IntValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r + l
 	END "+";
 
-	PROCEDURE "-"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "-"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.SubAV( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector;  r: RatValue ): Vector;
+	OPERATOR "-"*( l: Vector;  r: RatValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "-"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.SubAV( l, r1, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "-"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.SubVA( l, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: RatValue;  r: Vector ): Vector;
+	OPERATOR "-"*( l: RatValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "-"*( l: IntValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.SubVA( l1, r, res );  RETURN res;
 	END "-";
 
-	PROCEDURE "-"*( l: Vector ): Vector;
+	OPERATOR "-"*( l: Vector ): Vector;
 	BEGIN
 		RETURN 0 - l;
 	END "-";
 
-	PROCEDURE "*"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "*"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.MulAV( l, r, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Vector;  r: RatValue ): Vector;
+	OPERATOR "*"*( l: Vector;  r: RatValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "*"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.MulAV( l, r1, res );  RETURN res;
 	END "*";
 
-	PROCEDURE "*"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "*"*( l: Value;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: RatValue;  r: Vector ): Vector;
+	OPERATOR "*"*( l: RatValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "*"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "*"*( l: IntValue;  r: Vector ): Vector;
 	BEGIN
 		RETURN r * l;
 	END "*";
 
-	PROCEDURE "/"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "/"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.DivAV( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Vector;  r: RatValue ): Vector;
+	OPERATOR "/"*( l: Vector;  r: RatValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Vector;  r: IntValue ): Vector;
+	OPERATOR "/"*( l: Vector;  r: IntValue ): Vector;
 	VAR res: Vector;  r1: Value;
 	BEGIN
 		res := l.Alike();  r1 := r;  ArrayXd.DivAV( l, r1, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "/"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.DivVA( l, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: RatValue;  r: Vector ): Vector;
+	OPERATOR "/"*( l: RatValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
 	END "/";
 
-	PROCEDURE "/"*( l: IntValue;  r: Vector ): Vector;
+	OPERATOR "/"*( l: IntValue;  r: Vector ): Vector;
 	VAR res: Vector;  l1: Value;
 	BEGIN
 		res := r.Alike();  l1 := l;  ArrayXd.DivVA( l1, r, res );  RETURN res;
@@ -438,20 +438,20 @@ TYPE
 
 (*
 
-	PROCEDURE "MOD"*( l: Vector;  r: Value ): Vector;
+	OPERATOR "MOD"*( l: Vector;  r: Value ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := l.Alike();  ArrayXd.ModAV( l, r, res );  RETURN res;
 	END "MOD";
 
-	PROCEDURE "MOD"*( l: Value;  r: Vector ): Vector;
+	OPERATOR "MOD"*( l: Value;  r: Vector ): Vector;
 	VAR res: Vector;
 	BEGIN
 		res := r.Alike();  ArrayXd.ModVA( l, r, res );  RETURN res;
 	END "MOD";
 *)
 
-	PROCEDURE "*"*( l, r: Vector ): Value;   (* scalar product *)
+	OPERATOR "*"*( l, r: Vector ): Value;   (* scalar product *)
 	(*! replace by operation on memory *)
 	VAR res: Value;  i: LONGINT;
 	BEGIN