Vector.DivAndAdd Method

Overload List

#	Signature	Description
1	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TCplx): TMtxVec;	self = X/Y + zScalar
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TCplx; Index: Integer; Len: Integer): TMtxVec;
2	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TCplx): TMtxVec;	self = (X / Y) * xyScale + zScalar
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: TCplx; const Z: TCplx; Index: Integer; Len: Integer): TMtxVec;
3	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TMtxVec): TMtxVec;	self = X/Y*xyScale + Z
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: TCplx; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;
4	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TMtxVec; const zScale: TCplx): TMtxVec;	self = (X / Y)xyScale + ZzScale
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: TCplx; const Z: TMtxVec; zIndex: Integer; const zScale: TCplx; Index: Integer; Len: Integer): TMtxVec;
5	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec): TMtxVec;	self = X/Y + Z
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;
6	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec; const zScale: TCplx): TMtxVec;	self = X/Y + Z*zScale
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; const zScale: TCplx; Index: Integer; Len: Integer): TMtxVec;
7	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec; const zScale: Double): TMtxVec;	self = X/Y + Z*zScale
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; const zScale: Double; Index: Integer; Len: Integer): TMtxVec;
8	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: Double): TMtxVec;	self = X/Y + zScalar
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: Double; Index: Integer; Len: Integer): TMtxVec;
9	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: TMtxVec): TMtxVec;	self = X/Y*xyScale + Z
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: Double; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;
10	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: TMtxVec; const zScale: Double): TMtxVec;	self = (X / Y)xyScale + ZzScale
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: Double; const Z: TMtxVec; zIndex: Integer; const zScale: Double; Index: Integer; Len: Integer): TMtxVec;
11	function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: Double): TMtxVec;	self = (X / Y) * xyScale + zScalar
	└ indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: Double; const Z: Double; Index: Integer; Len: Integer): TMtxVec;

Overload 1: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TCplx): TMtxVec;

Compute X/Y + zScalar

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	Z	TCplx

Result: stored in self (calling object), returns self for chaining

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TCplx; Index: Integer; Len: Integer): TMtxVec;

Compute X/Y + zScalar on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	Z	TCplx
6	Index	Integer	start index
7	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Overload 2: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TCplx): TMtxVec;

Compute (X / Y) * xyScale + zScalar

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	xyScale	TCplx
4	Z	TCplx

Result: stored in self (calling object), returns self for chaining

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: TCplx; const Z: TCplx; Index: Integer; Len: Integer): TMtxVec;

Compute (X / Y) * xyScale + zScalar

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	xyScale	TCplx
6	Z	TCplx
7	Index	Integer	start index
8	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Overload 3: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TMtxVec): TMtxVec;

Compute X/Y*xyScale + Z

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	xyScale	TCplx
4	Z	TMtxVec

Result: stored in self (calling object), returns self for chaining

Examples

uses MtxVec, MtxExpr, Math387;

var
    X, Y, Z, A1, A2, A3: Vector;
    zScale: Double;
begin
    zScale := 2.0;
    X := [6,8,10,12];
    Y := [2,2,2,2];
    Z := [1,1,1,1];
    A1 := (X / Y) + (Z * zScale);
    A2 := DivAndAdd(X, Y, Z, zScale);
    A3.DivAndAdd(X, Y, zScale, Z);
    if not A2.IsEqual(A1) then ERaise('Problem');
    if not A3.IsEqual(A1) then ERaise('Problem');
end;

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: TCplx; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;

Compute X/Y*xyScale + Z on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	xyScale	TCplx
6	Z	TMtxVec
7	zIndex	Integer
8	Index	Integer	start index
9	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Overload 4: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TMtxVec; const zScale: TCplx): TMtxVec;

Compute (X / Y)*xyScale + Z*zScale

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	xyScale	TCplx
4	Z	TMtxVec
5	zScale	TCplx

Result: stored in self (calling object), returns self for chaining

Remarks:

The following expression would also run at the same or higher speed, when passing Z also for the Y parameter:

(X / Z) xyScale + Z zScale

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: TCplx; const Z: TMtxVec; zIndex: Integer; const zScale: TCplx; Index: Integer; Len: Integer): TMtxVec;

Compute (X / Y)*xyScale + Z*zScale on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	xyScale	TCplx
6	Z	TMtxVec
7	zIndex	Integer
8	zScale	TCplx
9	Index	Integer	start index
10	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Overload 5: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec): TMtxVec;

Compute X/Y + Z

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	Z	TMtxVec

Result: stored in self (calling object), returns self for chaining

Examples

uses MtxVec, MtxExpr, Math387;

var
    X, Y, Z, A1, A2, A3: Vector;
    xyScale, zScale: Double;
begin
    xyScale := 1.5;
    zScale  := 2.0;
    X := [8,10,12,14];
    Y := [2,2,2,2];
    Z := [1,1,1,1];
    A1 := (X / Y) * xyScale + Z * zScale;
    A2 := DivAndAdd(X, xyScale, Y, xyScale, Z, zScale);
    A3.Divide(X, Y, Z); // then in-place call: A3.DivAndAdd(X, xyScale, Y, xyScale, Z, zScale);
    if not A2.IsEqual(A1) then ERaise('Problem');
    if not A3.IsEqual(A1) then ERaise('Problem');
