Vector::SubAndMul Method

Vector Struct

Overload List

#SignatureDescription
1TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, TMtxVec *Z) const;Compute (X - Y)*Z
2TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, TMtxVec *Z, int zIndex, int Index, int Len) const;Compute (X + Y)*Z on sub array
3TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, TMtxVec *Z, const double zScale) const;Compute (X - Y)*Z*zScale
4TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, TMtxVec *Z, const TCplx &zScale) const;Compute (X - Y)*Z*zScale
5TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;Compute (X - Y)*Z*zScale on sub array
6TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;Compute (X - Y)*Z*zScale on sub array
7TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale) const;Compute (X - Y*yScale)*Z*zScale
8TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const TCplx &yScale, TMtxVec *Z, const TCplx &zScale) const;Compute (X - Y*yScale)*Z*zScale
9TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const double yScale, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;Compute (X - Y*yScale)*Z*zScale on sub array
10TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const TCplx &yScale, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;Compute (X - Y*yScale)*Z*zScale on sub array
11TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const double Z) const;Compute (X - Y)*zScalar
12TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const TCplx &Z) const;Compute (X - Y)*zScalar
13TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const double Z, int Index, int Len) const;Compute (X - Y)*zScalar on sub array
14TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const TCplx &Z, int Index, int Len) const;Compute (X - Y)*zScalar on sub array
15TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const double yScale, const double Z) const;Compute (X - Y*yScale)*zScalar
16TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const TCplx &yScale, const TCplx &Z) const;Compute (X - Y*yScale)*zScalar
17TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const double yScale, const double Z, int Index, int Len) const;Compute (X - Y*yScale)*zScalar on sub array
18TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const TCplx &yScale, const TCplx &Z, int Index, int Len) const;Compute (X - Y*yScale)*zScalar on sub array
19TMtxVec *SubAndMul(TMtxVec *X, const double Y, TMtxVec *Z, const double zScale) const;Compute (X - yScalar)*Z*zScale
20TMtxVec *SubAndMul(TMtxVec *X, const TCplx &Y, TMtxVec *Z, const TCplx &zScale) const;Compute (X - yScalar)*Z*zScale
21TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double Y, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;Compute (X - yScalar)*Z*zScale on sub-array
22TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &Y, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;Compute (X - yScalar)*Z*zScale on sub-array
23TMtxVec *SubAndMul(TMtxVec *X, const double xScale, const double Y, TMtxVec *Z) const;Compute (X*xScale - yScalar)*Z
24TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, const TCplx &Y, TMtxVec *Z) const;Compute (X*xScale - yScalar)*Z
25TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, const double Y, TMtxVec *Z, int zIndex, int Index, int Len) const;Compute (X*xScale - yScalar)*Z on sub-array
26TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, const TCplx &Y, TMtxVec *Z, int zIndex, int Index, int Len) const;Compute (X*xScale - yScalar)*Z on sub-array
27TMtxVec *SubAndMul(TMtxVec *X, const double Y, TMtxVec *Z) const;Compute (X - yScalar)*Z
28TMtxVec *SubAndMul(TMtxVec *X, const TCplx &Y, TMtxVec *Z) const;Compute (X - yScalar)*Z
29TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double Y, TMtxVec *Z, int zIndex, int Index, int Len) const;Compute (X - yScalar)*Z on sub-array
30TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &Y, TMtxVec *Z, int zIndex, int Index, int Len) const;Compute (X - yScalar)*Z on sub-array
31TMtxVec *SubAndMul(TMtxVec *X, const double Y, const double Z) const;Compute (X - yScalar)*zScalar
32TMtxVec *SubAndMul(TMtxVec *X, const TCplx &Y, const TCplx &Z) const;Compute (X - yScalar)*zScalar
33TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double Y, const double Z, int Index, int Len) const;Compute (X - yScalar)*zScalar on sub-array
34TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &Y, const TCplx &Z, int Index, int Len) const;Compute (X - yScalar)*zScalar on sub-array
35TMtxVec *SubAndMul(TMtxVec *X, const double xScale, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale) const;Compute (X*xScale - Y*yScale)*Z*zScale
36TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, TMtxVec *Z, const TCplx &zScale) const;Compute (X*xScale - Y*yScale)*Z*zScale
37TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, TMtxVec *Y, int YIndex, const double yScale, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;Compute (X*xScale - Y*yScale)*Z*Scale on sub array
38TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, TMtxVec *Y, int YIndex, const TCplx &yScale, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;Compute (X*xScale - Y*yScale)*Z*Scale on sub array
39TMtxVec *SubAndMul(TMtxVec *X, const double xScale, TMtxVec *Y, const double yScale, const double Z) const;Compute (X*xScale - Y*yScale)*zScalar
40TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, const TCplx &Z) const;Compute (X*xScale - Y*yScale)*zScalar
41TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, TMtxVec *Y, int YIndex, const double yScale, const double Z, int Index, int Len) const;Compute (X*xScale - Y*yScale)*zScalar on sub array
42TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, TMtxVec *Y, int YIndex, const TCplx &yScale, const TCplx &Z, int Index, int Len) const;Compute (X*xScale - Y*yScale)*zScalar on sub array
43TMtxVec *SubAndMul(TMtxVec *X, const double xScale, const double Y, TMtxVec *Z, const double zScale) const;Compute (X*xScale - yScalar)*Z*zScale
44TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, const TCplx &Y, TMtxVec *Z, const TCplx &zScale) const;Compute (X*xScale - yScalar)*Z*zScale
45TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, const double Y, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;Compute (X*xScale - yScalar)*Z*zScale on sub-array
46TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, const TCplx &Y, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;Compute (X*xScale - yScalar)*Z*zScale on sub-array
47TMtxVec *SubAndMul(TMtxVec *X, const double xScale, const double Y, const double Z) const;Compute (X*xScale - yScalar)*zScalar
48TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, const TCplx &Y, const TCplx &Z) const;Compute (X*xScale - yScalar)*zScalar
49TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, const double Y, const double Z, int Index, int Len) const;Compute (X*xScale - yScalar)*zScalar on sub array
50TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, const TCplx &Y, const TCplx &Z, int Index, int Len) const;Compute (X*xScale - yScalar)*zScalar on sub array

