MtxExpr::AddAndMul Function

MtxExpr Namespace

Overload List

#SignatureDescription
1Vector AddAndMul(TVec *X, const double xScale, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale);Compute (X*xScale + Y*yScale)*Z*zScale
2Matrix AddAndMul(TMtx *X, const double xScale, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale);Compute (X*xScale + Y*yScale)*Z*zScale, when X is a Matrix.
3Vector AddAndMul(TVec *X, const double xScale, double Y, TMtxVec *Z, const double zScale);Compute (X*xScale + yScalar)*Z*zScale
4Matrix AddAndMul(TMtx *X, const double xScale, double Y, TMtxVec *Z, const double zScale);Compute (X*xScale + yScalar)*Z*zScale, when X is a Matrix.
5Vector AddAndMul(TVec *X, const double xScale, TMtxVec *Y, const double yScale, const double Z);Compute (X*xScale + Y*yScale)*zScalar
6Matrix AddAndMul(TMtx *X, const double xScale, TMtxVec *Y, const double yScale, const double Z);Compute (X*xScale + Y*yScale)*zScalar, when X is a Matrix.
7Vector AddAndMul(TVec *X, const double xScale, double Y, double Z);Compute (X*xScale + yScalar)*zScalar
8Matrix AddAndMul(TMtx *X, const double xScale, double Y, double Z);Compute (X*xScale + yScalar)*zScalar, when X is a Matrix.
9Vector AddAndMul(TVec *X, TMtxVec *Y, TMtxVec *Z);Compute (X + Y)*Z
10Matrix AddAndMul(TMtx *X, TMtxVec *Y, TMtxVec *Z);Compute (X + Y)*Z, where X is a Matrix
11Vector AddAndMul(TVec *X, TMtxVec *Y, TMtxVec *Z, const double zScale);Compute (X + Y)*Z*zScale
12Matrix AddAndMul(TMtx *X, TMtxVec *Y, TMtxVec *Z, const double zScale);Compute (X + Y)*Z*zScale, where X is a Matrix
13Vector AddAndMul(TVec *X, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale);Compute (X + Y*yScale)*Z*zScale
14Matrix AddAndMul(TMtx *X, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale);Compute (X + Y*yScale)*Z*zScale, where X is a Matrix
15Vector AddAndMul(TVec *X, TMtxVec *Y, const double Z);Compute (X + Y)*zScalar
16Matrix AddAndMul(TMtx *X, TMtxVec *Y, const double Z);Compute (X + Y)*zScalar, where X is a Matrix
17Vector AddAndMul(TVec *X, TMtxVec *Y, const double yScale, const double Z);Compute (X + Y*yScale)*zScalar
18Matrix AddAndMul(TMtx *X, TMtxVec *Y, const double yScale, const double Z);Compute (X + Y*yScale)*zScalar, where X is a Matrix.
19Vector AddAndMul(TVec *X, double Y, TMtxVec *Z, const double zScale);Compute (X + yScalar)*Z*zScale
20Matrix AddAndMul(TMtx *X, double Y, TMtxVec *Z, const double zScale);Compute (X + yScalar)*Z*zScale, where X is a Matrix
21Vector AddAndMul(TVec *X, const double xScale, const double Y, TMtxVec *Z);Compute (X*xScale + yScalar)*Z
22Matrix AddAndMul(TMtx *X, const double xScale, const double Y, TMtxVec *Z);Compute (X*xScale + yScalar)*Z, where X is a Matrix.
23Vector AddAndMul(TVec *X, double Y, TMtxVec *Z);Compute (X + yScalar)*Z
24Matrix AddAndMul(TMtx *X, double Y, TMtxVec *Z);Compute (X + yScalar)*Z, where X is a Matrix
25Vector AddAndMul(TVec *X, double Y, double Z);Compute (X + yScalar)*zScalar
26Matrix AddAndMul(TMtx *X, double Y, double Z);Compute (X + yScalar)*zScalar, where X is a Matrix
27Vector AddAndMul(TVec *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, TMtxVec *Z, const TCplx &zScale);Compute (X*xScale + Y*yScale)*Z*zScale
28Matrix AddAndMul(TMtx *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, TMtxVec *Z, const TCplx &zScale);Compute (X*xScale + Y*yScale)*Z*zScale, where X is a Matrix
29Vector AddAndMul(TVec *X, const TCplx &xScale, TCplx Y, TMtxVec *Z, const TCplx &zScale);Compute (X*xScale + yScalar)*Z*zScale
30Matrix AddAndMul(TMtx *X, const TCplx &xScale, TCplx Y, TMtxVec *Z, const TCplx &zScale);Compute (X*xScale + yScalar)*Z*zScale, where X is a Matrix
31Vector AddAndMul(TVec *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, const TCplx &Z);Compute (X*xScale + Y*yScale)*zScalar
32Matrix AddAndMul(TMtx *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, const TCplx &Z);Compute (X*xScale + Y*yScale)*zScalar, where X is a Matrix
33Vector AddAndMul(TVec *X, const TCplx &xScale, TCplx Y, TCplx Z);Compute (X*xScale + yScalar)*zScalar
34Matrix AddAndMul(TMtx *X, const TCplx &xScale, TCplx Y, TCplx Z);Compute (X*xScale + yScalar)*zScalar, where X is a Matrix

