mscalar.h

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

  // method: atan
  //
  TIntegral atan() {
    return atan(value_d);
  }

  // method: atan
  //
  TIntegral atan(TIntegral arg) {
    return (value_d = (TIntegral)Integral::atan(arg));
  }

  // method: atanh
  //
  TIntegral atanh() {
    return atanh(value_d);
  }

  // method: atanh
  //
  TIntegral atanh(TIntegral arg) {
    return (value_d = (TIntegral)Integral::atanh(arg));
  }

  // method: ceil
  //
  TIntegral ceil() {
    return ceil(value_d);
  }

  // method: ceil
  //
  template <class TAIntegral>
  TIntegral ceil(TAIntegral arg) {
    return (value_d = (TIntegral)Integral::ceil(arg));
  }

  // method: centerClip
  //
  TIntegral centerClip(TIntegral min, TIntegral max) {
    return MScalarMethods::centerClip(*this, min, max, value_d);
  }

  // method: centerClip
  //
  TIntegral centerClip(TIntegral min, TIntegral max, TIntegral val) {
    return MScalarMethods::centerClip(*this, min, max, val);
  }
  
  // method: cos
  //
  TIntegral cos() {
    return cos(value_d);
  }
  
  // method: cos
  //
  TIntegral cos(TIntegral arg) {
    return (value_d = (TIntegral)Integral::cos(arg));
  }

  // method: cosh
  //
  TIntegral cosh() {
    return cosh(value_d);
  }
  
  // method: cosh
  //
  TIntegral cosh(TIntegral arg) {
    return (value_d = (TIntegral)Integral::cosh(arg));
  }

  // method: exp
  //
  TIntegral exp() {
    return exp(value_d);
  }

  // method: exp
  //
  TIntegral exp(TIntegral arg) {
    return (value_d = presentValue(Integral::exp(arg)));
  }

  // method: exp2
  //
  TIntegral exp2() {
    return exp2(value_d);
  }

  // method: exp2
  //
  TIntegral exp2(TIntegral arg) {
    return (value_d = presentValue(Integral::exp2(arg)));
  }

  // method: exp10
  //
  TIntegral exp10() {
    return exp10(value_d);
  }

  // method: exp10
  //
  TIntegral exp10(TIntegral arg) {
    return (value_d =  presentValue(Integral::exp10(arg)));
  }
  
  // method: factorial
  //
  TIntegral factorial() {
    return factorial(value_d);
  }
  
  // method: factorial
  //
  TIntegral factorial(TIntegral arg) {
    value_d = 1;    
    for (TIntegral count = 2; count <= arg; count++) {
      value_d *= count;
    }
    return value_d;
  }

  // method: floor
  //
  TIntegral floor() {
    return floor(value_d);
  }

  // method: floor
  //
  template <class TAIntegral>
  TIntegral floor(TAIntegral arg) {
    return (value_d = (TIntegral)Integral::floor(arg));
  }

  // method: fraction
  //
  TIntegral fraction() {
    return fraction(value_d);
  }
  
  // method: fraction
  //
  TIntegral fraction(TIntegral arg) {
    return (value_d = (TIntegral)0);
  }
  
  // gaussian random number generation methods
  //
  TIntegral grand(TIntegral mean, TIntegral stddev,
		  Random& generator = Random::GLOBAL_GAUSSIAN);

  // method: hash
  //
  ulong hash(ulong hsize) const {
    return Integral::hash(value_d,  hsize);
  }  
  
  // method: inverse
  //
  TIntegral inverse() {
    return inverse(value_d);
  }
  
  // method: inverse
  //
  TIntegral inverse(TIntegral arg) {
    value_d = 1;
    return (value_d /= arg);
  }

  // method: limit
  //
  TIntegral limit(TIntegral min, TIntegral max) {
    return MScalarMethods::limit(*this, min, max, value_d);
  }
  
  // method: limit
  //
  TIntegral limit(TIntegral min, TIntegral max, TIntegral val) {
    return MScalarMethods::limit(*this, min, max, val);
  }
  
  // method: limitMag
  //
  TIntegral limitMag(TIntegral thresh, TIntegral output) {
    return MScalarMethods::limitMag(*this, thresh, output, value_d);
  }
  
  // method: limitMag
  //
  TIntegral limitMag(TIntegral thresh, TIntegral output, TIntegral val) {
    return MScalarMethods::limitMag(*this, thresh, output, val);
  }

  // method: log
  //
  TIntegral log() {
    return log(value_d);
  }
  
  // method: log
  //
  TIntegral log(TIntegral arg) {
    return (value_d = presentValue(Integral::log(arg)));
  }

  // method: log2
  //
  TIntegral log2() {
    return log2(value_d);
  }

  // method: log2
  //
  TIntegral log2(TIntegral arg) {
    return (value_d = presentValue(Integral::log2(arg)));
  }
  
  // method: log10
  //
  TIntegral log10() {
    return log10(value_d);
  }
  
  // method: log10
  //
  TIntegral log10(TIntegral arg) {
    return (value_d = presentValue(Integral::log10(arg)));
  }
   
  // method: log1p
  //
  TIntegral log1p() {
    return log1p(value_d);
  }
   
  // method: log1p
  //
  TIntegral log1p(TIntegral arg) {
    return (value_d = presentValue(Integral::log1p(arg)));
  }
   
  // method: max
  //
  TIntegral max(TIntegral arg) {
    return max(value_d, arg);
  }
 
  // method: max
  //
  TIntegral max(TIntegral arg_1, TIntegral arg_2) {
    if (arg_1 > arg_2) {
      return (value_d = arg_1);
    }
    return (value_d = arg_2);
  }
  
  // method: min
  //
  TIntegral min(TIntegral arg) {
    return min(value_d, arg);
  }
  
  // method: min
  //
  TIntegral min(TIntegral arg_1, TIntegral arg_2) {
    if (arg_1 > arg_2) {
      return (value_d = arg_2);
    }
    else {
      return (value_d = arg_1);    
    }
  }

  // method: neg
  //
  TIntegral neg() {
    return neg(value_d);
  }
  
  // method: neg
  //
  TIntegral neg(TIntegral arg) {
    return (value_d = -arg);
  }

  // method: pow
  //
  TIntegral pow(TIntegral exponent) {
    return pow(value_d, exponent);
  }
  
  // method: pow
  //
  TIntegral pow(TIntegral arg, TIntegral exponent) {
    return (value_d = presentValue(Integral::pow(arg, exponent)));
  }

  // random number generation methods
  //
  TIntegral rand(Random& generator = Random::GLOBAL_UNIFORM);
  TIntegral rand(TIntegral min, TIntegral max,
		 Random& generator = Random::GLOBAL_UNIFORM);
  
  // method: rceil
  //
  TIntegral rceil() {
    return rceil(value_d);
  }

  // method: rceil
  //
  TIntegral rceil(TIntegral arg) {
    return (value_d = (TIntegral)(Integral::ceil(arg) - arg));
  }

  // method: rfloor
  //
  TIntegral rfloor() {
    return rfloor(value_d);
  }

  // method: rfloor
  //
  TIntegral rfloor(TIntegral arg) {
    return (value_d = (TIntegral)(Integral::floor(arg) - arg));
  }

  // method: round
  //
  TIntegral round() {
    return round(value_d);
  }

  // method: round
  //
  template <class TAIntegral>
  TIntegral round(TAIntegral arg) {
    return (value_d = (TIntegral)Integral::round(arg));
  }

  // method: sign
  //
  TIntegral sign() {
    return sign(value_d);
  }
  
  // method: sign
  //
  TIntegral sign(TIntegral arg) {
    if (arg < (TIntegral)0.0) {
      return (value_d = (TIntegral)Integral::NEGATIVE);
    }
    return (value_d = (TIntegral)Integral::POSITIVE);    
  }
  
  // method: sin
  //
  TIntegral sin() {
    return sin(value_d);
  }

  // method: sin
  //
  TIntegral sin(TIntegral arg) {
    return (value_d = (TIntegral)Integral::sin(arg));
  }

  // method: sinh
  //
  TIntegral sinh() {
    return sinh(value_d);
  }

  // method: sinh
  //
  TIntegral sinh(TIntegral arg) {
    return (value_d = (TIntegral)Integral::sinh(arg));
  }

  // method: sqrt
  //
  TIntegral sqrt() {
    return sqrt(value_d);
  }
   
  // method: sqrt
  //
  TIntegral sqrt(TIntegral arg) {
    return (value_d = presentValue(Integral::sqrt(arg)));
  }

  // method: square
  //
  TIntegral square() {
    return (value_d * value_d);
  }
   
  // method: square
  //
  TIntegral square(TIntegral arg) {
    return (value_d = arg * arg);
  }

  // method: tan
  //
  TIntegral tan() {
    return tan(value_d);
  }

  // method: tan
  //
  TIntegral tan(TIntegral arg) {
    return (value_d = (TIntegral)Integral::tan(arg));
  }

  // method: tanh
  //
  TIntegral tanh() {
    return tanh(value_d);
  }

  // method: tanh
  //
  TIntegral tanh(TIntegral arg) {
    return (value_d = (TIntegral)Integral::tanh(arg));
  }

  //---------------------------------------------------------------------------
  //
  // private methods
  //
  //---------------------------------------------------------------------------
