math_02.cc

这是一个从音频信号里提取特征参量的程序

  if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting for Y = [X1 + X2 * X3' + inv(x4)] (matrix + matrix * trans(matrix) + inv(matrix)):\n");
  }

  values.setLength(4);
  values_op.setLength(4);
  values(0).assign((long)IDENTITY);
  values(1).assign((long)IDENTITY);
  values(2).assign((long)TRANSPOSE);
  values(3).assign((long)INVERSE);
  
  values_op(0).assign((long)ASSIGN);
  values_op(1).assign((long)ADD);
  values_op(2).assign((long)MULTIPLY);
  values_op(3).assign((long)ADD);
  math6.setNumOperands(4);
  math6.setOperation(values_op);
  math6.setFunction(values);
  math6.setWeight(L"1.0, 1.0, 1.0, 1.0");
  math6.setConstant(0.0);
  input.setLength(4);
  input(0).makeMatrixDouble().assign(3, 3, L"1.0, 0.0, 5.0, 1.2, 2.4, 3.6, 1.8, 2.1, 9.8");
  input(1).makeMatrixDouble().assign(3, 3, L"2.0, 2.1, 3.2, 1.1, 2.1, 3.2, 4.2, 5.1, 1.1");
  input(2).makeMatrixDouble().assign(3, 3, L"1, 2, 3, 3, 2, 1, 2, 1, 1");
  input(3).makeMatrixDouble().assign(3, 3, L"5.1, 2.1, 2.2, 1.0, 1.0, 2.2, 2.1, 1.1, 2.1");

  MatrixDouble result_mat_db;
  math6.compute(output, input);
  
  result_mat_db.assign(3, 3, L"31.5808, 20.0370, 17.9575, 33.4260, 26.8712, 9.7219, 52.4151, 42.4781, 32.1548");
  
  if (!(result_mat_db).almostEqual(output.getMatrixDouble())) {
    output.debug(L"output");
    result_mat_db.debug(L"result");
    return Error::handle(name(), L"apply", Error::TEST,
			 __FILE__, __LINE__);
  }
  
  // test scalar addition
  //
  if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar addition (1):\n");
  }

  input.setLength(2);
  input(0).makeVectorDouble().assign(L"4.0");
  input(1).makeVectorDouble().assign(L"1.0, 2.0, 3.0, 4.0");

  values.setLength(2);
  values(0).assign((long)IDENTITY);
  values(1).assign((long)IDENTITY);

  values_op.setLength(2);
  values_op(0).assign((long)ASSIGN);
  values_op(1).assign((long)ADD);

  math7.setFunction(values);
  math7.setOperation(values_op);
  math7.compute(output, input);

  VectorDouble expected_db(L"5.0, 6.0, 7.0, 8.0");
  if (!output.getVectorDouble().almostEqual(expected_db)) {
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
  }

  /*
    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar addition (2):\n");
    }

    input(0).makeVectorDouble().assign(L"1.0, 2.0, 3.0, 4.0");
    input(1).makeVectorDouble().assign(L"4.0");

    math7.compute(output, input);

    expected.assign(L"5.0, 6.0, 7.0, 8.0");
    if (!output.getVectorDouble().almostEqual(expected)) {
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }

    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar addition (3):\n");
    }
  
    MatrixDouble a(3, 3);
    a.setDiagonal(4);

    MatrixDouble b(3, 3);
    b.assign(7);
    b.setDiagonal(11);

    input(0).makeVectorDouble().assign(L"7.0");
    input(1).makeMatrixDouble().assign(a);
  
    math7.compute(output, input);

    if (!output.getMatrixDouble().almostEqual(b)) {
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }
  
    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar addition (4):\n");
    }
    
    input(0).makeMatrixDouble().assign(a);
    input(1).makeVectorDouble().assign(L"7.0");
    
    math7.compute(output, input);

    if (!output.getMatrixDouble().almostEqual(b)) {
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }
  */
    
  // test scalar subtraction
  //
  if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar subtraction (1):\n");
  }
  
  input.setLength(2);
  input(0).makeVectorDouble().assign(L"4.0");
  input(1).makeVectorDouble().assign(L"1.0, 2.0, 3.0, 4.0");

  values.setLength(2);
  values(0).assign((long)IDENTITY);
  values(1).assign((long)IDENTITY);

  math7.setFunction(values);
  
  values_op.setLength(2);
  values_op(0).assign((long)ASSIGN);
  values_op(1).assign((long)SUBTRACT);

  math7.setOperation(values_op);
  
  math7.compute(output, input);

  expected_db.assign(L"3.0, 2.0, 1.0, 0.0");
  if (!output.getVectorDouble().almostEqual(expected_db)) {
    output.debug(L"output");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
  }
  
  input(0).makeVectorDouble().assign(L"1.0, 2.0, 3.0, 4.0");
  input(1).makeVectorDouble().assign(L"4.0");

  math7.compute(output, input);

  expected_db.assign(L"-3.0, -2.0, -1.0, 0.0");

  if (!output.getVectorDouble().almostEqual(expected_db)) {
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
  }

  /*
    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar subtraction (2):\n");
    }
  
    a.clear(Integral::RETAIN);
    a.setDiagonal(4);

    b.clear(Integral::RETAIN);
    b.assign(7);
    b.setDiagonal(11);

    input(0).makeVectorDouble().assign(L"7.0");
    input(1).makeMatrixDouble().assign(a);

    math7.compute(output, input);

    b.assign(7);
    b.setDiagonal(3.0);
  
    if (!output.getMatrixDouble().almostEqual(b)) {
    output.debug(L"output");
    b.debug(L"b");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }

    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar subtraction (3):\n");
    }
  
    input(0).makeMatrixDouble().assign(a);
    input(1).makeVectorDouble().assign(L"7.0");

    b.assign(-7.0);
    b.setDiagonal(-3.0);
    math7.compute(output, input);

    if (!output.getMatrixDouble().almostEqual(b)) {
    output.debug(L"output");
    b.debug(L"b");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }
  */
    
  // test scalar multiplication
  //
  if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar multiplication (1):\n");
  }
  
  values_op(1).assign((long)MULTIPLY);
  math7.setOperation(values_op);

  input(0).makeVectorDouble().assign(L"3.0");
  input(1).makeVectorDouble().assign(L"2.0, 3.0, 4.0");

  expected_db.assign(L"6.0, 9.0, 12.0");

  math7.compute(output, input);

  if (!output.getVectorDouble().almostEqual(expected_db)) {
    output.debug(L"output");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
  }

  /*
    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar multiplication (2):\n");
    }
  
    input(0).makeVectorDouble().assign(L"2.0, 3.0, 4.0");
    input(1).makeVectorDouble().assign(L"3.0");

    expected_db.assign(L"6.0, 9.0, 12.0");

    math7.compute(output, input);

    if (!output.getVectorDouble().almostEqual(expected_db)) {
    output.debug(L"output");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }

    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar multiplication (2):\n");
    }
  
    a.clear(Integral::RETAIN);
    a.setDiagonal(3.0);
  
    input(0).makeMatrixDouble().assign(a);
    input(1).makeVectorDouble().assign(L"3.0");

    b.clear(Integral::RETAIN);
    b.setDiagonal(9.0);

    math7.compute(output, input);

    if (!output.getMatrixDouble().almostEqual(b)) {
    output.debug(L"output");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }

    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar multiplication (3):\n");
    }
  
    input(0).makeVectorDouble().assign(L"3.0");
    input(1).makeMatrixDouble().assign(a);
  
    math7.compute(output, input);

    if (!output.getMatrixDouble().almostEqual(b)) {
    output.debug(L"output");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }
  */
    
  // test scalar division
  //
  if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar division (1):\n");
  }
  
  values_op(1).assign((long)DIVIDE);
  math7.setOperation(values_op);

  input(0).makeVectorDouble().assign(L"9.0, 6.0, 3.0");
  input(1).makeVectorDouble().assign(L"3.0");

  expected_db.assign(L"3.0, 2.0, 1.0");

  math7.compute(output, input);

  if (!output.getVectorDouble().almostEqual(expected_db)) {
    output.debug(L"output");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
  }

  /*
    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting  scalar division (2):\n");
    }
  
    a.clear(Integral::RETAIN);
    a.setDiagonal(6.0);
  
    input(0).makeMatrixDouble().assign(a);
    input(1).makeVectorDouble().assign(L"3.0");

    b.clear(Integral::RETAIN);
    b.setDiagonal(2.0);

    math7.compute(output, input);

    if (!output.getMatrixDouble().almostEqual(b)) {
    output.debug(L"output");
    return Error::handle(name(), L"compute", Error::TEST, __FILE__, __LINE__);
    }
  */
    
  // reset indentation
  //
  if (level_a > Integral::NONE) {
    Console::decreaseIndention();
  }
        
  //--------------------------------------------------------------------------
  //
  // 5. class-specific public methods:
  //     computational methods for complexfloat
  //
  //--------------------------------------------------------------------------
  
  // set indentation
  //
  if (level_a > Integral::NONE) {
    Console::put(L"testing class-specific public methods: computational methods for complexfloat...\n");
    Console::increaseIndention();
  }

  /*
    // test Y = 2.0 * X1 + 3.0 * X2 + 2.0
    //
    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting for Y = [2.0 * X1 + 3.0 * X2 + 2.0]:\n");
    }

    Math math6;
    math6.setNumOperands(2);
    math6.setConstant(2.0);
    math6.setWeight(L"2.0, 3.0");

    // set up the variables for test
    //
    Vector<AlgorithmData> input(2);
    AlgorithmData output;
    VectorComplexFloat result;

    input(0).makeVectorComplexFloat().assign(L"1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j");
    input(1).makeVectorComplexFloat().assign(L"1 + 1j, 2 + 2j, 3 + 3j, 4 + 4j");
    math6.compute(output, input);

    result.assign(L"7 + 5j, 12 + 10j, 17 + 15j, 22 + 20j");

    if (!result.almostEqual(output.getVectorComplexFloat())) {
    output.getVectorComplexFloat().debug(L"output");
    return Error::handle(name(), L"compute", Error::TEST,
    __FILE__, __LINE__);
    }

    // test Y = log(X1);
    //
    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting for Y = [log(X1)]:\n");
    }
  
    VectorLong values_01(1);
    values_01(0).assign((long)LOG);

    VectorLong values_op_01(1);
    values_op_01(0).assign((long)ASSIGN);

    math6.clear();
    math6.setNumOperands(1);
    math6.setWeight(L"1.0");
    math6.setOperation(values_op_01);
    math6.setFunction(values_01);
  
    input.setLength(1);
    input(0).makeVectorComplexFloat().assign(L"10.0 + 5.0j, 3.0 - 3.0j");

    output.clear();
    math6.compute(output, input);
    result.assign(L"2.41416 + 0.463648j, 1.44519 - 0.785398j");

    if (!result.almostEqual(output.getVectorComplexFloat())) {
    output.debug(L"output");
    result.debug(L"result");
    return Error::handle(name(), L"compute", Error::TEST,
    __FILE__, __LINE__);
    }
  
    // test Y = log(X1) + constant;
    //
    if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting for Y = [log(X1) + 10.0]:\n");
    }
  
    VectorLong values_02(1);
    values_02(0).assign((long)LOG);

    VectorLong values_op_02(1);
    values_op_02(0).assign((long)ASSIGN);

    math6.setNumOperands(1);
    math6.setWeight(L"1.0");
    math6.setOperation(values_op_02);
    math6.setFunction(values_02);
    math6.setConstant(10.0);
    
    input.setLength(1);
    input(0).makeVectorComplexFloat().assign(L"10.0 + 5.0j, 3.0 - 3.0j");

    math6.compute(output, input);

    result.assign(L"12.4142 + 0.4636j, 11.4452 - 0.7854j");

    if (!result.almostEqual(output.getVectorComplexFloat())) {
    output.debug(L"output");
    result.debug(L"result");
    return Error::handle(name(), L"compute", Error::TEST,
    __FILE__, __LINE__);
    }
  */
  
  // test Y = X1 + 2 * X2 - log(X3) - exp(X4)
  //
  if (level_a > Integral::BRIEF) {
    Console::put(L"\n\ttesting for Y = [X1 + 2.0 * X2 - log(X3) - exp(X4)]:\n");
  }
  
  values.setLength(4);
  values(0).assign((long)IDENTITY);
  values(1).assign((long)IDENTITY);
  values(2).assign((long)LOG);
  values(3).assign((long)EXP);

  values_op.setLength(4);
  values_op(0).assign((long)ASSIGN);
  values_op(1).assign((long)ADD);
  values_op(2).assign((long)SUBTRACT);
  values_op(3).assign((long)SUBTRACT);

  math6.setNumOperands(4);
  math6.setWeight(L"1.0, 2.0, 1.0, 1.0");
  math6.setOperation(values_op);
  math6.setFunction(values);
  math6.setConstant(0.0);
  
  input.setLength(4);
  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");