Overload 1: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, TMtxVec *Z) const;

Compute (X - Y)*Z

#NameTypeDescription
1XTMtxVec *
2YTMtxVec *
3ZTMtxVec *
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Y, Z, A1, A2, A3;
    double xScale, yScale, zScale;

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

Overload 2: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, TMtxVec *Z, int zIndex, int Index, int Len) const;

Compute (X + Y)*Z on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5ZTMtxVec *
6zIndexint
7Indexint
8Lenint
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Y, A1, A2, A3;
    double xScale, yScale, zScalar;

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

Overload 3: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, TMtxVec *Z, const double zScale) const;

Compute (X - Y)*Z*zScale

#NameTypeDescription
1XTMtxVec *
2YTMtxVec *
3ZTMtxVec *
4zScaleconst double
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Z, A1, A2, A3;
    double xScale, yScalar, zScale;

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

Overload 4: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, TMtxVec *Z, const TCplx &zScale) const;

Compute (X - Y)*Z*zScale

#NameTypeDescription
1XTMtxVec *
2YTMtxVec *
3ZTMtxVec *
4zScaleconst TCplx &
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, A1, A2, A3;
    double xScale, yScalar, zScalar;

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

Overload 5: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;

Compute (X - Y)*Z*zScale on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5ZTMtxVec *
6zIndexint
7zScaleconst double
8Indexint
9Lenint
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Y, Z, A1, A2, A3;

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

Overload 6: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;

Compute (X - Y)*Z*zScale on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5ZTMtxVec *
6zIndexint
7zScaleconst TCplx &
8Indexint
9Lenint
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Y, Z, A1, A2, A3;
    double zScale;

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

Overload 7: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale) const;

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

