MtxExpr::DivAndSub Function

MtxExpr Namespace

Overload List

#SignatureDescription
1Vector DivAndSub(TVec *X, TMtxVec *Y, const double xyScale, TMtxVec *Z, const double zScale);Compute (X / Y) * xyScale - Z*zScale
2Matrix DivAndSub(TMtx *X, TMtxVec *Y, const double xyScale, TMtxVec *Z, const double zScale);Compute (X / Y) * xyScale - Z*zScale, where X is a Matrix
3Vector DivAndSub(TVec *X, TMtxVec *Y, const TCplx &xyScale, TMtxVec *Z, const TCplx &zScale);Compute (X / Y) * xyScale - Z*zScale
4Matrix DivAndSub(TMtx *X, TMtxVec *Y, const TCplx &xyScale, TMtxVec *Z, const TCplx &zScale);Compute (X / Y) * xyScale - Z*zScale, where X is a Matrix
5Vector DivAndSub(TVec *X, TMtxVec *Y, const double xyScale, const double Z);Compute (X / Y) * xyScale - zScalar
6Matrix DivAndSub(TMtx *X, TMtxVec *Y, const double xyScale, const double Z);Compute (X / Y) * xyScale - zScalar, where X is a Matrix
7Vector DivAndSub(TVec *X, TMtxVec *Y, const TCplx &xyScale, const TCplx &Z);Compute (X / Y) * xyScale - zScalar
8Matrix DivAndSub(TMtx *X, TMtxVec *Y, const TCplx &xyScale, const TCplx &Z);Compute (X / Y) * xyScale - zScalar, where X is a Matrix
9Vector DivAndSub(TVec *X, TMtxVec *Y, TMtxVec *Z);Compute X/Y - Z
10Matrix DivAndSub(TMtx *X, TMtxVec *Y, TMtxVec *Z);Compute X/Y - Z, where X is a Matrix
11Vector DivAndSub(TVec *X, TMtxVec *Y, const double xyScale, TMtxVec *Z);Compute X/Y*xyScale - Z
12Matrix DivAndSub(TMtx *X, TMtxVec *Y, const double xyScale, TMtxVec *Z);Compute X/Y*xyScale - Z, where X is a Matrix
13Vector DivAndSub(TVec *X, TMtxVec *Y, TMtxVec *Z, const double zScale);Compute X/Y - Z*zScale
14Matrix DivAndSub(TMtx *X, TMtxVec *Y, TMtxVec *Z, const double zScale);Compute X/Y - Z*zScale, where X is a Matrix
15Vector DivAndSub(TVec *X, TMtxVec *Y, const double Z);Compute X/Y - zScalar
16Matrix DivAndSub(TMtx *X, TMtxVec *Y, const double Z);Compute X/Y - zScalar, where X is a Matrix
17Vector DivAndSub(TVec *X, TMtxVec *Y, const TCplx &xyScale, TMtxVec *Z);Compute X/Y*xyScale - Z
18Matrix DivAndSub(TMtx *X, TMtxVec *Y, const TCplx &xyScale, TMtxVec *Z);Compute X/Y*xyScale - Z, where X is a Matrix
19Vector DivAndSub(TVec *X, TMtxVec *Y, TMtxVec *Z, const TCplx &zScale);Compute X/Y - Z*zScale
20Matrix DivAndSub(TMtx *X, TMtxVec *Y, TMtxVec *Z, const TCplx &zScale);Compute X/Y - Z*zScale, where X is a Matrix
21Vector DivAndSub(TVec *X, TMtxVec *Y, const TCplx &Z);Compute X/Y - zScalar
22Matrix DivAndSub(TMtx *X, TMtxVec *Y, const TCplx &Z);Compute X/Y - zScalar, where X is a Matrix

Overload 1: Vector DivAndSub(TVec *X, TMtxVec *Y, const double xyScale, TMtxVec *Z, const double zScale);

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

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

