mvector.h

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

}

template<> boolean
MVector<Short, short>::ceil() {
  return false ;
}

template<> boolean
MVector<Short, short>::ceil(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::rceil() {
  return false ;
}

template<> boolean
MVector<Short, short>::rceil(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::floor() {
  return false ;
}

template<> boolean
MVector<Short, short>::floor(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::rfloor() {
  return false ;
}

template<> boolean
MVector<Short, short>::rfloor(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::sin() {
  return false ;
}

template<> boolean
MVector<Short, short>::sin(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::cos() {
  return false ;
}

template<> boolean
MVector<Short, short>::cos(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::tan() {
  return false ;
}

template<> boolean
MVector<Short, short>::tan(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::sinh() {
  return false ;
}

template<> boolean
MVector<Short, short>::sinh(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::cosh() {
  return false ;
}

template<> boolean
MVector<Short, short>::cosh(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::tanh() {
  return false ;
}

template<> boolean
MVector<Short, short>::tanh(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::asin() {
  return false ;
}

template<> boolean
MVector<Short, short>::asin(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::acos() {
  return false ;
}

template<> boolean
MVector<Short, short>::acos(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::atan() {
  return false ;
}

template<> boolean
MVector<Short, short>::atan(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::asinh() {
  return false ;
}

template<> boolean
MVector<Short, short>::asinh(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::acosh() {
  return false ;
}

template<> boolean
MVector<Short, short>::acosh(const MVector<Short, short>& v1) {
  return false ;
}

template<> boolean
MVector<Short, short>::atanh() {
  return false ;
}

template<> boolean
MVector<Short, short>::atanh(const MVector<Short, short>& v1) {
  return false ;
}

// template specialization for Long
//
template<> boolean
MVector<Long, long>::round() {
  return false ;
}

template<> boolean
MVector<Long, long>::round(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::ceil() {
  return false ;
}

template<> boolean
MVector<Long, long>::ceil(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::rceil() {
  return false ;
}

template<> boolean
MVector<Long, long>::rceil(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::floor() {
  return false ;
}

template<> boolean
MVector<Long, long>::floor(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::rfloor() {
  return false ;
}

template<> boolean
MVector<Long, long>::rfloor(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::sin() {
  return false ;
}

template<> boolean
MVector<Long, long>::sin(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::cos() {
  return false ;
}

template<> boolean
MVector<Long, long>::cos(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::tan() {
  return false ;
}

template<> boolean
MVector<Long, long>::tan(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::sinh() {
  return false ;
}

template<> boolean
MVector<Long, long>::sinh(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::cosh() {
  return false ;
}

template<> boolean
MVector<Long, long>::cosh(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::tanh() {
  return false ;
}

template<> boolean
MVector<Long, long>::tanh(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::asin() {
  return false ;
}

template<> boolean
MVector<Long, long>::asin(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::acos() {
  return false ;
}

template<> boolean
MVector<Long, long>::acos(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::atan() {
  return false ;
}

template<> boolean
MVector<Long, long>::atan(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::asinh() {
  return false ;
}

template<> boolean
MVector<Long, long>::asinh(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::acosh() {
  return false ;
}

template<> boolean
MVector<Long, long>::acosh(const MVector<Long, long>& v1) {
  return false ;
}

template<> boolean
MVector<Long, long>::atanh() {
  return false ;
}

template<> boolean
MVector<Long, long>::atanh(const MVector<Long, long>& v1) {
  return false ;
}

// template specialization for Llong
//

template<> boolean
MVector<Llong, llong>::round() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::round(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::ceil() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::ceil(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::rceil() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::rceil(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::floor() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::floor(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::rfloor() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::rfloor(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::sin() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::sin(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::cos() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::cos(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::tan() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::tan(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::sinh() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::sinh(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::cosh() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::cosh(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::tanh() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::tanh(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::asin() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::asin(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::acos() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::acos(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::atan() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::atan(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::asinh() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::asinh(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::acosh() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::acosh(const MVector<Llong, llong>& v1) {
  return false ;
}

template<> boolean
MVector<Llong, llong>::atanh() {
  return false ;
}

template<> boolean
MVector<Llong, llong>::atanh(const MVector<Llong, llong>& v1) {
  return false ;
}

// template specialization for Float
//
template<> boolean
MVector<Float, float>::band(const MVector<Float, float>& v1) {
  return false;
}

template<> boolean
MVector<Float, float>::band(const MVector<Float, float>& v1,
			    const MVector<Float, float>& v2) {
  return false;
}

template<> boolean
MVector<Float, float>::band(float value) {
  return false;
}

template<> boolean
MVector<Float, float>::band(const MVector& v1, float value) {
  return false;
}

template<> boolean
MVector<Float, float>::bor(const MVector& v2) {
  return false;
}

template<> boolean
MVector<Float, float>::bor(const MVector& v1, const MVector& v2) {
  return false;
}

template<> boolean
MVector<Float, float>::bor(float value) {
  return false;
}

template<> boolean
MVector<Float, float>::bor(const MVector& v1, float value) {
  return false;
}

template<> boolean
MVector<Float, float>::bxor(const MVector& v2) {
  return false;
}

template<> boolean
MVector<Float, float>::bxor(const MVector& v1, const MVector& v2) {
  return false;
}

template<> boolean
MVector<Float, float>::bxor(float value) {
  return false;
}

template<> boolean
MVector<Float, float>::bxor(const MVector& v1, float value) {
  return false;
}

template<> boolean
MVector<Float, float>::brs(float shift_amount) {
  return false;
}

template<> boolean
MVector<Float, float>::brs(const MVector& v1, float shift_amount) {
  return false;
}

template<> boolean
MVector<Float, float>::bls(float shift_amount) {
  return false;
}

template<> boolean
MVector<Float, float>::bls(const MVector& v1, float shift_amount) {
  return false;
}

template<> boolean
MVector<Float, float>::bcmpl(const MVector& v1) {
  return false;
}

template<> boolean
MVector<Float, float>::bcmpl() {
  return false;
}

template<> boolean
MVector<Float, float>::mod(const MVector& vector) {
  return false;
  
}
template<> boolean
MVector<Float, float>::mod(const MVector& v1, const MVector& v2) {
  return false;
}

template<> boolean
MVector<Float, float>::mod(float value) {
  return false;
}

template<> boolean
MVector<Float, float>::mod(const MVector& vector, float value) {
  return false;
}

// template specialization for Double
//
template<> boolean
MVector<Double, double>::band(const MVector<Double, d