#NameTypeDescription
1XTMtxVec *
2YTMtxVec *
3yScaleconst double
4ZTMtxVec *
5zScaleconst double
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, Y, Z, A1, A2, A3;
    double yScale, zScale;

    yScale = 1.5;
    zScale = 2.0;
    X = {5, 6, 7, 8};
    Y = {1, 2, 3, 4};
    Z = {2, 2, 2, 2};
    A1 = (X - Y * yScale) * Z * zScale;
    A2 = SubAndMul(X, Y, yScale, Z, zScale);  // Parameter order adapted to your implementation
    A3.SubAndMul(X, Y, yScale, Z, zScale);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 8: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const TCplx &yScale, TMtxVec *Z, const TCplx &zScale) const;

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

#NameTypeDescription
1XTMtxVec *
2YTMtxVec *
3yScaleconst TCplx &
4ZTMtxVec *
5zScaleconst TCplx &
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Y, A1, A2, A3;
    double zScalar;

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

Overload 9: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const double yScale, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;

Compute (X - Y*yScale)*Z*zScale on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5yScaleconst double
6ZTMtxVec *
7zIndexint
8zScaleconst double
9Indexint
10Lenint
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, Y, A1, A2, A3;
    double yScale, zScalar;

    yScale = 0.5;
    zScalar = 3.0;
    X = {1, 2, 3, 4};
    Y = {2, 4, 6, 8};
    // Compute (X - (Y * 0.5)) * 3
    A1 = (X - Y * yScale) * zScalar;
    A2 = SubAndMul(X, Y, yScale, zScalar);
    A3.SubAndMul(X, Y, yScale, zScalar);
    if (!A2.IsEqual(A1)) ERaise("Problem");
    if (!A3.IsEqual(A1)) ERaise("Problem");
}
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 10: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const TCplx &yScale, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;

Compute (X - Y*yScale)*Z*zScale on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5yScaleconst TCplx &
6ZTMtxVec *
7zIndexint
8zScaleconst TCplx &
9Indexint
10Lenint
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Z, A1, A2, A3;
    double yScalar, zScale;

    yScalar = 2.0;
    zScale = 4.0;
    X = {1, 2, 3, 4};
    Z = {2, 2, 2, 2};
    A1 = (X - yScalar) * Z * zScale;
    A2 = SubAndMul(X, yScalar, Z, zScale);
    A3.SubAndMul(X, yScalar, Z, zScale);
    if (!A2.IsEqual(A1))
        ERaise("Problem");
    if (!A3.IsEqual(A1))
        ERaise("Problem");
}
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 11: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const double Z) const;

Compute (X - Y)*zScalar

#NameTypeDescription
1XTMtxVec *
2YTMtxVec *
3Zconst double
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Z, A1, A2, A3;
    double xScale, yScalar;

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

Overload 12: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const TCplx &Z) const;

Compute (X - Y)*zScalar

#NameTypeDescription
1XTMtxVec *
2YTMtxVec *
3Zconst TCplx &
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, Z, A1, A2, A3;
    double yScalar;

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

Overload 13: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const double Z, int Index, int Len) const;

Compute (X - Y)*zScalar on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5Zconst double
6Indexint
7Lenint
Examples
#include "MtxExpr.h"
#include "Units.Math387.h"
#include "Units.MtxExpr.h"
#include "Units.MtxVec.h"

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

void Example()
{
    Vector X, A1, A2, A3;
    double yScalar, zScalar;

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

Overload 14: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const TCplx &Z, int Index, int Len) const;

Compute (X - Y)*zScalar on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5Zconst TCplx &
6Indexint
7Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 15: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const double yScale, const double Z) const;

Compute (X - Y*yScale)*zScalar

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

Overload 16: TMtxVec *SubAndMul(TMtxVec *X, TMtxVec *Y, const TCplx &yScale, const TCplx &Z) const;

Compute (X - Y*yScale)*zScalar

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

Overload 17: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const double yScale, const double Z, int Index, int Len) const;

Compute (X - Y*yScale)*zScalar on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5yScaleconst double
6Zconst double
7Indexint
8Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 18: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, TMtxVec *Y, int YIndex, const TCplx &yScale, const TCplx &Z, int Index, int Len) const;