private:
  
  // friend functions:
  //  while friend functions are generally discouraged in the ISIP
  //  environment, they are used in the MScalar class to circumvent the
  //  template delayed compilation problem. 
  //
  friend class MScalarMethods;
};

// the presentValue method is used to construct values for
// mathematical methods which have approximate
// values for integer types and exact values for floating point types
//

template<> double
MScalar<double, float64>::presentValue(double arg) const {
  return (double)arg;
}

template<> float
MScalar<float, float32>::presentValue(double arg) const {
  return (float)arg;
}

template<> complexdouble
MScalar<complexdouble, float64>::presentValue(complexdouble arg) const {
  return (complexdouble)arg;
}

template<> complexfloat
MScalar<complexfloat, float32>::presentValue(complexdouble arg) const {
  return (complexfloat)arg;
}

template<> complexlong
MScalar<complexlong, int32>::presentValue(complexdouble arg) const {
  return (complexlong)Integral::round(arg);
}

// template specializations for mathematical methods which have type-specific
// values. typically, these are methods that have approximate
// values for integer types and exact values for floating point types.
//

template<> double
MScalar<double, float64>::mod(double arg1, double arg2) {
  return arg1;
}

template<> float
MScalar<float, float32>::mod(float arg1, float arg2) {
  return arg1;
}

