Vector.MulAndAdd Method

Vector Class

Overload List

#SignatureDescription
1function MulAndAdd(const X: TMtxVec; const Y: TCplx; const Z: TCplx): TMtxVec;self = (X*yScalar) + zScalar
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TCplx; const Z: TCplx; Index: Integer; Len: Integer): TMtxVec;
2function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TCplx): TMtxVec;self = X*Y + zScalar
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TCplx; Index: Integer; Len: Integer): TMtxVec;
3function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TCplx): TMtxVec;self = (X*Y)*xyScale + zScalar
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: TCplx; const Z: TCplx; Index: Integer; Len: Integer): TMtxVec;
4function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TMtxVec): TMtxVec;self = X*Y*xyScale + Z
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: TCplx; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;
5function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TMtxVec; const zScale: TCplx): TMtxVec;self = (X*Y)*xyScale + Z*zScale
└ indexed: function MulAndAdd(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;
6function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec): TMtxVec;self = X*Y + Z
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;
7function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec; const zScale: TCplx): TMtxVec;self = X*Y + Z*zScale
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; const zScale: TCplx; Index: Integer; Len: Integer): TMtxVec;
8function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec; const zScale: Double): TMtxVec;self = X*Y + Z*zScale
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: TMtxVec; zIndex: Integer; const zScale: Double; Index: Integer; Len: Integer): TMtxVec;
9function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: Double): TMtxVec;self = X*Y + zScalar
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const Z: Double; Index: Integer; Len: Integer): TMtxVec;
10function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: TMtxVec): TMtxVec;self = X*Y*xyScale + Z
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: Double; const Z: TMtxVec; zIndex: Integer; Index: Integer; Len: Integer): TMtxVec;
11function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: TMtxVec; const zScale: Double): TMtxVec;self = (X*Y)*xyScale + Z*zScale
└ indexed: function MulAndAdd(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;
12function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: Double): TMtxVec;self = (X*Y)*xyScale + zScalar
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: TMtxVec; YIndex: Integer; const xyScale: Double; const Z: Double; Index: Integer; Len: Integer): TMtxVec;
13function MulAndAdd(const X: TMtxVec; const Y: Double; const Z: Double): TMtxVec;self = (X*yScalar) + zScalar
└ indexed: function MulAndAdd(const X: TMtxVec; XIndex: Integer; const Y: Double; const Z: Double; Index: Integer; Len: Integer): TMtxVec;

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

Compute (X*yScalar) + zScalar

#NameTypeDescription
1XTMtxVec
2YTCplx
3ZTCplx

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

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

Compute (X*yScalar) + zScalar

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTCplx
4ZTCplx
5IndexIntegerstart index
6LenIntegerelement count

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

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

Compute X*Y + zScalar

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3ZTCplx

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

Indexed: function MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5ZTCplx
6IndexIntegerstart index
7LenIntegerelement count

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

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

Compute (X*Y)*xyScale + zScalar

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3xyScaleTCplx
4ZTCplx

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

Indexed: function MulAndAdd(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 on sub array

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5xyScaleTCplx
6ZTCplx
7IndexIntegerstart index
8LenIntegerelement count

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 X also for the Y parameter:

X^2*xyScale + zScale

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

Compute X*Y*xyScale + Z

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3xyScaleTCplx
4ZTMtxVec

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

Indexed: function MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5xyScaleTCplx
6ZTMtxVec
7zIndexInteger
8IndexIntegerstart index
9LenIntegerelement count

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

Overload 5: function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: TCplx; const Z: TMtxVec; const zScale: TCplx): TMtxVec;

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

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3xyScaleTCplx
4ZTMtxVec
5zScaleTCplx

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 X also for the Y parameter:

X^2*xyScale + Z*zScale

Indexed: function MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5xyScaleTCplx
6ZTMtxVec
7zIndexInteger
8zScaleTCplx
9IndexIntegerstart index
10LenIntegerelement count

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