Compute (X - Y*yScale)*zScalar on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3YTMtxVec *
4YIndexint
5yScaleconst TCplx &
6Zconst TCplx &
7Indexint
8Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 19: TMtxVec *SubAndMul(TMtxVec *X, const double Y, TMtxVec *Z, const double zScale) const;

Compute (X - yScalar)*Z*zScale

#NameTypeDescription
1XTMtxVec *
2Yconst double
3ZTMtxVec *
4zScaleconst double
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

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

Compute (X - yScalar)*Z*zScale

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

Overload 21: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double Y, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;

Compute (X - yScalar)*Z*zScale on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3Yconst double
4ZTMtxVec *
5zIndexint
6zScaleconst double
7Indexint
8Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 22: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &Y, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;

Compute (X - yScalar)*Z*zScale on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3Yconst TCplx &
4ZTMtxVec *
5zIndexint
6zScaleconst TCplx &
7Indexint
8Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 23: TMtxVec *SubAndMul(TMtxVec *X, const double xScale, const double Y, TMtxVec *Z) const;

Compute (X*xScale - yScalar)*Z

#NameTypeDescription
1XTMtxVec *
2xScaleconst double
3Yconst double
4ZTMtxVec *
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 24: TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, const TCplx &Y, TMtxVec *Z) const;

Compute (X*xScale - yScalar)*Z

#NameTypeDescription
1XTMtxVec *
2xScaleconst TCplx &
3Yconst TCplx &
4ZTMtxVec *
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 25: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, const double Y, TMtxVec *Z, int zIndex, int Index, int Len) const;

Compute (X*xScale - yScalar)*Z on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst double
4Yconst double
5ZTMtxVec *
6zIndexint
7Indexint
8Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 26: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, const TCplx &Y, TMtxVec *Z, int zIndex, int Index, int Len) const;

Compute (X*xScale - yScalar)*Z on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst TCplx &
4Yconst TCplx &
5ZTMtxVec *
6zIndexint
7Indexint
8Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 27: TMtxVec *SubAndMul(TMtxVec *X, const double Y, TMtxVec *Z) const;

Compute (X - yScalar)*Z

#NameTypeDescription
1XTMtxVec *
2Yconst double
3ZTMtxVec *
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 28: TMtxVec *SubAndMul(TMtxVec *X, const TCplx &Y, TMtxVec *Z) const;

Compute (X - yScalar)*Z

#NameTypeDescription
1XTMtxVec *
2Yconst TCplx &
3ZTMtxVec *
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 29: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double Y, TMtxVec *Z, int zIndex, int Index, int Len) const;

Compute (X - yScalar)*Z on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3Yconst double
4ZTMtxVec *
5zIndexint
6Indexint
7Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 30: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &Y, TMtxVec *Z, int zIndex, int Index, int Len) const;

Compute (X - yScalar)*Z on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3Yconst TCplx &
4ZTMtxVec *
5zIndexint
6Indexint
7Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 31: TMtxVec *SubAndMul(TMtxVec *X, const double Y, const double Z) const;

Compute (X - yScalar)*zScalar

#NameTypeDescription
1XTMtxVec *
2Yconst double
3Zconst double
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 32: TMtxVec *SubAndMul(TMtxVec *X, const TCplx &Y, const TCplx &Z) const;

Compute (X - yScalar)*zScalar

#NameTypeDescription
1XTMtxVec *
2Yconst TCplx &
3Zconst TCplx &
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 33: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double Y, const double Z, int Index, int Len) const;

Compute (X - yScalar)*zScalar on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3Yconst double
4Zconst double
5Indexint
6Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 34: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &Y, const TCplx &Z, int Index, int Len) const;

Compute (X - yScalar)*zScalar on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3Yconst TCplx &
4Zconst TCplx &
5Indexint
6Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 35: TMtxVec *SubAndMul(TMtxVec *X, const double xScale, TMtxVec *Y, const double yScale, TMtxVec *Z, const double zScale) const;

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