template<> double
MScalar<double, float64>::operator%(double arg) const {
  return arg;
}

template<> float
MScalar<float, float32>::operator%(float arg) const {
  return arg;
}

template<> MScalar<double, float64>&
MScalar<double, float64>::operator%= (double arg) {
  return *this;
}

template<> MScalar<float, float32>&
MScalar<float, float32>::operator%= (float arg) {
  return *this;
}

template<> double
MScalar<double, float64>::bor(double arg1, double arg2) {
  return arg1;
}

template<> float
MScalar<float, float32>::bor(float arg1, float arg2) {
  return arg1;
}

template<> double
MScalar<double, float64>::band(double arg1, double arg2) {
  return arg1;
}

template<> float
MScalar<float, float32>::band(float arg1, float arg2) {
  return arg1;
}

template<> double
MScalar<double, float64>::bxor(double arg1, double arg2) {
  return arg1;
}

template<> float
MScalar<float, float32>::bxor(float arg1, float arg2) {
  return arg1;
}

template<> double
MScalar<double, float64>::brs(double arg1, double arg2) {
  return arg1;
}

template<> float
MScalar<float, float32>::brs(float arg1, float arg2) {
  return arg1;
}

template<> double
MScalar<double, float64>::bls(double arg1, double arg2) {
  return arg1;
}