Overload 1: Vector AddAndMul(TVec *X, const double xScale, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale);

Compute (X*xScale + Y*yScale)*Z*zScale

#NameTypeDescription
1XTVec *
2xScaleconst double
3YTMtxVec *
4yScaleconst double
5ZTMtxVec *
6zScaleconst double
Remarks:

Computes the expression (X*xScale + Y*yScale) multiplied by Z*zScale without temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double xScale = 1.0, yScale = 2.0, zScale = 3.0;
    Vector X = { 1, 2, 3, 4 };
    Vector Y = { 2, 3, 4, 5 };
    Vector Z = { 3, 4, 5, 6 };
    Vector A1 = (X * xScale + Y * yScale) * Z * zScale;
    Vector A2 = AddAndMul(X, xScale, Y, yScale, Z, zScale);
    Vector A3;
    A3.AddAndMul(X, xScale, Y, yScale, Z, zScale);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 2: Matrix AddAndMul(TMtx *X, const double xScale, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale);

Compute (X*xScale + Y*yScale)*Z*zScale, when X is a Matrix.

#NameTypeDescription
1XTMtx *
2xScaleconst double
3YTMtxVec *
4yScaleconst double
5ZTMtxVec *
6zScaleconst double
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 3: Vector AddAndMul(TVec *X, const double xScale, double Y, TMtxVec *Z, const double zScale);

Compute (X*xScale + yScalar)*Z*zScale

#NameTypeDescription
1XTVec *
2xScaleconst double
3Ydouble
4ZTMtxVec *
5zScaleconst double
Remarks:

Computes the expression where X is scaled by xScale, then added to a scalar yScalar, and the result is multiplied element-wise by Z and finally scaled by zScale. This operation is performed without creating temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double xScale = 1.0, yScalar = 2.0, zScale = 3.0;
    Vector X = { 1, 2, 3, 4 };
    Vector Z = { 3, 4, 5, 6 };
    Vector A1 = (X * xScale + yScalar) * Z * zScale;
    Vector A2 = AddAndMul(X, xScale, yScalar, Z, zScale);
    Vector A3;
    A3.AddAndMul(X, xScale, yScalar, Z, zScale);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 4: Matrix AddAndMul(TMtx *X, const double xScale, double Y, TMtxVec *Z, const double zScale);

Compute (X*xScale + yScalar)*Z*zScale, when X is a Matrix.

#NameTypeDescription
1XTMtx *
2xScaleconst double
3Ydouble
4ZTMtxVec *
5zScaleconst double
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 5: Vector AddAndMul(TVec *X, const double xScale, TMtxVec *Y, const double yScale, const double Z);

Compute (X*xScale + Y*yScale)*zScalar

#NameTypeDescription
1XTVec *
2xScaleconst double
3YTMtxVec *
4yScaleconst double
5Zconst double
Remarks:

Computes the expression (X*xScale + Y*yScale) multiplied by a scalar zScalar without temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double xScale = 1.0, yScale = 2.0, zScalar = 3.0;
    Vector X = { 1, 2, 3, 4 };
    Vector Y = { 2, 3, 4, 5 };
    Vector A1 = (X * xScale + Y * yScale) * zScalar;
    Vector A2 = AddAndMul(X, xScale, Y, yScale, zScalar);
    Vector A3;
    A3.AddAndMul(X, xScale, Y, yScale, zScalar);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 6: Matrix AddAndMul(TMtx *X, const double xScale, TMtxVec *Y, const double yScale, const double Z);

