math_09.cc

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

      }
      if (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {
	output_a.makeVectorComplexFloat().assign(tmp_input.getVectorComplexFloat());
      }
      else {
	output_a.makeMatrixComplexFloat().assign(tmp_input.getMatrixComplexFloat());
      }
    }
    
    //  Operation: ADD
    //
    else if (operation_d(j) == (long)ADD) {
      
      computeAddCFloat(output_a, tmp_input);
    }

    //  Operation: SUBTRACT
    //
    else if (operation_d(j) == (long)SUBTRACT) {
      
      computeSubCFloat(output_a, tmp_input);
    }

    //  Operation: MULTIPLY
    //
    else if (operation_d(j) == (long)MULTIPLY) {

      computeMultCFloat(output_a, tmp_input);
    }
    
    //  Operation: DIVIDE
    //
    else if (operation_d(j) == (long)DIVIDE) {
      
      computeDivCFloat(output_a, tmp_input);
    }
    
    // invalid operation
    //
    else {
      return Error::handle(name(), L"computeFuncCalcEnumerateCFloat",
			   ERR_UNKOPE, __FILE__, __LINE__);
    }
  }

  // add the constant term
  //
  if (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {
    output_a.getVectorComplexFloat().add((complexfloat)const_d);
  }
  else {
    output_a.getMatrixComplexFloat().add((complexfloat)const_d);
  }
  
  // exit gracefully
  //
  return true;
}