template<> float
MScalar<float, float32>::bls(float arg1, float arg2) {
  return arg1;
}

template<> double
MScalar<double, float64>::bcmpl(double arg) {
  return arg;
}

template<> float
MScalar<float, float32>::bcmpl(float arg1) {
  return arg1;
}

template<> double
MScalar<double, float64>::fraction(double arg) {
  return (value_d = Integral::fraction(arg)); 
}

template<> float
MScalar<float, float32>::fraction(float arg) {
  return (value_d = Integral::fraction(arg)); 
}

template<> byte
MScalar<byte, byte8>::neg(byte arg) {
  Error::handle(name(), L"neg", Error::TEST, __FILE__, __LINE__);
  return (byte)0; 
}

template<> ulong
MScalar<ulong, uint32>::neg(ulong arg) {
    Error::handle(name(), L"neg", Error::TEST, __FILE__, __LINE__);
    return (ulong)0; 
}

template<> ullong
MScalar<ullong, uint64>::neg(ullong arg) {
   Error::handle(name(), L"neg", Error::TEST, __FILE__, __LINE__);
   return (ullong)0; 
}

template<> ushort
MScalar<ushort, uint16>::neg(ushort arg) {
   Error::handle(name(), L"neg", Error::TEST, __FILE__, __LINE__);
   return (ushort)0;
 }

template<> byte
MScalar<byte, byte8>::abs(byte arg) {
  Error::handle(name(), L"abs", Error::TEST, __FILE__, __LINE__);
  return (byte)0;
 }

template<> ulong
MScalar<ulong, uint32>::abs(ulong arg) {
  Error::handle(name(), L"abs", Error::TEST, __FILE__, __LINE__);
  return (ulong)0;
 }

template<> ullong
MScalar<ullong, uint64>::abs(ullong arg) {
  Error::handle(name(), L"abs", Error::TEST, __FILE__, __LINE__);
  return (ullong)0; 
}

template<> ushort
MScalar<ushort, uint16>::abs(ushort arg) {
  Error::handle(name(), L"abs", Error::TEST, __FILE__, __LINE__);
  return (ushort)0; 
}

template<> byte
MScalar<byte, byte8>::sign(byte arg) {
    Error::handle(name(), L"sign", Error::TEST, __FILE__, __LINE__);
    return (byte)0;
}

template<> ulong
MScalar<ulong, uint32>::sign(ulong arg) {
  Error::handle(name(), L"sign", Error::TEST, __FILE__, __LINE__);
  return (ulong)0;
}

template<> ullong
MScalar<ullong, uint64>::sign(ullong arg) {
  Error::handle(name(), L"sign", Error::TEST, __FILE__, __LINE__);
  return (ullong)0;
}

template<> ushort
MScalar<ushort, uint16>::sign(ushort arg) {
  Error::handle(name(), L"sign", Error::TEST, __FILE__, __LINE__);
  return (ushort)0;
}

template<> byte
MScalar<byte, byte8>::acos(byte arg) {
  Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
  return (byte)0;
}

template<> ullong
MScalar<ullong, uint64>::acos(ullong arg) {
  Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
  return (ullong)0;
}

template<> ulong
MScalar<ulong, uint32>::acos(ulong arg) {
  Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
  return (ulong)0;
}

template<> ushort
MScalar<ushort, uint16>::acos(ushort arg) {
  Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
  return (ushort)0;
}

template<> llong
MScalar<llong, int64>::acos(llong arg) {
  Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
  return (llong)0;
}

template<> long
MScalar<long, int32>::acos(long arg) {
  Error::handle(name(), L"acos", Error::TEST, __FILE__, __LINE__);
  return (long)0;