Compute (X*xScale + Y*yScale)*zScalar, when X is a Matrix.

#NameTypeDescription
1XTMtx *
2xScaleconst double
3YTMtxVec *
4yScaleconst double
5Zconst double
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 7: Vector AddAndMul(TVec *X, const double xScale, double Y, double Z);

Compute (X*xScale + yScalar)*zScalar

#NameTypeDescription
1XTVec *
2xScaleconst double
3Ydouble
4Zdouble
Remarks:

Computes the result of multiplying X by xScale, adding a scalar yScalar, and then multiplying the entire result by a scalar zScalar, all without creating temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double xScale = 1.0, yScalar = 2.0, zScalar = 3.0;
    Vector X = { 1, 2, 3, 4 };
    Vector A1 = (X * xScale + yScalar) * zScalar;
    Vector A2 = AddAndMul(X, xScale, yScalar, zScalar);
    Vector A3;
    A3.AddAndMul(X, xScale, yScalar, zScalar);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 8: Matrix AddAndMul(TMtx *X, const double xScale, double Y, double Z);

Compute (X*xScale + yScalar)*zScalar, when X is a Matrix.

#NameTypeDescription
1XTMtx *
2xScaleconst double
3Ydouble
4Zdouble
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 9: Vector AddAndMul(TVec *X, TMtxVec *Y, TMtxVec *Z);

Compute (X + Y)*Z

#NameTypeDescription
1XTVec *
2YTMtxVec *
3ZTMtxVec *
Remarks:

Computes the product of the sum of X and Y multiplied by Z without temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    Vector X = { 1, 2, 3, 4 };
    Vector Y = { 2, 3, 4, 5 };
    Vector Z = { 3, 4, 5, 6 };
    Vector A1 = (X + Y) * Z;
    Vector A2 = AddAndMul(X, Y, Z);
    Vector A3;
    A3.AddAndMul(X, Y, Z);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 10: Matrix AddAndMul(TMtx *X, TMtxVec *Y, TMtxVec *Z);

Compute (X + Y)*Z, where X is a Matrix

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3ZTMtxVec *
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 11: Vector AddAndMul(TVec *X, TMtxVec *Y, TMtxVec *Z, const double zScale);

Compute (X + Y)*Z*zScale

#NameTypeDescription
1XTVec *
2YTMtxVec *
3ZTMtxVec *
4zScaleconst double
Remarks:

Computes the product of (X + Y) multiplied by Z and then by the scalar zScale, all without creating temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double zScale = 2.0;
    Vector X = { 1, 2, 3, 4 };
    Vector Y = { 2, 3, 4, 5 };
    Vector Z = { 3, 4, 5, 6 };
    Vector A1 = (X + Y) * Z * zScale;
    Vector A2 = AddAndMul(X, Y, Z, zScale);
    Vector A3;
    A3.AddAndMul(X, Y, Z, zScale);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 12: Matrix AddAndMul(TMtx *X, TMtxVec *Y, TMtxVec *Z, const double zScale);

Compute (X + Y)*Z*zScale, where X is a Matrix

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3ZTMtxVec *
4zScaleconst double
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 13: Vector AddAndMul(TVec *X, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale);

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

#NameTypeDescription
1XTVec *
2YTMtxVec *
3yScaleconst double
4ZTMtxVec *
5zScaleconst double
Remarks:

Computes the product of (X plus Y scaled by yScale) multiplied by Z and then by zScale, without temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double yScale = 1.5, zScale = 2.0;
    Vector X = {1, 2, 3, 4};
    Vector Y = {2, 3, 4, 5};
    Vector Z = {3, 4, 5, 6};
    Vector A1 = (X + Y * yScale) * Z * zScale;
    Vector A2 = AddAndMul(X, Y, yScale, Z, zScale);
    Vector A3;
    A3.AddAndMul(X, Y, yScale, Z, zScale);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 14: Matrix AddAndMul(TMtx *X, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale);

Compute (X + Y*yScale)*Z*zScale, where X is a Matrix

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3yScaleconst double
4ZTMtxVec *
5zScaleconst double
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 15: Vector AddAndMul(TVec *X, TMtxVec *Y, const double Z);

