algorithmdata.h

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

  //
  boolean setDataType(DATA_TYPE dtype);

  // method: setCoefType
  //
  boolean setCoefType(COEF_TYPE ctype) {
    coef_type_d = ctype;
    return true;
  }
  
  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  get methods
  //
  //---------------------------------------------------------------------------
  
  // method: getDataType
  //
  DATA_TYPE getDataType() const {
    return data_type_d;
  }

  // method: getCoefType
  //
  COEF_TYPE getCoefType() const {
    return coef_type_d;
  }

  // method: getVectorFloat
  //
  const VectorFloat& getVectorFloat() const {
    if (data_type_d != VECTOR_FLOAT) {
      Error::handle(name(), L"getVectorFloat", ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < VectorFloat* > (data_d));
  }

  // method: getVectorFloat
  //
  VectorFloat& getVectorFloat() {
    if (data_type_d != VECTOR_FLOAT) {
      Error::handle(name(), L"getVectorFloat", ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < VectorFloat* > (data_d));
  }

  // method: getVectorComplexFloat
  //
  const VectorComplexFloat& getVectorComplexFloat() const {
    if (data_type_d != VECTOR_COMPLEX_FLOAT) {
      Error::handle(name(), L"getVectorComplexFloat", ERR_TYPE,
		    __FILE__, __LINE__);
    }
    return *(reinterpret_cast < VectorComplexFloat* > (data_d));
  }

  // method: getVectorComplexFloat
  //
  VectorComplexFloat& getVectorComplexFloat() {
    if (data_type_d != VECTOR_COMPLEX_FLOAT) {
      Error::handle(name(), L"getVectorComplexFloat",
		    ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < VectorComplexFloat* > (data_d));
  }

  // method: getMatrixFloat
  //
  const MatrixFloat& getMatrixFloat() const {
    if (data_type_d != MATRIX_FLOAT) {
      Error::handle(name(), L"getMatrixFloat", ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < MatrixFloat* > (data_d));
  }

  // method: getMatrixFloat
  //
  MatrixFloat& getMatrixFloat() {
    if (data_type_d != MATRIX_FLOAT) {
      Error::handle(name(), L"getMatrixFloat", ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < MatrixFloat* > (data_d));
  }

  // method: getMatrixComplexFloat
  //
  
  const MatrixComplexFloat& getMatrixComplexFloat() const {
    if (data_type_d != MATRIX_COMPLEX_FLOAT) {
      Error::handle(name(), L"getMatrixComplexFloat",
		    ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < MatrixComplexFloat* > (data_d));
  }

  // method: getMatrixComplexFloat
  //
  MatrixComplexFloat& getMatrixComplexFloat() {
    if (data_type_d != MATRIX_COMPLEX_FLOAT) {
      Error::handle(name(), L"getMatrixComplexFloat",
		    ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < MatrixComplexFloat* > (data_d));
  }

  // method: getVectorDouble
  //
  const VectorDouble& getVectorDouble() const {
    if (data_type_d != VECTOR_DOUBLE) {
      Error::handle(name(), L"getVectorDouble", ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < VectorDouble* > (data_d));
  }

  // method: getVectorDouble
  //
  VectorDouble& getVectorDouble() {
    if (data_type_d != VECTOR_DOUBLE) {
      Error::handle(name(), L"getVectorDouble", ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < VectorDouble* > (data_d));
  }

  // method: getVectorComplexDouble
  //
  const VectorComplexDouble& getVectorComplexDouble() const {
    if (data_type_d != VECTOR_COMPLEX_DOUBLE) {
      Error::handle(name(), L"getVectorComplexDouble", ERR_TYPE,
		    __FILE__, __LINE__);
    }
    return *(reinterpret_cast < VectorComplexDouble* > (data_d));
  }

  // method: getVectorComplexDouble
  //
  VectorComplexDouble& getVectorComplexDouble() {
    if (data_type_d != VECTOR_COMPLEX_DOUBLE) {
      Error::handle(name(), L"getVectorComplexDouble",
		    ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < VectorComplexDouble* > (data_d));
  }

  // method: getMatrixDouble
  //
  const MatrixDouble& getMatrixDouble() const {
    if (data_type_d != MATRIX_DOUBLE) {
      Error::handle(name(), L"getMatrixDouble", ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < MatrixDouble* > (data_d));
  }

  // method: getMatrixDouble
  //
  MatrixDouble& getMatrixDouble() {
    if (data_type_d != MATRIX_DOUBLE) {
      Error::handle(name(), L"getMatrixDouble", ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < MatrixDouble* > (data_d));
  }

  // method: getMatrixComplexDouble
  //
  const MatrixComplexDouble& getMatrixComplexDouble() const {
    if (data_type_d != MATRIX_COMPLEX_DOUBLE) {
      Error::handle(name(), L"getMatrixComplexDouble",
		    ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < MatrixComplexDouble* > (data_d));
  }

  // method: getMatrixComplexDouble
  //
  MatrixComplexDouble& getMatrixComplexDouble() {
    if (data_type_d != MATRIX_COMPLEX_DOUBLE) {
      Error::handle(name(), L"getMatrixComplexDouble",
		    ERR_TYPE, __FILE__, __LINE__);
    }
    return *(reinterpret_cast < MatrixComplexDouble* > (data_d));
  }

  // method: getCombination
  //
  const Vector<AlgorithmData>& getCombination() const {
    if (data_type_d != COMBINATION) {
      Error::handle(name(), L"getCombination", ERR_TYPE,
		    __FILE__, __LINE__);
    }
    return *(reinterpret_cast< Vector < AlgorithmData >* > (data_d));
  }
  
  // method: getCombination
  //
  Vector<AlgorithmData>& getCombination() {
    if (data_type_d != COMBINATION) {
      Error::handle(name(), L"getCombination", ERR_TYPE,
		    __FILE__, __LINE__);
    }
    return *(reinterpret_cast < Vector < AlgorithmData >* > (data_d));
  }
  
  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  make methods
  //
  //---------------------------------------------------------------------------
  
  // method: make
  //
  boolean make(const AlgorithmData& arg) {
    return (assign(arg) && clear(Integral::RETAIN));
  }

  // method: makeVectorFloat
  //
  VectorFloat& makeVectorFloat() {
    setDataType(VECTOR_FLOAT);
    return *(reinterpret_cast < VectorFloat* > (data_d));
  }
  
  // method: makeVectorComplexFloat
  //
  VectorComplexFloat& makeVectorComplexFloat() {
    setDataType(VECTOR_COMPLEX_FLOAT);
    return *(reinterpret_cast < VectorComplexFloat* > (data_d));
  }
  
  // method: makeMatrixFloat
  //
  MatrixFloat& makeMatrixFloat() {
    setDataType(MATRIX_FLOAT);
    return *(reinterpret_cast < MatrixFloat* > (data_d));
  }

  // method: makeMatrixComplexFloat
  //
  
  MatrixComplexFloat& makeMatrixComplexFloat() {
    setDataType(MATRIX_COMPLEX_FLOAT);
    return *(reinterpret_cast < MatrixComplexFloat* > (data_d));
  }

  // method: makeVectorDouble
  //
  VectorDouble& makeVectorDouble() {
    setDataType(VECTOR_DOUBLE);
    return *(reinterpret_cast < VectorDouble* > (data_d));
  }
  
  // method: makeVectorComplexDouble
  //
  VectorComplexDouble& makeVectorComplexDouble() {
    setDataType(VECTOR_COMPLEX_DOUBLE);
    return *(reinterpret_cast < VectorComplexDouble* > (data_d));
  }
  
  // method: makeMatrixDouble
  //
  MatrixDouble& makeMatrixDouble() {
    setDataType(MATRIX_DOUBLE);
    return *(reinterpret_cast < MatrixDouble* > (data_d));
  }

  // method: makeMatrixComplexDouble
  //
  MatrixComplexDouble& makeMatrixComplexDouble() {
    setDataType(MATRIX_COMPLEX_DOUBLE);
    return *(reinterpret_cast < MatrixComplexDouble* > (data_d));
  }
  
  // method: makeCombination
  //
  Vector<AlgorithmData>& makeCombination() {
    setDataType(COMBINATION);
    return *(reinterpret_cast < Vector < AlgorithmData >* > (data_d));
  }

  //---------------------------------------------------------------------------
  //
  // class-specific public methods:
  //  swap methods
  //
  //---------------------------------------------------------------------------

  // method to swap out the data in one object to another
  //
  boolean swap(AlgorithmData& arg);
  
  //---------------------------------------------------------------------------
  //
  // this class does not need an interface contract
  //
  //---------------------------------------------------------------------------

  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:
};

// end of include file
// 
#endif