// method: computeAddCFloat
//
// arguments:
//  AlgorithmData& output: (input/output) 1st operand and output
//  const AlgorithmData& input: (input) 2nd operand
//
// return: logical error status
//
boolean Math::computeAddCFloat(AlgorithmData& output_a,
			       const AlgorithmData& input_a) const {
  
  if (input_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {
    
    long ilen = input_a.getVectorComplexFloat().length();

    if (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {

      long olen = output_a.getVectorComplexFloat().length();
      
      // if either input is of length 1, perform scalar addition
      //
      if (ilen == 1) {
	complexfloat scalar = input_a.getVectorComplexFloat()(0);
	return output_a.getVectorComplexFloat().add(scalar);
      }
      else if (olen == 1) {
	complexfloat scalar = output_a.getVectorComplexFloat()(0);
	return output_a.getVectorComplexFloat().add(input_a.getVectorComplexFloat(), scalar);
      }
      
      // if they are the same length, do vector addition
      //
      else if (ilen == olen) {
	return output_a.getVectorComplexFloat().add(input_a.getVectorComplexFloat());
      }

      // else error
      //
      else {
	return Error::handle(name(), L"computeAddCFloat", ERR_MATCH,
			     __FILE__, __LINE__);
      }
    }

    // 1 vector, 1 matrix. if the vector is of length 1, treat it as a
    // scalar
    //
    else if (output_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {

      if (ilen == 1) {
	complexfloat scalar = input_a.getVectorComplexFloat()(0);
	return output_a.getMatrixComplexFloat().add(scalar);
      }
      else {
	return Error::handle(name(), L"computeAddCFloat", ERR_MATCH,
			     __FILE__, __LINE__);
      }
    }
  }

  else if (input_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {

    // 1 vector, 1 matrix. if the vector is of length 1, treat it as a
    // scalar
    //
    if (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {
      long olen = output_a.getVectorComplexFloat().length();
      if (olen == 1) {
	complexfloat scalar = output_a.getVectorComplexFloat()(0);
	return output_a.makeMatrixComplexFloat().add(input_a.getMatrixComplexFloat(), scalar);
      }
      else {
	return Error::handle(name(), L"computeAddCFloat", ERR_MATCH, __FILE__,
			     __LINE__);
      }
    }

    // if both are matrices, just add them
    //
    else if (output_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {
      return output_a.getMatrixComplexFloat().add(input_a.getMatrixComplexFloat());
    }
  }

  // exit gracefully
  //
  return true;
}


// method: computeSubCFloat
//
// arguments:
//  AlgorithmData& output: (input/output) 1st operand and output
//  const AlgorithmData& input: (input) 2nd operand
//
// return: logical error status
//
boolean Math::computeSubCFloat(AlgorithmData& output_a,
			       const AlgorithmData& input_a) const {
  
  if (input_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {
    
    long ilen = input_a.getVectorComplexFloat().length();

    if (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {

      long olen = output_a.getVectorComplexFloat().length();
      
      // if either input is of length 1, perform scalar subtraction
      //
      if (ilen == 1) {
	complexfloat scalar = input_a.getVectorComplexFloat()(0);
	return output_a.getVectorComplexFloat().sub(scalar);
      }
      else if (olen == 1) {

	// note this is different from addition since the operation is
	// not cummative
	//
	complexfloat scalar = output_a.getVectorComplexFloat()(0);
	output_a.getVectorComplexFloat().setLength(ilen);
	output_a.getVectorComplexFloat().assign(scalar);
	return output_a.getVectorComplexFloat().sub(input_a.getVectorComplexFloat());
      }
      
      // if they are the same length, do vector subtraction
      //
      else if (ilen == olen) {
	return output_a.getVectorComplexFloat().sub(input_a.getVectorComplexFloat());
      }

      // else error
      //
      else {
	return Error::handle(name(), L"computeSubCFloat", ERR_MATCH,
			     __FILE__, __LINE__);
      }
    }

    // 1 vector, 1 matrix. if the vector is of length 1, treat it as a
    // scalar
    //
    else if (output_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {

      if (ilen == 1) {
	complexfloat scalar = input_a.getVectorComplexFloat()(0);
	return output_a.getMatrixComplexFloat().sub(scalar);
      }
      else {
	return Error::handle(name(), L"computeSubCFloat", ERR_MATCH,
			     __FILE__, __LINE__);
      }
    }
  }

  else if (input_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {

    // 1 vector, 1 matrix. if the vector is of length 1, treat it as a
    // scalar
    //
    if (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {
      long olen = output_a.getVectorComplexFloat().length();
      if (olen == 1) {

	// note this is different from addition since the operation is
	// not cummative
	//
	complexfloat scalar = output_a.getVectorComplexFloat()(0);
	output_a.makeMatrixComplexFloat().setDimensions(input_a.getMatrixComplexFloat());
	output_a.getMatrixComplexFloat().assign(scalar);
	return output_a.getMatrixComplexFloat().sub(input_a.getMatrixComplexFloat());
      }
      else {
	return Error::handle(name(), L"computeSubCFloat", ERR_MATCH, __FILE__,
			     __LINE__);
      }
    }

    // if both are matrices, just subtract them
    //
    else if (output_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {
      return output_a.getMatrixComplexFloat().sub(input_a.getMatrixComplexFloat());
    }
  }

  // exit gracefully
  //
  return true;
}

// method: computeMultCFloat
//
// arguments:
//  AlgorithmData& output: (input/output) 1st operand and output
//  const AlgorithmData& input: (input) 2nd operand
//
// return: logical error status
//
boolean Math::computeMultCFloat(AlgorithmData& output_a,
				const AlgorithmData& input_a) const {
  
  if (input_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {
    
    long ilen = input_a.getVectorComplexFloat().length();

    if (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {

      long olen = output_a.getVectorComplexFloat().length();

      // if either input is of length 1, perform scalar multiplication
      //
      if (ilen == 1) {
	complexfloat scalar = input_a.getVectorComplexFloat()(0);
	return output_a.getVectorComplexFloat().mult(scalar);
      }
      else if (olen == 1) {

	complexfloat scalar = output_a.getVectorComplexFloat()(0);
	return output_a.getVectorComplexFloat().mult(input_a.getVectorComplexFloat(), scalar);
      }
      
      // if they are the same length, do vector multiplication
      //
      else if (ilen == olen) {
	return output_a.getVectorComplexFloat().mult(input_a.getVectorComplexFloat());
      }

      // else error
      //
      else {
	return Error::handle(name(), L"computeMultCFloat", ERR_MATCH,
			     __FILE__, __LINE__);
      }
    }
    else if (output_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {

      // if the vector is length 1, do scalar multiplication
      //
      if (ilen == 1) {
	complexfloat scalar = input_a.getVectorComplexFloat()(0);
	return output_a.getMatrixComplexFloat().mult(scalar);
      }

      // if the vector is the correct length for multv, do it
      //
      else if (ilen == output_a.getMatrixComplexFloat().getNumColumns()) {
	VectorComplexFloat tmp_out;
	output_a.getMatrixComplexFloat().multv(tmp_out, input_a.getVectorComplexFloat());
	output_a.makeVectorComplexFloat().assign(tmp_out);
      }

      // else error
      //
      else {
	return Error::handle(name(), L"computeMultCFloat", ERR_MATCH,
			     __FILE__, __LINE__);
      }
    }
  }

  // input is a matrix
  //
  else if (input_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {

    if (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) {

      long olen = output_a.getVectorComplexFloat().length();

      // if the vector is of length 1, do scalar multiplication
      //
      if (olen == 1) {
	complexfloat scalar = output_a.getVectorComplexFloat()(0);
	output_a.makeMatrixComplexFloat().assign(input_a.getMatrixComplexFloat());
	return output_a.getMatrixComplexFloat().mult(scalar);
      }

      // if the vector is the correct length for vmult, do it
      //
      else if (olen == input_a.getMatrixComplexFloat().getNumRows()) {

	VectorComplexFloat tmp_out;
	input_a.getMatrixComplexFloat().vmult(tmp_out, output_a.getVectorComplexFloat());
	output_a.getVectorComplexFloat().assign(tmp_out);
      }
	
      // else error
      //
      else {
	return Error::handle(name(), L"computeMultCFloat", ERR_MATCH,
			     __FILE__, __LINE__);
      }
    }
    else if (output_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT) {

      return output_a.getMatrixComplexFloat().mult(input_a.getMatrixComplexFloat());
    }
  }

  // exit gracefully
  //
  return true;
}

// method: computeDivCFloat
//
// arguments:
//  AlgorithmData& output: (input/output) 1st operand and output
//  const AlgorithmData& input: (input) 2nd operand
//
// return: logical error status
//
boolean Math::computeDivCFloat(AlgorithmData& output_a,
			       const AlgorithmData& input_a) const {  
  
  // vector-matrix division is possible only if length of the
  // vector is 1. no other matrix division is possible
  //
  if ((input_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) &&
      (output_a.getDataType() == AlgorithmData::MATRIX_COMPLEX_FLOAT)) {      

    if (input_a.getVectorComplexFloat().length() > 1) {
      return Error::handle(name(), L"computeDivCFloat",
			   ERR_MATCH, __FILE__, __LINE__);
    }
    VectorComplexFloat vec(input_a.getVectorComplexFloat());
    complexfloat scalar = vec(0);
    output_a.getMatrixComplexFloat().div(scalar);
  }

  // both inputs are vectors
  //
  else if ((input_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT) &&
	   (output_a.getDataType() == AlgorithmData::VECTOR_COMPLEX_FLOAT)) {

    // if the input is of length 1, do scalar division
    //
    if (input_a.getVectorComplexFloat().length() == 1) {
      complexfloat scalar = input_a.getVectorComplexFloat()(0);

      return output_a.getVectorComplexFloat().div(scalar);
    }

    // if the lengths are equal, do element-wise division
    //
    else if (input_a.getVectorComplexFloat().length() == output_a.getVectorComplexFloat().length()) {

      return output_a.getVectorComplexFloat().div(input_a.getVectorComplexFloat());

    } 
    else {
      return Error::handle(name(), L"computeDivCFloat", ERR_MATCH,
			   __FILE__, __LINE__);
    }
  }
  else {
    return Error::handle(name(), L"computeDivCFloat", ERR_MATCH, __FILE__, __LINE__);
  }
  
  // exit gracefully
  //
  return true;
}