mscalar.h

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

}

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

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

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

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

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

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

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

template<> short
MScalar<short, int16>::acosh(short arg) {
  Error::handle(name(), L"acosh", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}

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

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

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

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

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

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

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

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

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

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

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

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

template<> short
MScalar<short, int16>::asinh(short arg) {
  Error::handle(name(), L"asinh", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}

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

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

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

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

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

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

template<> short
MScalar<short, int16>::atan(short arg) {
  Error::handle(name(), L"atan", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}

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

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

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

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

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

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

template<> short
MScalar<short, int16>::atanh(short arg) {
  Error::handle(name(), L"atanh", Error::TEST, __FILE__, __LINE__);
  return (short)0; 
}

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

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

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

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

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

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

template<> short
MScalar<short, int16>::cos(short arg) {
  Error::handle(name(), L"cos", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}

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

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

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

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

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

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

template<> short
MScalar<short, int16>::cosh(short arg) {
  Error::handle(name(), L"cosh", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}
/*
template<> byte
MScalar<byte, byte8>::floor(byte arg) {
  Error::handle(name(), L"floor", Error::TEST, __FILE__, __LINE__);
  return (byte)0;
}

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

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

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

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

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

template<> short
MScalar<short, int16>::floor(short arg) {
  Error::handle(name(), L"floor", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}
*/
template<> byte
MScalar<byte, byte8>::sin(byte arg) {
  Error::handle(name(), L"sin", Error::TEST, __FILE__, __LINE__);
  return (byte)0;
}

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

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

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

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

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

template<> short
MScalar<short, int16>::sin(short arg) {
  Error::handle(name(), L"sin", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}

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

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

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

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

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

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

template<> short
MScalar<short, int16>::sinh(short arg) {
  Error::handle(name(), L"sinh", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}

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

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

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

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

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

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


template<> short
MScalar<short, int16>::tan(short arg) {
  Error::handle(name(), L"tan", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}

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

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

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

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

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

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

template<> short
MScalar<short, int16>::tanh(short arg) {
  Error::handle(name(), L"tanh", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}
/*
template<> byte
MScalar<byte, byte8>::ceil(byte arg) {
  Error::handle(name(), L"ceil", Error::TEST, __FILE__, __LINE__);
  return (byte)0;
}

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

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

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

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

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

template<> short
MScalar<short, int16>::ceil(short arg) {
  Error::handle(name(), L"ceil", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}
*/
template<> byte
MScalar<byte, byte8>::rceil(byte arg) {
  Error::handle(name(), L"rceil", Error::TEST, __FILE__, __LINE__);
  return (byte)0;
}

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

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

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

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

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

template<> short
MScalar<short, int16>::rceil(short arg) {
  Error::handle(name(), L"rceil", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}

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

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

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

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

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

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


template<> short
MScalar<short, int16>::rfloor(short arg) {
  Error::handle(name(), L"rfloor", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}
/*
template<> byte
MScalar<byte, byte8>::round(byte arg) {
  Error::handle(name(), L"round", Error::TEST, __FILE__, __LINE__);
  return (byte)0;
}

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

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

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

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

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


template<> short
MScalar<short, int16>::round(short arg) {
  Error::handle(name(), L"round", Error::TEST, __FILE__, __LINE__);
  return (short)0;
}
*/
  
// end of include file
//
#endif