Compute (X + Y)*zScalar

#NameTypeDescription
1XTVec *
2YTMtxVec *
3Zconst double
Remarks:

Computes the sum of X and Y multiplied by the scalar zScalar without temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double zScalar = 3.0;
    Vector X = { 1, 2, 3, 4 };
    Vector Y = { 2, 3, 4, 5 };
    Vector A1 = (X + Y) * zScalar;
    Vector A2 = AddAndMul(X, Y, zScalar);
    Vector A3;
    A3.AddAndMul(X, Y, zScalar);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 16: Matrix AddAndMul(TMtx *X, TMtxVec *Y, const double Z);

Compute (X + Y)*zScalar, where X is a Matrix

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3Zconst double
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 17: Vector AddAndMul(TVec *X, TMtxVec *Y, const double yScale, const double Z);

Compute (X + Y*yScale)*zScalar

#NameTypeDescription
1XTVec *
2YTMtxVec *
3yScaleconst double
4Zconst double
Remarks:

Computes the expression (X + Y*yScale) multiplied by a scalar zScalar without temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double yScale = 1.5, zScalar = 3.0;
    Vector X = {1, 2, 3, 4};
    Vector Y = {2, 3, 4, 5};
    Vector A1 = (X + Y * yScale) * zScalar;
    Vector A2 = AddAndMul(X, Y, yScale, zScalar);
    Vector A3;
    A3.AddAndMul(X, Y, yScale, zScalar);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 18: Matrix AddAndMul(TMtx *X, TMtxVec *Y, const double yScale, const double Z);

Compute (X + Y*yScale)*zScalar, where X is a Matrix.

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3yScaleconst double
4Zconst double
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 19: Vector AddAndMul(TVec *X, double Y, TMtxVec *Z, const double zScale);

Compute (X + yScalar)*Z*zScale

#NameTypeDescription
1XTVec *
2Ydouble
3ZTMtxVec *
4zScaleconst double
Remarks:

Computes the expression (X + yScalar) multiplied by Z and then by zScale, without creating temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double yScalar = 2.0, zScale = 3.0;
    Vector X = { 1, 2, 3, 4 };
    Vector Z = { 3, 4, 5, 6 };
    Vector A1 = (X + yScalar) * Z * zScale;
    Vector A2 = AddAndMul(X, yScalar, Z, zScale);
    Vector A3;
    A3.AddAndMul(X, yScalar, Z, zScale);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 20: Matrix AddAndMul(TMtx *X, double Y, TMtxVec *Z, const double zScale);

Compute (X + yScalar)*Z*zScale, where X is a Matrix

#NameTypeDescription
1XTMtx *
2Ydouble
3ZTMtxVec *
4zScaleconst double
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 21: Vector AddAndMul(TVec *X, const double xScale, const double Y, TMtxVec *Z);

Compute (X*xScale + yScalar)*Z

#NameTypeDescription
1XTVec *
2xScaleconst double
3Yconst double
4ZTMtxVec *
Remarks:

Computes the expression (X scaled by xScale plus the scalar yScalar) multiplied by Z, without creating temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double xScale = 1.0, yScalar = 2.0;
    Vector X = { 1, 2, 3, 4 };
    Vector Z = { 3, 4, 5, 6 };
    Vector A1 = (X * xScale + yScalar) * Z;
    Vector A2 = AddAndMul(X, xScale, yScalar, Z);
    Vector A3;
    A3.AddAndMul(X, xScale, yScalar, Z);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 22: Matrix AddAndMul(TMtx *X, const double xScale, const double Y, TMtxVec *Z);

Compute (X*xScale + yScalar)*Z, where X is a Matrix.

#NameTypeDescription
1XTMtx *
2xScaleconst double
3Yconst double
4ZTMtxVec *
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 23: Vector AddAndMul(TVec *X, double Y, TMtxVec *Z);

Compute (X + yScalar)*Z

#NameTypeDescription
1XTVec *
2Ydouble
3ZTMtxVec *
Remarks:

Computes the expression (X plus the scalar yScalar) multiplied by Z, without creating temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double yScalar = 2.0;
    Vector X = { 1, 2, 3, 4 };
    Vector Z = { 3, 4, 5, 6 };
    Vector A1 = (X + yScalar) * Z;
    Vector A2 = AddAndMul(X, yScalar, Z);
    Vector A3;
    A3.AddAndMul(X, yScalar, Z);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 24: Matrix AddAndMul(TMtx *X, double Y, TMtxVec *Z);