Overload 6: function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec): TMtxVec;

Compute X*Y + Z

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3ZTMtxVec

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 := [2,4,6,8];
    Y := [1,1,1,1];
    Z := [3,4,5,6];
    A1 := (X * Y * xyScale) + (Z * zScale);
    A2 := MulAndAdd(X, xyScale, Y, xyScale, Z, zScale);  // Note: Overload uses given scales
    A3.MulAndAdd(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 MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5ZTMtxVec
6zIndexInteger
7IndexIntegerstart index
8LenIntegerelement 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 := [2,4,6,8];
    Y := [1,1,1,1];
    A1 := (X * Y * xyScale) + zScalar;
    A2 := MulAndAdd(X, xyScale, Y, xyScale, zScalar);
    A3.MulAndAdd(X, xyScale, Y, xyScale, zScalar);
    if not A2.IsEqual(A1) then ERaise('Problem');
    if not A3.IsEqual(A1) then ERaise('Problem');
end;

Overload 7: function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const Z: TMtxVec; const zScale: TCplx): TMtxVec;

Compute X*Y + Z*zScale

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3ZTMtxVec
4zScaleTCplx

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

Indexed: function MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5ZTMtxVec
6zIndexInteger
7zScaleTCplx
8IndexIntegerstart index
9LenIntegerelement count

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

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

Compute X*Y + Z*zScale

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3ZTMtxVec
4zScaleDouble

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

Indexed: function MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5ZTMtxVec
6zIndexInteger
7zScaleDouble
8IndexIntegerstart index
9LenIntegerelement count

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

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

Compute X*Y + zScalar

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3ZDouble

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

Indexed: function MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5ZDouble
6IndexIntegerstart index
7LenIntegerelement count

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

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

Compute X*Y*xyScale + Z

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3xyScaleDouble
4ZTMtxVec

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

Examples
uses MtxVec, MtxExpr, Math387;

var
    X, A1, A2, A3: Vector;
    yScalar, zScalar: Double;
begin
    yScalar := 2.0;
    zScalar := 3.0;
    X := [2,4,6,8];
    A1 := (X * yScalar) + zScalar;
    A2 := MulAndAdd(X, yScalar, zScalar);
    A3.MulAndAdd(X, yScalar, zScalar);
    if not A2.IsEqual(A1) then ERaise('Problem');
    if not A3.IsEqual(A1) then ERaise('Problem');
end;

Indexed: function MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5xyScaleDouble
6ZTMtxVec
7zIndexInteger
8IndexIntegerstart index
9LenIntegerelement count

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

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

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

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3xyScaleDouble
4ZTMtxVec
5zScaleDouble

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 X also for the Y parameter:

X^2*xyScale + Z*zScale

Indexed: function MulAndAdd(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

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5xyScaleDouble
6ZTMtxVec
7zIndexInteger
8zScaleDouble
9IndexIntegerstart index
10LenIntegerelement count

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

Overload 12: function MulAndAdd(const X: TMtxVec; const Y: TMtxVec; const xyScale: Double; const Z: Double): TMtxVec;

Compute (X*Y)*xyScale + zScalar

#NameTypeDescription
1XTMtxVec
2YTMtxVec
3xyScaleDouble
4ZDouble

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

Indexed: function MulAndAdd(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 on sub array

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YTMtxVec
4YIndexIntegerY start index
5xyScaleDouble
6ZDouble
7IndexIntegerstart index
8LenIntegerelement count

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 X also for the Y parameter:

X^2*xyScale + zScale

Overload 13: function MulAndAdd(const X: TMtxVec; const Y: Double; const Z: Double): TMtxVec;

Compute (X*yScalar) + zScalar

#NameTypeDescription
1XTMtxVec
2YDouble
3ZDouble

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

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

Compute (X*yScalar) + zScalar

#NameTypeDescription
1XTMtxVec
2XIndexIntegerX start index
3YDouble
4ZDouble
5IndexIntegerstart index
6LenIntegerelement count

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