mvector.h

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

// template specialization for Ushort
//
template<> boolean
MVector<Ushort, ushort>::abs() {
  return false ;
}

template<> boolean
MVector<Ushort, ushort>::abs(const MVector<Ushort, ushort>& v1) {
  return false ;
}

template<> boolean
MVector<Ushort, ushort>::neg() {
  return false ;
}

template<> boolean
MVector<Ushort, ushort>::neg(const MVector<Ushort, ushort>& v1) {
  return false ;
}

template<> boolean
MVector<Ushort, ushort>::round() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::ceil() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::cos() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::tan() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::cosh() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::tanh() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::asin() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::asinh() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::acos() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::acosh() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::atan() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::atanh() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::rceil() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::floor() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::rfloor() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::sign() {
  return false ;
}

template<> boolean
MVector<Ushort, ushort>::sign(const MVector<Ushort, ushort>& v1) {
  return false ;
}

template<> boolean
MVector<Ushort, ushort>::sin() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::sinh() {
  return false ;
}

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

template<> boolean
MVector<Ushort, ushort>::centerClip(ushort u1, ushort u2) {
  return false ;
}

template<> boolean
MVector<Ushort, ushort>::centerClip(ushort u1, ushort u2, const MVector<Ushort, ushort>& v1) {
  return false ;
}

// template specialization for Ulong
//
template<> boolean
MVector<Ulong, ulong>::abs() {
  return false ;
}

template<> boolean
MVector<Ulong, ulong>::abs(const MVector<Ulong, ulong>& v1) {
  return false ;
}

template<> boolean
MVector<Ulong, ulong>::neg() {
  return false ;
}

template<> boolean
MVector<Ulong, ulong>::neg(const MVector<Ulong, ulong>& v1) {
  return false ;
}

template<> boolean
MVector<Ulong, ulong>::round() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::ceil() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::rceil() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::floor() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::rfloor() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::sign() {
  return false ;
}

template<> boolean
MVector<Ulong, ulong>::sign(const MVector<Ulong, ulong>& v1) {
  return false ;
}

template<> boolean
MVector<Ulong, ulong>::sin() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::cos() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::tan() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::sinh() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::cosh() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::tanh() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::asin() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::acos() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::atan() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::asinh() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::acosh() {
  return false ;
}

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

template<> boolean
MVector<Ulong, ulong>::atanh() {
  return false ;
}

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

// template specialization for Ullong
//
template<> boolean
MVector<Ullong, ullong>::abs() {
  return false ;
}

template<> boolean
MVector<Ullong, ullong>::abs(const MVector<Ullong, ullong>& v1) {
  return false ;
}

template<> boolean
MVector<Ullong, ullong>::neg() {
  return false ;
}

template<> boolean
MVector<Ullong, ullong>::neg(const MVector<Ullong, ullong>& v1) {
  return false ;
}

template<> boolean
MVector<Ullong, ullong>::round() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::ceil() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::rceil() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::floor() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::rfloor() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::sign() {
  return false ;
}

template<> boolean
MVector<Ullong, ullong>::sign(const MVector<Ullong, ullong>& v1) {
  return false ;
}

template<> boolean
MVector<Ullong, ullong>::sin() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::cos() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::tan() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::sinh() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::cosh() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::tanh() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::asin() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::acos() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::atan() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::asinh() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::acosh() {
  return false ;
}

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

template<> boolean
MVector<Ullong, ullong>::atanh() {
  return false ;
}

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

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

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