end;

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;

Compute X/Y + Z on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	Z	TMtxVec
6	zIndex	Integer
7	Index	Integer	start index
8	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Examples

uses MtxVec, MtxExpr, Math387;

var
    X, Y, A1, A2, A3: Vector;
    xyScale, zScalar: Double;
begin
    xyScale := 1.5;
    zScalar := 2.0;
    X := [8,10,12,14];
    Y := [2,2,2,2];
    A1 := (X / Y) * xyScale + zScalar;
    A2 := DivAndAdd(X, xyScale, Y, xyScale, zScalar);
    A3.DivAndAdd(X, xyScale, Y, xyScale, zScalar);
    if not A2.IsEqual(A1) then ERaise('Problem');
    if not A3.IsEqual(A1) then ERaise('Problem');
end;

Overload 6: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec; const zScale: TCplx): TMtxVec;

Compute X/Y + Z*zScale

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	Z	TMtxVec
4	zScale	TCplx

Result: stored in self (calling object), returns self for chaining

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; const zScale: TCplx; Index: Integer; Len: Integer): TMtxVec;

Compute X/Y + Z*zScale on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	Z	TMtxVec
6	zIndex	Integer
7	zScale	TCplx
8	Index	Integer	start index
9	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Overload 7: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec; const zScale: Double): TMtxVec;

Compute X/Y + Z*zScale

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	Z	TMtxVec
4	zScale	Double

Result: stored in self (calling object), returns self for chaining

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; const zScale: Double; Index: Integer; Len: Integer): TMtxVec;

Compute X/Y + Z*zScale on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	Z	TMtxVec
6	zIndex	Integer
7	zScale	Double
8	Index	Integer	start index
9	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Overload 8: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: Double): TMtxVec;

Compute X/Y + zScalar

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	Z	Double

Result: stored in self (calling object), returns self for chaining

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: Double; Index: Integer; Len: Integer): TMtxVec;

Compute X/Y + zScalar on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	Z	Double
6	Index	Integer	start index
7	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Overload 9: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: TMtxVec): TMtxVec;

Compute X/Y*xyScale + Z

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	xyScale	Double
4	Z	TMtxVec

Result: stored in self (calling object), returns self for chaining

Examples

uses MtxVec, MtxExpr, Math387;

var
    X, Y, Z, A1, A2, A3: Vector;
begin
    X := [6, 8, 10, 12];
    Y := [2, 2, 2, 2];
    Z := [1, 1, 1, 1];
    A1 := (X / Y) + Z;             // standard operation using operators
    A2 := DivAndAdd(X, Y, Z);       // using the function
    A3.DivAndAdd(X, Y, Z);          // in-place operation on A3
    if not A2.IsEqual(A1) then ERaise('Problem');
    if not A3.IsEqual(A1) then ERaise('Problem');
end;

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: Double; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;

Compute X/Y*xyScale + Z on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	xyScale	Double
6	Z	TMtxVec
7	zIndex	Integer
8	Index	Integer	start index
9	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Examples

uses MtxVec, MtxExpr, Math387;

var
    X, Y, A1, A2, A3: Vector;
    zScalar: Double;
begin
    zScalar := 2.0;
    X := [6,8,10,12];
    Y := [2,2,2,2];
    A1 := (X / Y) + zScalar;             // standard operator use
    A2 := DivAndAdd(X, Y, zScalar);       // function call
    A3.DivAndAdd(X, Y, zScalar);          // in-place method call
    if not A2.IsEqual(A1) then ERaise('Problem');
    if not A3.IsEqual(A1) then ERaise('Problem');
end;

Overload 10: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: TMtxVec; const zScale: Double): TMtxVec;

Compute (X / Y)*xyScale + Z*zScale

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	xyScale	Double
4	Z	TMtxVec
5	zScale	Double

Result: stored in self (calling object), returns self for chaining

Remarks:

The following expression would also run at the same or higher speed, when passing Z also for the Y parameter:

(X / Z) xyScale + Z zScale

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: Double; const Z: TMtxVec; zIndex: Integer; const zScale: Double; Index: Integer; Len: Integer): TMtxVec;

Compute (X / Y)*xyScale + Z*zScale on sub array

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	xyScale	Double
6	Z	TMtxVec
7	zIndex	Integer
8	zScale	Double
9	Index	Integer	start index
10	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining

Overload 11: function DivAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: Double): TMtxVec;

Compute (X / Y) * xyScale + zScalar

#	Name	Type
1	X	TMtxVec
2	Y	TMtxVec
3	xyScale	Double
4	Z	Double

Result: stored in self (calling object), returns self for chaining

Indexed: function DivAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: Double; const Z: Double; Index: Integer; Len: Integer): TMtxVec;

Compute (X / Y) * xyScale + zScalar

#	Name	Type	Description
1	X	TMtxVec
2	XIndex	Integer	X start index
3	Y	TMtxVec
4	YIndex	Integer	Y start index
5	xyScale	Double
6	Z	Double
7	Index	Integer	start index
8	Len	Integer	element count

Result: stored in self (calling object), returns self for chaining