g++ [flags ...] file ... -l /isip/tools/lib/$ISIP_BINARY/lib_algo.a

#include <Math.h>

Math();
Math(const Math& arg);
const String& className() const;
boolean setNumOperands(long num);
boolean setFunction(const String& functions);
boolean setOperation(const String& operations);
boolean compute(VectorFloat& output, const VectorFloat& input);

// compute Y = 2.0 * X1 + 3.0 * X2 + 2.0
//
Math math;
math.setConstant(2.0);
math.setWeight(L"2.0, 3.0");

VectorFloat input;
VectorFloat output;
VectorFloat result;

input.assign(L"1.1, 4.0, 1.5, 2.3, 1.0, 1.0, 0.0, 0.0");
math.compute(output, input);

1. The behavior of these options are the same for all functions supported. See the definition of the enumeration named FUNCTION above for an exhaustive list.
   
   
2. All function choices are implemented the same way as shown in these two examples. The selection of functions available is based on the math functions available in the Math Scalar classes.
3. Note that the input values can be matrices and vectors. In this case, limited linear algebra options (e.g., INVERSE, TRANSPOSE) are supported in addition to the normal math function (e.g., ADD).

• This example shows how to compute an equation of the form:
  
  
  y = x(0) + x(1) - log(x(2)) - exp(x4)
  
  using the Math class. Note that inputs are numbered starting at zero.

  // isip include files
  //
  #include <Math.h>
  
  // main program starts here
  // compute Y = X1 + X2 - log(X3) - exp(X4)
  //
  int main(int argc, const char **argv) {
  
    // declare a Math object
    //
    Math math;
  
    // set the number of operands and weights for each operand
    //
    math.setNumOperands(4);    
    math.setWeight(L"1.0, 2.0, 1.0, 1.0");
  
    // declare and set the functions
    //
    VectorLong values(4);
    values(0).assign((long)Math::IDENTITY);
    values(1).assign((long)Math::IDENTITY);
    values(2).assign((long)Math::LOG);
    values(3).assign((long)Math::EXP);
    math.setFunction(values);
  
    // declare and set the operations
    //
    VectorLong values_op(4);
    values_op(0).assign((long)Math::ASSIGN);
    values_op(1).assign((long)Math::ADD);
    values_op(2).assign((long)Math::SUBTRACT);
    values_op(3).assign((long)Math::SUBTRACT);
    math.setOperation(values_op);
  
    // declare the input, output and the expected result
    //
    Vector input;
    AlgorithmData output;
    VectorFloat result;
  
    // set the input object
    //
    input.setLength(4);
    input(0).makeVectorFloat().assign(L"1.1, 4.0");
    input(1).makeVectorFloat().assign(L"1.5, 2.3");
    input(2).makeVectorFloat().assign(L"1.0, 1.0");
    input(3).makeVectorFloat().assign(L"0.0, 0.0");
    
    // compute the output object
    //
    math.compute(output, input);
    
    // error if the expected output is not equal to the actual output
    //
    result.assign(L"3.1, 7.6");
    if (!result.almostEqual(output.getVectorFloat())) {
      input.debug(L"input:");
      output.debug(L"actual output:");
      result.debug(L"expected output:");
      return Error::handle(math.name(), L"compute", Error::TEST,
         __FILE__, __LINE__);
     }
  
    // print the input and output to console
    //
    input.debug(L"input:");
    output.debug(L"actual output:");
    
    // exit gracefully
    //
    Integral::exit();
  }

• In this example, we compute:
  
  
  y = x(0) + square(x(1)) + exp(x(2)) + 0.5
  
  using the Math class. In this case, we demonstrate how to use the setConstant method.

  // isip include files
  // 
  #include 
  
  // main program starts here
  // compute Y = X0 + square(X1) + exp(X2) + 0.5
  //
  int main(int argc, const char **argv) {
  
    // declare a Math object
    //
    Math math;
  
    // set the number of operands, weights for each operand and constant
    // value
    //
    math.setNumOperands(3);
    math.setWeight(L"1.0, 2.0, 1.0");
    math.setConstant(0.5);
    
    // declare and set the functions
    //
    VectorLong values(3);
    values(0).assign((long)Math::IDENTITY);
    values(1).assign((long)Math::SQUARE);
    values(2).assign((long)Math::EXP);
    math.setFunction(values);
   
    // declare and set the operations
    //
    VectorLong values_op(3);
    values_op(0).assign((long)Math::ASSIGN);
    values_op(1).assign((long)Math::ADD);
    values_op(2).assign((long)Math::ADD);
    math.setOperation(values_op);  
    
    // declare the input, output and the expected result
    //  
    Vector input;
    AlgorithmData output;
    VectorComplexFloat result;
   
    // set the input object
    //
    input.setLength(3);
    input(0).makeVectorComplexFloat().assign(L"1.1 + 1.1j, 4.0 + 4.0j");
    input(1).makeVectorComplexFloat().assign(L"1.5 + 1.5j, 2.3 + 2.3j");
    input(2).makeVectorComplexFloat().assign(L"1.0 + 1.0j, 1.0 + 1.0j");
  
    // compute the output object
    //
    math.compute(output, input);
   
    // error if the expected output is not equal to the actual output
    //
    result.assign(L"2.56869+12.3874j, 5.46869+27.4474j");  
    if (!result.almostEqual(output.getVectorComplexFloat())) {
      input.debug(L"input:");
      output.debug(L"actual output:");
      result.debug(L"expected output:");
      return Error::handle(math.name(), L"compute", Error::TEST,
  			 __FILE__, __LINE__);
    }
    
    // print the input and output to console
    //
    input.debug(L"input:");
    output.debug(L"output:");
    
    // exit gracefully
    //
    Integral::exit();
  }

• Note that the function setNumOperands resets the function and operations specifications. Hence, it should be called first, since the previous settings will be lost.