Compute (X + yScalar)*Z, where X is a Matrix

#NameTypeDescription
1XTMtx *
2Ydouble
3ZTMtxVec *
Remarks:

The operation does only per-element math.

Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 25: Vector AddAndMul(TVec *X, double Y, double Z);

Compute (X + yScalar)*zScalar

#NameTypeDescription
1XTVec *
2Ydouble
3Zdouble
Remarks:

Computes the result of adding the scalar yScalar to X and then multiplying by the scalar zScalar, without creating temporary objects.

Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"

using namespace Dew;
using namespace Dew::Math;
using namespace Dew::Math::Units::Math387;
using namespace Dew::Math::Units::MtxExpr;

void Example()
{
    double yScalar = 2.0, zScalar = 3.0;
    Vector X = { 1, 2, 3, 4 };
    Vector A1 = (X + yScalar) * zScalar;
    Vector A2 = AddAndMul(X, yScalar, zScalar);
    Vector A3;
    A3.AddAndMul(X, yScalar, zScalar);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 26: Matrix AddAndMul(TMtx *X, double Y, double Z);

Compute (X + yScalar)*zScalar, where X is a Matrix

#NameTypeDescription
1XTMtx *
2Ydouble
3Zdouble
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 27: Vector AddAndMul(TVec *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, TMtxVec *Z, const TCplx &zScale);

Compute (X*xScale + Y*yScale)*Z*zScale

#NameTypeDescription
1XTVec *
2xScaleconst TCplx &
3YTMtxVec *
4yScaleconst TCplx &
5ZTMtxVec *
6zScaleconst TCplx &
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 28: Matrix AddAndMul(TMtx *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, TMtxVec *Z, const TCplx &zScale);

Compute (X*xScale + Y*yScale)*Z*zScale, where X is a Matrix

#NameTypeDescription
1XTMtx *
2xScaleconst TCplx &
3YTMtxVec *
4yScaleconst TCplx &
5ZTMtxVec *
6zScaleconst TCplx &
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 29: Vector AddAndMul(TVec *X, const TCplx &xScale, TCplx Y, TMtxVec *Z, const TCplx &zScale);

Compute (X*xScale + yScalar)*Z*zScale

#NameTypeDescription
1XTVec *
2xScaleconst TCplx &
3YTCplx
4ZTMtxVec *
5zScaleconst TCplx &
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 30: Matrix AddAndMul(TMtx *X, const TCplx &xScale, TCplx Y, TMtxVec *Z, const TCplx &zScale);

Compute (X*xScale + yScalar)*Z*zScale, where X is a Matrix

#NameTypeDescription
1XTMtx *
2xScaleconst TCplx &
3YTCplx
4ZTMtxVec *
5zScaleconst TCplx &
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 31: Vector AddAndMul(TVec *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, const TCplx &Z);

Compute (X*xScale + Y*yScale)*zScalar

#NameTypeDescription
1XTVec *
2xScaleconst TCplx &
3YTMtxVec *
4yScaleconst TCplx &
5Zconst TCplx &
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 32: Matrix AddAndMul(TMtx *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, const TCplx &Z);

Compute (X*xScale + Y*yScale)*zScalar, where X is a Matrix

#NameTypeDescription
1XTMtx *
2xScaleconst TCplx &
3YTMtxVec *
4yScaleconst TCplx &
5Zconst TCplx &
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 33: Vector AddAndMul(TVec *X, const TCplx &xScale, TCplx Y, TCplx Z);

Compute (X*xScale + yScalar)*zScalar

#NameTypeDescription
1XTVec *
2xScaleconst TCplx &
3YTCplx
4ZTCplx
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler

Overload 34: Matrix AddAndMul(TMtx *X, const TCplx &xScale, TCplx Y, TCplx Z);

Compute (X*xScale + yScalar)*zScalar, where X is a Matrix

#NameTypeDescription
1XTMtx *
2xScaleconst TCplx &
3YTCplx
4ZTCplx
Declared in Dew::Math::Units::MtxExpr · Dew.Math/Units.MtxExpr.h · Cross-compiler