Divides X by Y, scales the quotient by xyScale, then subtracts Z scaled by zScale, all 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 xyScale = 1.5, zScale = 2.0;
    Vector X = {8, 10, 12, 14};
    Vector Y = {2, 2, 2, 2};
    Vector Z = {1, 1, 1, 1};
    Vector A1 = (X / Y) * xyScale - Z * zScale;
    Vector A2 = DivAndSub(X, Y, xyScale, Z, zScale);
    Vector A3;
    A3.DivAndSub(X, Y, xyScale, 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 DivAndSub(TMtx *X, TMtxVec *Y, const double xyScale, TMtxVec *Z, const double zScale);

Compute (X / Y) * xyScale - Z*zScale, where X is a Matrix

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3xyScaleconst 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 3: Vector DivAndSub(TVec *X, TMtxVec *Y, const TCplx &xyScale, TMtxVec *Z, const TCplx &zScale);

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

#NameTypeDescription
1XTVec *
2YTMtxVec *
3xyScaleconst TCplx &
4ZTMtxVec *
5zScaleconst TCplx &
Remarks:

The operation does only per-element math.

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

Overload 4: Matrix DivAndSub(TMtx *X, TMtxVec *Y, const TCplx &xyScale, TMtxVec *Z, const TCplx &zScale);

Compute (X / Y) * xyScale - Z*zScale, where X is a Matrix

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3xyScaleconst TCplx &
4ZTMtxVec *
5zScaleconst TCplx &
Remarks:

The operation does only per-element math.

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

Overload 5: Vector DivAndSub(TVec *X, TMtxVec *Y, const double xyScale, const double Z);

Compute (X / Y) * xyScale - zScalar

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

Computes the expression (X divided by Y) multiplied by xyScale and then subtracts the scalar zScalar, all 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 xyScale = 1.5, zScalar = 2.0;
    Vector X = {8, 10, 12, 14};
    Vector Y = {2, 2, 2, 2};
    Vector A1 = (X / Y) * xyScale - zScalar;
    Vector A2 = DivAndSub(X, Y, xyScale, zScalar);
    Vector A3;
    A3.DivAndSub(X, Y, xyScale, 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 DivAndSub(TMtx *X, TMtxVec *Y, const double xyScale, const double Z);

Compute (X / Y) * xyScale - zScalar, where X is a Matrix

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3xyScaleconst double
4Zconst 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 DivAndSub(TVec *X, TMtxVec *Y, const TCplx &xyScale, const TCplx &Z);

Compute (X / Y) * xyScale - zScalar

#NameTypeDescription
1XTVec *
2YTMtxVec *
3xyScaleconst TCplx &
4Zconst TCplx &
Remarks:

The operation does only per-element math.

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

Overload 8: Matrix DivAndSub(TMtx *X, TMtxVec *Y, const TCplx &xyScale, const TCplx &Z);

Compute (X / Y) * xyScale - zScalar, where X is a Matrix

#NameTypeDescription
1XTMtx *
2YTMtxVec *
3xyScaleconst TCplx &
4Zconst TCplx &
Remarks:

The operation does only per-element math.

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

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

Compute X/Y - Z

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

Divides X by Y element-wise and then subtracts Z, 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()
{
    Vector X = { 6, 8, 10, 12 };
    Vector Y = { 2, 2, 2, 2 };
    Vector Z = { 1, 1, 1, 1 };
    Vector A1 = (X / Y) - Z;
    Vector A2 = DivAndSub(X, Y, Z);
    Vector A3;
    A3.DivAndSub(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 DivAndSub(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 DivAndSub(TVec *X, TMtxVec *Y, const double xyScale, TMtxVec *Z);

Compute X/Y*xyScale - Z

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

Divides X by Y element-wise, multiplies the quotient by xyScale, and then subtracts 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 xyScale = 1.5;
    Vector X = { 8, 10, 12, 14 };
    Vector Y = { 2, 2, 2, 2 };
    Vector Z = { 1, 1, 1, 1 };
    Vector A1 = (X / Y) * xyScale - Z;
    Vector A2 = DivAndSub(X, Y, xyScale, Z);
    Vector A3;
    A3.DivAndSub(X, Y, xyScale, 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 12: Matrix DivAndSub(TMtx *X, TMtxVec *Y, const double xyScale, TMtxVec *Z);

Compute X/Y*xyScale - Z, where X is a Matrix

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

The operation does only per-element math.

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

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

Compute X/Y - Z*zScale

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

Divides X by Y element-wise and then subtracts Z multiplied by 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 = { 6, 8, 10, 12 };
    Vector Y = { 2, 2, 2, 2 };
    Vector Z = { 1, 1, 1, 1 };
    Vector A1 = (X / Y) - (Z * zScale);
    Vector A2 = DivAndSub(X, Y, Z, zScale);
    Vector A3;
    A3.DivAndSub(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 14: Matrix DivAndSub(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 15: Vector DivAndSub(TVec *X, TMtxVec *Y, const double Z);

Compute X/Y - zScalar

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

Divides X by Y element-wise and then subtracts 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 zScalar = 2.0;
    Vector X = { 6, 8, 10, 12 };
    Vector Y = { 2, 2, 2, 2 };
    Vector A1 = (X / Y) - zScalar;
    Vector A2 = DivAndSub(X, Y, zScalar);
    Vector A3;
    A3.DivAndSub(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 DivAndSub(TMtx *X, TMtxVec *Y, const double Z);

Compute X/Y - zScalar, where X is a Matrix

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

The operation does only per-element math.

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

Overload 17: Vector DivAndSub(TVec *X, TMtxVec *Y, const TCplx &xyScale, TMtxVec *Z);

Compute X/Y*xyScale - Z

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

Overload 18: Matrix DivAndSub(TMtx *X, TMtxVec *Y, const TCplx &xyScale, TMtxVec *Z);

Compute X/Y*xyScale - Z, where X is a Matrix

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

Overload 19: Vector DivAndSub(TVec *X, TMtxVec *Y, TMtxVec *Z, const TCplx &zScale);

Compute X/Y - Z*zScale

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

Overload 20: Matrix DivAndSub(TMtx *X, TMtxVec *Y, TMtxVec *Z, const TCplx &zScale);

Compute X/Y - Z*zScale, where X is a Matrix

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

Overload 21: Vector DivAndSub(TVec *X, TMtxVec *Y, const TCplx &Z);

Compute X/Y - zScalar

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

Overload 22: Matrix DivAndSub(TMtx *X, TMtxVec *Y, const TCplx &Z);

Compute X/Y - zScalar, where X is a Matrix

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