#NameTypeDescription
1XTMtxVec *
2xScaleconst double
3YTMtxVec *
4yScaleconst double
5ZTMtxVec *
6zScaleconst double
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 36: TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, TMtxVec *Z, const TCplx &zScale) const;

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

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

Overload 37: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, TMtxVec *Y, int YIndex, const double yScale, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;

Compute (X*xScale - Y*yScale)*Z*Scale on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst double
4YTMtxVec *
5YIndexint
6yScaleconst double
7ZTMtxVec *
8zIndexint
9zScaleconst double
10Indexint
11Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 38: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, TMtxVec *Y, int YIndex, const TCplx &yScale, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;

Compute (X*xScale - Y*yScale)*Z*Scale on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst TCplx &
4YTMtxVec *
5YIndexint
6yScaleconst TCplx &
7ZTMtxVec *
8zIndexint
9zScaleconst TCplx &
10Indexint
11Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 39: TMtxVec *SubAndMul(TMtxVec *X, const double xScale, TMtxVec *Y, const double yScale, const double Z) const;

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

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

Overload 40: TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, TMtxVec *Y, const TCplx &yScale, const TCplx &Z) const;

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

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

Overload 41: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, TMtxVec *Y, int YIndex, const double yScale, const double Z, int Index, int Len) const;

Compute (X*xScale - Y*yScale)*zScalar on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst double
4YTMtxVec *
5YIndexint
6yScaleconst double
7Zconst double
8Indexint
9Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 42: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, TMtxVec *Y, int YIndex, const TCplx &yScale, const TCplx &Z, int Index, int Len) const;

Compute (X*xScale - Y*yScale)*zScalar on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst TCplx &
4YTMtxVec *
5YIndexint
6yScaleconst TCplx &
7Zconst TCplx &
8Indexint
9Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 43: TMtxVec *SubAndMul(TMtxVec *X, const double xScale, const double Y, TMtxVec *Z, const double zScale) const;

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

#NameTypeDescription
1XTMtxVec *
2xScaleconst double
3Yconst double
4ZTMtxVec *
5zScaleconst double
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 44: TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, const TCplx &Y, TMtxVec *Z, const TCplx &zScale) const;

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

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

Overload 45: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, const double Y, TMtxVec *Z, int zIndex, const double zScale, int Index, int Len) const;

Compute (X*xScale - yScalar)*Z*zScale on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst double
4Yconst double
5ZTMtxVec *
6zIndexint
7zScaleconst double
8Indexint
9Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 46: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, const TCplx &Y, TMtxVec *Z, int zIndex, const TCplx &zScale, int Index, int Len) const;

Compute (X*xScale - yScalar)*Z*zScale on sub-array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst TCplx &
4Yconst TCplx &
5ZTMtxVec *
6zIndexint
7zScaleconst TCplx &
8Indexint
9Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 47: TMtxVec *SubAndMul(TMtxVec *X, const double xScale, const double Y, const double Z) const;

Compute (X*xScale - yScalar)*zScalar

#NameTypeDescription
1XTMtxVec *
2xScaleconst double
3Yconst double
4Zconst double
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 48: TMtxVec *SubAndMul(TMtxVec *X, const TCplx &xScale, const TCplx &Y, const TCplx &Z) const;

Compute (X*xScale - yScalar)*zScalar

#NameTypeDescription
1XTMtxVec *
2xScaleconst TCplx &
3Yconst TCplx &
4Zconst TCplx &
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 49: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const double xScale, const double Y, const double Z, int Index, int Len) const;

Compute (X*xScale - yScalar)*zScalar on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst double
4Yconst double
5Zconst double
6Indexint
7Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler

Overload 50: TMtxVec *SubAndMul(TMtxVec *X, int XIndex, const TCplx &xScale, const TCplx &Y, const TCplx &Z, int Index, int Len) const;

Compute (X*xScale - yScalar)*zScalar on sub array

#NameTypeDescription
1XTMtxVec *
2XIndexint
3xScaleconst TCplx &
4Yconst TCplx &
5Zconst TCplx &
6Indexint
7Lenint
Declared in Dew::Math::Vector · Dew.Math/MtxExpr.h · Cross-compiler