//
//
//   File: altmath.cpp     Created 12-MAY-2007        Richard B. Johnson
//                                                  RichardBJohnson@comcast.net
//
//   The data, text, and source-code within these files are presumed to
//   be accurate and free of encumbrances. Use at your own risk.
//

#define UNROLL
#include <stdio.h>
#include <math.h>
#include <string.h>
#include "altmath.h"
#ifdef DEBUG
#define DEB(f) f
#else
#define DEB(f)
#endif


SIG sig;

/*
 *  Note, in Intel machines, all floating point values are in
 *  memory (80 bits). We save a place for the most common ones.
 */
const double SIG::one  = 1.0;
const double SIG::two  = 2.0;
const double SIG::turn = 360.0;


#if !defined(_hypot)
double _hypot(double x, double y)
{
    return sqrt((x * x) + (y * y));
}
#endif
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created FEB-11-2003               Richard B. Johnson
//
//   Filter the input data (box-car) and return the filtered data
//   in the same buffer.
//
void SIG::filter(double *buf, int box, int len)
{
    double *dp, *sp, f;
    int i, j;

    if((dp = new double [len]) == NULL)
        return;

    sp = dp;
    for(i = 0; i< (len-box); i++)
    {
        f = 0.0;
        for(j=0; j < box; j++)
            f += buf[i+j];
        f /= (double) box;
        *sp++ = f;
    }
    memcpy(buf, dp, len);
    delete[] dp;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//    Created FEB-11-2003               Richard B. Johnson
//
//    This returns the phase between the two real/imaginary channels
//    in the output channel. Channel a = real, b = imaginary.
//    The return value is in degrees.
//

#define DO_PHASE(i) out[i] = atan2(b[i], a[i]) * deg

void SIG::get_phase(double *out, double *a, double *b, int len)
{
    double deg = turn / (two * PI);
#ifdef UNROLL
    while(len >= 0x100)
    {
        len -= 0x100;
        out += 0x100;
        a   += 0x100;
        b   += 0x100;
ALIGN;
        DO_PHASE(-0x100);
        DO_PHASE(-0x0ff);
        DO_PHASE(-0x0fe);
        DO_PHASE(-0x0fd);
        DO_PHASE(-0x0fc);
        DO_PHASE(-0x0fb);
        DO_PHASE(-0x0fa);
        DO_PHASE(-0x0f9);
        DO_PHASE(-0x0f8);
        DO_PHASE(-0x0f7);
        DO_PHASE(-0x0f6);
        DO_PHASE(-0x0f5);
        DO_PHASE(-0x0f4);
        DO_PHASE(-0x0f3);
        DO_PHASE(-0x0f2);
        DO_PHASE(-0x0f1);
        DO_PHASE(-0x0f0);
        DO_PHASE(-0x0ef);
        DO_PHASE(-0x0ee);
        DO_PHASE(-0x0ed);
        DO_PHASE(-0x0ec);
        DO_PHASE(-0x0eb);
        DO_PHASE(-0x0ea);
        DO_PHASE(-0x0e9);
        DO_PHASE(-0x0e8);
        DO_PHASE(-0x0e7);
        DO_PHASE(-0x0e6);
        DO_PHASE(-0x0e5);
        DO_PHASE(-0x0e4);
        DO_PHASE(-0x0e3);
        DO_PHASE(-0x0e2);
        DO_PHASE(-0x0e1);
        DO_PHASE(-0x0e0);
        DO_PHASE(-0x0df);
        DO_PHASE(-0x0de);
        DO_PHASE(-0x0dd);
        DO_PHASE(-0x0dc);
        DO_PHASE(-0x0db);
        DO_PHASE(-0x0da);
        DO_PHASE(-0x0d9);
        DO_PHASE(-0x0d8);
        DO_PHASE(-0x0d7);
        DO_PHASE(-0x0d6);
        DO_PHASE(-0x0d5);
        DO_PHASE(-0x0d4);
        DO_PHASE(-0x0d3);
        DO_PHASE(-0x0d2);
        DO_PHASE(-0x0d1);
        DO_PHASE(-0x0d0);
        DO_PHASE(-0x0cf);
        DO_PHASE(-0x0ce);
        DO_PHASE(-0x0cd);
        DO_PHASE(-0x0cc);
        DO_PHASE(-0x0cb);
        DO_PHASE(-0x0ca);
        DO_PHASE(-0x0c9);
        DO_PHASE(-0x0c8);
        DO_PHASE(-0x0c7);
        DO_PHASE(-0x0c6);
        DO_PHASE(-0x0c5);
        DO_PHASE(-0x0c4);
        DO_PHASE(-0x0c3);
        DO_PHASE(-0x0c2);
        DO_PHASE(-0x0c1);
        DO_PHASE(-0x0c0);
        DO_PHASE(-0x0bf);
        DO_PHASE(-0x0be);
        DO_PHASE(-0x0bd);
        DO_PHASE(-0x0bc);
        DO_PHASE(-0x0bb);
        DO_PHASE(-0x0ba);
        DO_PHASE(-0x0b9);
        DO_PHASE(-0x0b8);
        DO_PHASE(-0x0b7);
        DO_PHASE(-0x0b6);
        DO_PHASE(-0x0b5);
        DO_PHASE(-0x0b4);
        DO_PHASE(-0x0b3);
        DO_PHASE(-0x0b2);
        DO_PHASE(-0x0b1);
        DO_PHASE(-0x0b0);
        DO_PHASE(-0x0af);
        DO_PHASE(-0x0ae);
        DO_PHASE(-0x0ad);
        DO_PHASE(-0x0ac);
        DO_PHASE(-0x0ab);
        DO_PHASE(-0x0aa);
        DO_PHASE(-0x0a9);
        DO_PHASE(-0x0a8);
        DO_PHASE(-0x0a7);
        DO_PHASE(-0x0a6);
        DO_PHASE(-0x0a5);
        DO_PHASE(-0x0a4);
        DO_PHASE(-0x0a3);
        DO_PHASE(-0x0a2);
        DO_PHASE(-0x0a1);
        DO_PHASE(-0x0a0);
        DO_PHASE(-0x09f);
        DO_PHASE(-0x09e);
        DO_PHASE(-0x09d);
        DO_PHASE(-0x09c);
        DO_PHASE(-0x09b);
        DO_PHASE(-0x09a);
        DO_PHASE(-0x099);
        DO_PHASE(-0x098);
        DO_PHASE(-0x097);
        DO_PHASE(-0x096);
        DO_PHASE(-0x095);
        DO_PHASE(-0x094);
        DO_PHASE(-0x093);
        DO_PHASE(-0x092);
        DO_PHASE(-0x091);
        DO_PHASE(-0x090);
        DO_PHASE(-0x08f);
        DO_PHASE(-0x08e);
        DO_PHASE(-0x08d);
        DO_PHASE(-0x08c);
        DO_PHASE(-0x08b);
        DO_PHASE(-0x08a);
        DO_PHASE(-0x089);
        DO_PHASE(-0x088);
        DO_PHASE(-0x087);
        DO_PHASE(-0x086);
        DO_PHASE(-0x085);
        DO_PHASE(-0x084);
        DO_PHASE(-0x083);
        DO_PHASE(-0x082);
        DO_PHASE(-0x081);
        DO_PHASE(-0x080);
        DO_PHASE(-0x07f);
        DO_PHASE(-0x07e);
        DO_PHASE(-0x07d);
        DO_PHASE(-0x07c);
        DO_PHASE(-0x07b);
        DO_PHASE(-0x07a);
        DO_PHASE(-0x079);
        DO_PHASE(-0x078);
        DO_PHASE(-0x077);
        DO_PHASE(-0x076);
        DO_PHASE(-0x075);
        DO_PHASE(-0x074);
        DO_PHASE(-0x073);
        DO_PHASE(-0x072);
        DO_PHASE(-0x071);
        DO_PHASE(-0x070);
        DO_PHASE(-0x06f);
        DO_PHASE(-0x06e);
        DO_PHASE(-0x06d);
        DO_PHASE(-0x06c);
        DO_PHASE(-0x06b);
        DO_PHASE(-0x06a);
        DO_PHASE(-0x069);
        DO_PHASE(-0x068);
        DO_PHASE(-0x067);
        DO_PHASE(-0x066);
        DO_PHASE(-0x065);
        DO_PHASE(-0x064);
        DO_PHASE(-0x063);
        DO_PHASE(-0x062);
        DO_PHASE(-0x061);
        DO_PHASE(-0x060);
        DO_PHASE(-0x05f);
        DO_PHASE(-0x05e);
        DO_PHASE(-0x05d);
        DO_PHASE(-0x05c);
        DO_PHASE(-0x05b);
        DO_PHASE(-0x05a);
        DO_PHASE(-0x059);
        DO_PHASE(-0x058);
        DO_PHASE(-0x057);
        DO_PHASE(-0x056);
        DO_PHASE(-0x055);
        DO_PHASE(-0x054);
        DO_PHASE(-0x053);
        DO_PHASE(-0x052);
        DO_PHASE(-0x051);
        DO_PHASE(-0x050);
        DO_PHASE(-0x04f);
        DO_PHASE(-0x04e);
        DO_PHASE(-0x04d);
        DO_PHASE(-0x04c);
        DO_PHASE(-0x04b);
        DO_PHASE(-0x04a);
        DO_PHASE(-0x049);
        DO_PHASE(-0x048);
        DO_PHASE(-0x047);
        DO_PHASE(-0x046);
        DO_PHASE(-0x045);
        DO_PHASE(-0x044);
        DO_PHASE(-0x043);
        DO_PHASE(-0x042);
        DO_PHASE(-0x041);
        DO_PHASE(-0x040);
        DO_PHASE(-0x03f);
        DO_PHASE(-0x03e);
        DO_PHASE(-0x03d);
        DO_PHASE(-0x03c);
        DO_PHASE(-0x03b);
        DO_PHASE(-0x03a);
        DO_PHASE(-0x039);
        DO_PHASE(-0x038);
        DO_PHASE(-0x037);
        DO_PHASE(-0x036);
        DO_PHASE(-0x035);
        DO_PHASE(-0x034);
        DO_PHASE(-0x033);
        DO_PHASE(-0x032);
        DO_PHASE(-0x031);
        DO_PHASE(-0x030);
        DO_PHASE(-0x02f);
        DO_PHASE(-0x02e);
        DO_PHASE(-0x02d);
        DO_PHASE(-0x02c);
        DO_PHASE(-0x02b);
        DO_PHASE(-0x02a);
        DO_PHASE(-0x029);
        DO_PHASE(-0x028);
        DO_PHASE(-0x027);
        DO_PHASE(-0x026);
        DO_PHASE(-0x025);
        DO_PHASE(-0x024);
        DO_PHASE(-0x023);
        DO_PHASE(-0x022);
        DO_PHASE(-0x021);
        DO_PHASE(-0x020);
        DO_PHASE(-0x01f);
        DO_PHASE(-0x01e);
        DO_PHASE(-0x01d);
        DO_PHASE(-0x01c);
        DO_PHASE(-0x01b);
        DO_PHASE(-0x01a);
        DO_PHASE(-0x019);
        DO_PHASE(-0x018);
        DO_PHASE(-0x017);
        DO_PHASE(-0x016);
        DO_PHASE(-0x015);
        DO_PHASE(-0x014);
        DO_PHASE(-0x013);
        DO_PHASE(-0x012);
        DO_PHASE(-0x011);
        DO_PHASE(-0x010);
        DO_PHASE(-0x00f);
        DO_PHASE(-0x00e);
        DO_PHASE(-0x00d);
        DO_PHASE(-0x00c);
        DO_PHASE(-0x00b);
        DO_PHASE(-0x00a);
        DO_PHASE(-0x009);
        DO_PHASE(-0x008);
        DO_PHASE(-0x007);
        DO_PHASE(-0x006);
        DO_PHASE(-0x005);
        DO_PHASE(-0x004);
        DO_PHASE(-0x003);
        DO_PHASE(-0x002);
        DO_PHASE(-0x001);
    }
#endif
    while(len--)
        *out++ = atan2(*b++, *a++) * deg;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created FEB-04-2003                Richard B. Johnson
//   This performs the natural log upon every element in the array.
//   Note: to convert to a log of another kind, you simply multiply
//   the value by a constant. For instance if you wanted to change these
//   log values to log base 10, you multiply them by the reciprocal
//   of the natural log of 10, a constant. Since you want most things
//   in decibels,  20 * log (A/B), you can combine operations as
//   20.0 / log(10.0).
//

#define LOGN(n) buf[n] = log(buf[n])

void SIG::LogN(double *buf, int len)
{
     double x;
#ifdef UNROLL
     while(len >= 0x100)
     {
        len -= 0x100;
        buf += 0x100;
ALIGN;
        LOGN(-0x100);
        LOGN(-0x0ff);
        LOGN(-0x0fe);
        LOGN(-0x0fd);
        LOGN(-0x0fc);
        LOGN(-0x0fb);
        LOGN(-0x0fa);
        LOGN(-0x0f9);
        LOGN(-0x0f8);
        LOGN(-0x0f7);
        LOGN(-0x0f6);
        LOGN(-0x0f5);
        LOGN(-0x0f4);
        LOGN(-0x0f3);
        LOGN(-0x0f2);
        LOGN(-0x0f1);
        LOGN(-0x0f0);
        LOGN(-0x0ef);
        LOGN(-0x0ee);
        LOGN(-0x0ed);
        LOGN(-0x0ec);
        LOGN(-0x0eb);
        LOGN(-0x0ea);
        LOGN(-0x0e9);
        LOGN(-0x0e8);
        LOGN(-0x0e7);
        LOGN(-0x0e6);
        LOGN(-0x0e5);
        LOGN(-0x0e4);
        LOGN(-0x0e3);
        LOGN(-0x0e2);
        LOGN(-0x0e1);
        LOGN(-0x0e0);
        LOGN(-0x0df);
        LOGN(-0x0de);
        LOGN(-0x0dd);
        LOGN(-0x0dc);
        LOGN(-0x0db);
        LOGN(-0x0da);
        LOGN(-0x0d9);
        LOGN(-0x0d8);
        LOGN(-0x0d7);
        LOGN(-0x0d6);
        LOGN(-0x0d5);
        LOGN(-0x0d4);
        LOGN(-0x0d3);
        LOGN(-0x0d2);
        LOGN(-0x0d1);
        LOGN(-0x0d0);
        LOGN(-0x0cf);
        LOGN(-0x0ce);
        LOGN(-0x0cd);
        LOGN(-0x0cc);
        LOGN(-0x0cb);
        LOGN(-0x0ca);
        LOGN(-0x0c9);
        LOGN(-0x0c8);
        LOGN(-0x0c7);
        LOGN(-0x0c6);
        LOGN(-0x0c5);
        LOGN(-0x0c4);
        LOGN(-0x0c3);
        LOGN(-0x0c2);
        LOGN(-0x0c1);
        LOGN(-0x0c0);
        LOGN(-0x0bf);
        LOGN(-0x0be);
        LOGN(-0x0bd);
        LOGN(-0x0bc);
        LOGN(-0x0bb);
        LOGN(-0x0ba);
        LOGN(-0x0b9);
        LOGN(-0x0b8);
        LOGN(-0x0b7);
        LOGN(-0x0b6);
        LOGN(-0x0b5);
        LOGN(-0x0b4);
        LOGN(-0x0b3);
        LOGN(-0x0b2);
        LOGN(-0x0b1);
        LOGN(-0x0b0);
        LOGN(-0x0af);
        LOGN(-0x0ae);
        LOGN(-0x0ad);
        LOGN(-0x0ac);
        LOGN(-0x0ab);
        LOGN(-0x0aa);
        LOGN(-0x0a9);
        LOGN(-0x0a8);
        LOGN(-0x0a7);
        LOGN(-0x0a6);
        LOGN(-0x0a5);
        LOGN(-0x0a4);
        LOGN(-0x0a3);
        LOGN(-0x0a2);
        LOGN(-0x0a1);
        LOGN(-0x0a0);
        LOGN(-0x09f);
        LOGN(-0x09e);
        LOGN(-0x09d);
        LOGN(-0x09c);
        LOGN(-0x09b);
        LOGN(-0x09a);
        LOGN(-0x099);
        LOGN(-0x098);
        LOGN(-0x097);
        LOGN(-0x096);
        LOGN(-0x095);
        LOGN(-0x094);
        LOGN(-0x093);
        LOGN(-0x092);
        LOGN(-0x091);
        LOGN(-0x090);
        LOGN(-0x08f);
        LOGN(-0x08e);
        LOGN(-0x08d);
        LOGN(-0x08c);
        LOGN(-0x08b);
        LOGN(-0x08a);
        LOGN(-0x089);
        LOGN(-0x088);
        LOGN(-0x087);
        LOGN(-0x086);
        LOGN(-0x085);
        LOGN(-0x084);
        LOGN(-0x083);
        LOGN(-0x082);
        LOGN(-0x081);
        LOGN(-0x080);
        LOGN(-0x07f);
        LOGN(-0x07e);
        LOGN(-0x07d);
        LOGN(-0x07c);
        LOGN(-0x07b);
        LOGN(-0x07a);
        LOGN(-0x079);
        LOGN(-0x078);
        LOGN(-0x077);
        LOGN(-0x076);
        LOGN(-0x075);
        LOGN(-0x074);
        LOGN(-0x073);
        LOGN(-0x072);
        LOGN(-0x071);
        LOGN(-0x070);
        LOGN(-0x06f);
        LOGN(-0x06e);
        LOGN(-0x06d);
        LOGN(-0x06c);
        LOGN(-0x06b);
        LOGN(-0x06a);
        LOGN(-0x069);
        LOGN(-0x068);
        LOGN(-0x067);
        LOGN(-0x066);
        LOGN(-0x065);
        LOGN(-0x064);
        LOGN(-0x063);
        LOGN(-0x062);
        LOGN(-0x061);
        LOGN(-0x060);
        LOGN(-0x05f);
        LOGN(-0x05e);
        LOGN(-0x05d);
        LOGN(-0x05c);
        LOGN(-0x05b);
        LOGN(-0x05a);
        LOGN(-0x059);
        LOGN(-0x058);
        LOGN(-0x057);
        LOGN(-0x056);
        LOGN(-0x055);
        LOGN(-0x054);
        LOGN(-0x053);
        LOGN(-0x052);
        LOGN(-0x051);
        LOGN(-0x050);
        LOGN(-0x04f);
        LOGN(-0x04e);
        LOGN(-0x04d);
        LOGN(-0x04c);
        LOGN(-0x04b);
        LOGN(-0x04a);
        LOGN(-0x049);
        LOGN(-0x048);
        LOGN(-0x047);
        LOGN(-0x046);
        LOGN(-0x045);
        LOGN(-0x044);
        LOGN(-0x043);
        LOGN(-0x042);
        LOGN(-0x041);
        LOGN(-0x040);
        LOGN(-0x03f);
        LOGN(-0x03e);
        LOGN(-0x03d);
        LOGN(-0x03c);
        LOGN(-0x03b);
        LOGN(-0x03a);
        LOGN(-0x039);
        LOGN(-0x038);
        LOGN(-0x037);
        LOGN(-0x036);
        LOGN(-0x035);
        LOGN(-0x034);
        LOGN(-0x033);
        LOGN(-0x032);
        LOGN(-0x031);
        LOGN(-0x030);
        LOGN(-0x02f);
        LOGN(-0x02e);
        LOGN(-0x02d);
        LOGN(-0x02c);
        LOGN(-0x02b);
        LOGN(-0x02a);
        LOGN(-0x029);
        LOGN(-0x028);
        LOGN(-0x027);
        LOGN(-0x026);
        LOGN(-0x025);
        LOGN(-0x024);
        LOGN(-0x023);
        LOGN(-0x022);
        LOGN(-0x021);
        LOGN(-0x020);
        LOGN(-0x01f);
        LOGN(-0x01e);
        LOGN(-0x01d);
        LOGN(-0x01c);
        LOGN(-0x01b);
        LOGN(-0x01a);
        LOGN(-0x019);
        LOGN(-0x018);
        LOGN(-0x017);
        LOGN(-0x016);
        LOGN(-0x015);
        LOGN(-0x014);
        LOGN(-0x013);
        LOGN(-0x012);
        LOGN(-0x011);
        LOGN(-0x010);
        LOGN(-0x00f);
        LOGN(-0x00e);
        LOGN(-0x00d);
        LOGN(-0x00c);
        LOGN(-0x00b);
        LOGN(-0x00a);
        LOGN(-0x009);
        LOGN(-0x008);
        LOGN(-0x007);
        LOGN(-0x006);
        LOGN(-0x005);
        LOGN(-0x004);
        LOGN(-0x003);
        LOGN(-0x002);
        LOGN(-0x001);
     }
     while(len >= 0x10)
     {
        len -= 0x10;
        buf += 0x10;
        LOGN(-0x10);
        LOGN(-0x0f);
        LOGN(-0x0e);
        LOGN(-0x0d);
        LOGN(-0x0c);
        LOGN(-0x0b);
        LOGN(-0x0a);
        LOGN(-0x09);
        LOGN(-0x08);
        LOGN(-0x07);
        LOGN(-0x06);
        LOGN(-0x05);
        LOGN(-0x04);
        LOGN(-0x03);
        LOGN(-0x02);
        LOGN(-0x01);
     }
#endif
     while(len--)
        { x = *buf ; *buf++ = log(x); }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created FEB-04-2003                Richard B. Johnson
//
//   This performs the base-10 log upon every element in the array.
//

#define LOGN10(n) buf[n] = log10(buf[n])

void SIG::Log10(double *buf, int len)
{
    double x;
#ifdef UNROLL
    while(len >= 0x100)
    {
        len -= 0x100;
        buf += 0x100;
ALIGN;
        LOGN10(-0x100);
        LOGN10(-0x0ff);
        LOGN10(-0x0fe);
        LOGN10(-0x0fd);
        LOGN10(-0x0fc);
        LOGN10(-0x0fb);
        LOGN10(-0x0fa);
        LOGN10(-0x0f9);
        LOGN10(-0x0f8);
        LOGN10(-0x0f7);
        LOGN10(-0x0f6);
        LOGN10(-0x0f5);
        LOGN10(-0x0f4);
        LOGN10(-0x0f3);
        LOGN10(-0x0f2);
        LOGN10(-0x0f1);
        LOGN10(-0x0f0);
        LOGN10(-0x0ef);
        LOGN10(-0x0ee);
        LOGN10(-0x0ed);
        LOGN10(-0x0ec);
        LOGN10(-0x0eb);
        LOGN10(-0x0ea);
        LOGN10(-0x0e9);
        LOGN10(-0x0e8);
        LOGN10(-0x0e7);
        LOGN10(-0x0e6);
        LOGN10(-0x0e5);
        LOGN10(-0x0e4);
        LOGN10(-0x0e3);
        LOGN10(-0x0e2);
        LOGN10(-0x0e1);
        LOGN10(-0x0e0);
        LOGN10(-0x0df);
        LOGN10(-0x0de);
        LOGN10(-0x0dd);
        LOGN10(-0x0dc);
        LOGN10(-0x0db);
        LOGN10(-0x0da);
        LOGN10(-0x0d9);
        LOGN10(-0x0d8);
        LOGN10(-0x0d7);
        LOGN10(-0x0d6);
        LOGN10(-0x0d5);
        LOGN10(-0x0d4);
        LOGN10(-0x0d3);
        LOGN10(-0x0d2);
        LOGN10(-0x0d1);
        LOGN10(-0x0d0);
        LOGN10(-0x0cf);
        LOGN10(-0x0ce);
        LOGN10(-0x0cd);
        LOGN10(-0x0cc);
        LOGN10(-0x0cb);
        LOGN10(-0x0ca);
        LOGN10(-0x0c9);
        LOGN10(-0x0c8);
        LOGN10(-0x0c7);
        LOGN10(-0x0c6);
        LOGN10(-0x0c5);
        LOGN10(-0x0c4);
        LOGN10(-0x0c3);
        LOGN10(-0x0c2);
        LOGN10(-0x0c1);
        LOGN10(-0x0c0);
        LOGN10(-0x0bf);
        LOGN10(-0x0be);
        LOGN10(-0x0bd);
        LOGN10(-0x0bc);
        LOGN10(-0x0bb);
        LOGN10(-0x0ba);
        LOGN10(-0x0b9);
        LOGN10(-0x0b8);
        LOGN10(-0x0b7);
        LOGN10(-0x0b6);
        LOGN10(-0x0b5);
        LOGN10(-0x0b4);
        LOGN10(-0x0b3);
        LOGN10(-0x0b2);
        LOGN10(-0x0b1);
        LOGN10(-0x0b0);
        LOGN10(-0x0af);
        LOGN10(-0x0ae);
        LOGN10(-0x0ad);
        LOGN10(-0x0ac);
        LOGN10(-0x0ab);
        LOGN10(-0x0aa);
        LOGN10(-0x0a9);
        LOGN10(-0x0a8);
        LOGN10(-0x0a7);
        LOGN10(-0x0a6);
        LOGN10(-0x0a5);
        LOGN10(-0x0a4);
        LOGN10(-0x0a3);
        LOGN10(-0x0a2);
        LOGN10(-0x0a1);
        LOGN10(-0x0a0);
        LOGN10(-0x09f);
        LOGN10(-0x09e);
        LOGN10(-0x09d);
        LOGN10(-0x09c);
        LOGN10(-0x09b);
        LOGN10(-0x09a);
        LOGN10(-0x099);
        LOGN10(-0x098);
        LOGN10(-0x097);
        LOGN10(-0x096);
        LOGN10(-0x095);
        LOGN10(-0x094);
        LOGN10(-0x093);
        LOGN10(-0x092);
        LOGN10(-0x091);
        LOGN10(-0x090);
        LOGN10(-0x08f);
        LOGN10(-0x08e);
        LOGN10(-0x08d);
        LOGN10(-0x08c);
        LOGN10(-0x08b);
        LOGN10(-0x08a);
        LOGN10(-0x089);
        LOGN10(-0x088);
        LOGN10(-0x087);
        LOGN10(-0x086);
        LOGN10(-0x085);
        LOGN10(-0x084);
        LOGN10(-0x083);
        LOGN10(-0x082);
        LOGN10(-0x081);
        LOGN10(-0x080);
        LOGN10(-0x07f);
        LOGN10(-0x07e);
        LOGN10(-0x07d);
        LOGN10(-0x07c);
        LOGN10(-0x07b);
        LOGN10(-0x07a);
        LOGN10(-0x079);
        LOGN10(-0x078);
        LOGN10(-0x077);
        LOGN10(-0x076);
        LOGN10(-0x075);
        LOGN10(-0x074);
        LOGN10(-0x073);
        LOGN10(-0x072);
        LOGN10(-0x071);
        LOGN10(-0x070);
        LOGN10(-0x06f);
        LOGN10(-0x06e);
        LOGN10(-0x06d);
        LOGN10(-0x06c);
        LOGN10(-0x06b);
        LOGN10(-0x06a);
        LOGN10(-0x069);
        LOGN10(-0x068);
        LOGN10(-0x067);
        LOGN10(-0x066);
        LOGN10(-0x065);
        LOGN10(-0x064);
        LOGN10(-0x063);
        LOGN10(-0x062);
        LOGN10(-0x061);
        LOGN10(-0x060);
        LOGN10(-0x05f);
        LOGN10(-0x05e);
        LOGN10(-0x05d);
        LOGN10(-0x05c);
        LOGN10(-0x05b);
        LOGN10(-0x05a);
        LOGN10(-0x059);
        LOGN10(-0x058);
        LOGN10(-0x057);
        LOGN10(-0x056);
        LOGN10(-0x055);
        LOGN10(-0x054);
        LOGN10(-0x053);
        LOGN10(-0x052);
        LOGN10(-0x051);
        LOGN10(-0x050);
        LOGN10(-0x04f);
        LOGN10(-0x04e);
        LOGN10(-0x04d);
        LOGN10(-0x04c);
        LOGN10(-0x04b);
        LOGN10(-0x04a);
        LOGN10(-0x049);
        LOGN10(-0x048);
        LOGN10(-0x047);
        LOGN10(-0x046);
        LOGN10(-0x045);
        LOGN10(-0x044);
        LOGN10(-0x043);
        LOGN10(-0x042);
        LOGN10(-0x041);
        LOGN10(-0x040);
        LOGN10(-0x03f);
        LOGN10(-0x03e);
        LOGN10(-0x03d);
        LOGN10(-0x03c);
        LOGN10(-0x03b);
        LOGN10(-0x03a);
        LOGN10(-0x039);
        LOGN10(-0x038);
        LOGN10(-0x037);
        LOGN10(-0x036);
        LOGN10(-0x035);
        LOGN10(-0x034);
        LOGN10(-0x033);
        LOGN10(-0x032);
        LOGN10(-0x031);
        LOGN10(-0x030);
        LOGN10(-0x02f);
        LOGN10(-0x02e);
        LOGN10(-0x02d);
        LOGN10(-0x02c);
        LOGN10(-0x02b);
        LOGN10(-0x02a);
        LOGN10(-0x029);
        LOGN10(-0x028);
        LOGN10(-0x027);
        LOGN10(-0x026);
        LOGN10(-0x025);
        LOGN10(-0x024);
        LOGN10(-0x023);
        LOGN10(-0x022);
        LOGN10(-0x021);
        LOGN10(-0x020);
        LOGN10(-0x01f);
        LOGN10(-0x01e);
        LOGN10(-0x01d);
        LOGN10(-0x01c);
        LOGN10(-0x01b);
        LOGN10(-0x01a);
        LOGN10(-0x019);
        LOGN10(-0x018);
        LOGN10(-0x017);
        LOGN10(-0x016);
        LOGN10(-0x015);
        LOGN10(-0x014);
        LOGN10(-0x013);
        LOGN10(-0x012);
        LOGN10(-0x011);
        LOGN10(-0x010);
        LOGN10(-0x00f);
        LOGN10(-0x00e);
        LOGN10(-0x00d);
        LOGN10(-0x00c);
        LOGN10(-0x00b);
        LOGN10(-0x00a);
        LOGN10(-0x009);
        LOGN10(-0x008);
        LOGN10(-0x007);
        LOGN10(-0x006);
        LOGN10(-0x005);
        LOGN10(-0x004);
        LOGN10(-0x003);
        LOGN10(-0x002);
        LOGN10(-0x001);
    }
    while(len >= 0x10)
    {
        len -= 0x10;
        buf += 0x10;
        LOGN10(-0x10);
        LOGN10(-0x0f);
        LOGN10(-0x0e);
        LOGN10(-0x0d);
        LOGN10(-0x0c);
        LOGN10(-0x0b);
        LOGN10(-0x0a);
        LOGN10(-0x09);
        LOGN10(-0x08);
        LOGN10(-0x07);
        LOGN10(-0x06);
        LOGN10(-0x05);
        LOGN10(-0x04);
        LOGN10(-0x03);
        LOGN10(-0x02);
        LOGN10(-0x01);
    }
#endif
     while(len--)
        { x = *buf ; *buf++ = log10(x); }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created FEB-03-2003                Richard B. Johnson
//
//   This returns the RMS value of all the elements in the array.
//

#define ACC_SQUARES(n) x = buf[n] ; x *= x ; accum += x

double SIG::ArrayRMS(double *buf, int len)
{
    double accum;
    double x;
    double bins;
    bins = (double) len;
    x = accum = 0.0;
#ifdef UNROLL
    while(len >= 0x100)
    {
        buf += 0x100;
        len -= 0x100;
ALIGN;
        ACC_SQUARES(-0x100);
        ACC_SQUARES(-0x0ff);
        ACC_SQUARES(-0x0fe);
        ACC_SQUARES(-0x0fd);
        ACC_SQUARES(-0x0fc);
        ACC_SQUARES(-0x0fb);
        ACC_SQUARES(-0x0fa);
        ACC_SQUARES(-0x0f9);
        ACC_SQUARES(-0x0f8);
        ACC_SQUARES(-0x0f7);
        ACC_SQUARES(-0x0f6);
        ACC_SQUARES(-0x0f5);
        ACC_SQUARES(-0x0f4);
        ACC_SQUARES(-0x0f3);
        ACC_SQUARES(-0x0f2);
        ACC_SQUARES(-0x0f1);
        ACC_SQUARES(-0x0f0);
        ACC_SQUARES(-0x0ef);
        ACC_SQUARES(-0x0ee);
        ACC_SQUARES(-0x0ed);
        ACC_SQUARES(-0x0ec);
        ACC_SQUARES(-0x0eb);
        ACC_SQUARES(-0x0ea);
        ACC_SQUARES(-0x0e9);
        ACC_SQUARES(-0x0e8);
        ACC_SQUARES(-0x0e7);
        ACC_SQUARES(-0x0e6);
        ACC_SQUARES(-0x0e5);
        ACC_SQUARES(-0x0e4);
        ACC_SQUARES(-0x0e3);
        ACC_SQUARES(-0x0e2);
        ACC_SQUARES(-0x0e1);
        ACC_SQUARES(-0x0e0);
        ACC_SQUARES(-0x0df);
        ACC_SQUARES(-0x0de);
        ACC_SQUARES(-0x0dd);
        ACC_SQUARES(-0x0dc);
        ACC_SQUARES(-0x0db);
        ACC_SQUARES(-0x0da);
        ACC_SQUARES(-0x0d9);
        ACC_SQUARES(-0x0d8);
        ACC_SQUARES(-0x0d7);
        ACC_SQUARES(-0x0d6);
        ACC_SQUARES(-0x0d5);
        ACC_SQUARES(-0x0d4);
        ACC_SQUARES(-0x0d3);
        ACC_SQUARES(-0x0d2);
        ACC_SQUARES(-0x0d1);
        ACC_SQUARES(-0x0d0);
        ACC_SQUARES(-0x0cf);
        ACC_SQUARES(-0x0ce);
        ACC_SQUARES(-0x0cd);
        ACC_SQUARES(-0x0cc);
        ACC_SQUARES(-0x0cb);
        ACC_SQUARES(-0x0ca);
        ACC_SQUARES(-0x0c9);
        ACC_SQUARES(-0x0c8);
        ACC_SQUARES(-0x0c7);
        ACC_SQUARES(-0x0c6);
        ACC_SQUARES(-0x0c5);
        ACC_SQUARES(-0x0c4);
        ACC_SQUARES(-0x0c3);
        ACC_SQUARES(-0x0c2);
        ACC_SQUARES(-0x0c1);
        ACC_SQUARES(-0x0c0);
        ACC_SQUARES(-0x0bf);
        ACC_SQUARES(-0x0be);
        ACC_SQUARES(-0x0bd);
        ACC_SQUARES(-0x0bc);
        ACC_SQUARES(-0x0bb);
        ACC_SQUARES(-0x0ba);
        ACC_SQUARES(-0x0b9);
        ACC_SQUARES(-0x0b8);
        ACC_SQUARES(-0x0b7);
        ACC_SQUARES(-0x0b6);
        ACC_SQUARES(-0x0b5);
        ACC_SQUARES(-0x0b4);
        ACC_SQUARES(-0x0b3);
        ACC_SQUARES(-0x0b2);
        ACC_SQUARES(-0x0b1);
        ACC_SQUARES(-0x0b0);
        ACC_SQUARES(-0x0af);
        ACC_SQUARES(-0x0ae);
        ACC_SQUARES(-0x0ad);
        ACC_SQUARES(-0x0ac);
        ACC_SQUARES(-0x0ab);
        ACC_SQUARES(-0x0aa);
        ACC_SQUARES(-0x0a9);
        ACC_SQUARES(-0x0a8);
        ACC_SQUARES(-0x0a7);
        ACC_SQUARES(-0x0a6);
        ACC_SQUARES(-0x0a5);
        ACC_SQUARES(-0x0a4);
        ACC_SQUARES(-0x0a3);
        ACC_SQUARES(-0x0a2);
        ACC_SQUARES(-0x0a1);
        ACC_SQUARES(-0x0a0);
        ACC_SQUARES(-0x09f);
        ACC_SQUARES(-0x09e);
        ACC_SQUARES(-0x09d);
        ACC_SQUARES(-0x09c);
        ACC_SQUARES(-0x09b);
        ACC_SQUARES(-0x09a);
        ACC_SQUARES(-0x099);
        ACC_SQUARES(-0x098);
        ACC_SQUARES(-0x097);
        ACC_SQUARES(-0x096);
        ACC_SQUARES(-0x095);
        ACC_SQUARES(-0x094);
        ACC_SQUARES(-0x093);
        ACC_SQUARES(-0x092);
        ACC_SQUARES(-0x091);
        ACC_SQUARES(-0x090);
        ACC_SQUARES(-0x08f);
        ACC_SQUARES(-0x08e);
        ACC_SQUARES(-0x08d);
        ACC_SQUARES(-0x08c);
        ACC_SQUARES(-0x08b);
        ACC_SQUARES(-0x08a);
        ACC_SQUARES(-0x089);
        ACC_SQUARES(-0x088);
        ACC_SQUARES(-0x087);
        ACC_SQUARES(-0x086);
        ACC_SQUARES(-0x085);
        ACC_SQUARES(-0x084);
        ACC_SQUARES(-0x083);
        ACC_SQUARES(-0x082);
        ACC_SQUARES(-0x081);
        ACC_SQUARES(-0x080);
        ACC_SQUARES(-0x07f);
        ACC_SQUARES(-0x07e);
        ACC_SQUARES(-0x07d);
        ACC_SQUARES(-0x07c);
        ACC_SQUARES(-0x07b);
        ACC_SQUARES(-0x07a);
        ACC_SQUARES(-0x079);
        ACC_SQUARES(-0x078);
        ACC_SQUARES(-0x077);
        ACC_SQUARES(-0x076);
        ACC_SQUARES(-0x075);
        ACC_SQUARES(-0x074);
        ACC_SQUARES(-0x073);
        ACC_SQUARES(-0x072);
        ACC_SQUARES(-0x071);
        ACC_SQUARES(-0x070);
        ACC_SQUARES(-0x06f);
        ACC_SQUARES(-0x06e);
        ACC_SQUARES(-0x06d);
        ACC_SQUARES(-0x06c);
        ACC_SQUARES(-0x06b);
        ACC_SQUARES(-0x06a);
        ACC_SQUARES(-0x069);
        ACC_SQUARES(-0x068);
        ACC_SQUARES(-0x067);
        ACC_SQUARES(-0x066);
        ACC_SQUARES(-0x065);
        ACC_SQUARES(-0x064);
        ACC_SQUARES(-0x063);
        ACC_SQUARES(-0x062);
        ACC_SQUARES(-0x061);
        ACC_SQUARES(-0x060);
        ACC_SQUARES(-0x05f);
        ACC_SQUARES(-0x05e);
        ACC_SQUARES(-0x05d);
        ACC_SQUARES(-0x05c);
        ACC_SQUARES(-0x05b);
        ACC_SQUARES(-0x05a);
        ACC_SQUARES(-0x059);
        ACC_SQUARES(-0x058);
        ACC_SQUARES(-0x057);
        ACC_SQUARES(-0x056);
        ACC_SQUARES(-0x055);
        ACC_SQUARES(-0x054);
        ACC_SQUARES(-0x053);
        ACC_SQUARES(-0x052);
        ACC_SQUARES(-0x051);
        ACC_SQUARES(-0x050);
        ACC_SQUARES(-0x04f);
        ACC_SQUARES(-0x04e);
        ACC_SQUARES(-0x04d);
        ACC_SQUARES(-0x04c);
        ACC_SQUARES(-0x04b);
        ACC_SQUARES(-0x04a);
        ACC_SQUARES(-0x049);
        ACC_SQUARES(-0x048);
        ACC_SQUARES(-0x047);
        ACC_SQUARES(-0x046);
        ACC_SQUARES(-0x045);
        ACC_SQUARES(-0x044);
        ACC_SQUARES(-0x043);
        ACC_SQUARES(-0x042);
        ACC_SQUARES(-0x041);
        ACC_SQUARES(-0x040);
        ACC_SQUARES(-0x03f);
        ACC_SQUARES(-0x03e);
        ACC_SQUARES(-0x03d);
        ACC_SQUARES(-0x03c);
        ACC_SQUARES(-0x03b);
        ACC_SQUARES(-0x03a);
        ACC_SQUARES(-0x039);
        ACC_SQUARES(-0x038);
        ACC_SQUARES(-0x037);
        ACC_SQUARES(-0x036);
        ACC_SQUARES(-0x035);
        ACC_SQUARES(-0x034);
        ACC_SQUARES(-0x033);
        ACC_SQUARES(-0x032);
        ACC_SQUARES(-0x031);
        ACC_SQUARES(-0x030);
        ACC_SQUARES(-0x02f);
        ACC_SQUARES(-0x02e);
        ACC_SQUARES(-0x02d);
        ACC_SQUARES(-0x02c);
        ACC_SQUARES(-0x02b);
        ACC_SQUARES(-0x02a);
        ACC_SQUARES(-0x029);
        ACC_SQUARES(-0x028);
        ACC_SQUARES(-0x027);
        ACC_SQUARES(-0x026);
        ACC_SQUARES(-0x025);
        ACC_SQUARES(-0x024);
        ACC_SQUARES(-0x023);
        ACC_SQUARES(-0x022);
        ACC_SQUARES(-0x021);
        ACC_SQUARES(-0x020);
        ACC_SQUARES(-0x01f);
        ACC_SQUARES(-0x01e);
        ACC_SQUARES(-0x01d);
        ACC_SQUARES(-0x01c);
        ACC_SQUARES(-0x01b);
        ACC_SQUARES(-0x01a);
        ACC_SQUARES(-0x019);
        ACC_SQUARES(-0x018);
        ACC_SQUARES(-0x017);
        ACC_SQUARES(-0x016);
        ACC_SQUARES(-0x015);
        ACC_SQUARES(-0x014);
        ACC_SQUARES(-0x013);
        ACC_SQUARES(-0x012);
        ACC_SQUARES(-0x011);
        ACC_SQUARES(-0x010);
        ACC_SQUARES(-0x00f);
        ACC_SQUARES(-0x00e);
        ACC_SQUARES(-0x00d);
        ACC_SQUARES(-0x00c);
        ACC_SQUARES(-0x00b);
        ACC_SQUARES(-0x00a);
        ACC_SQUARES(-0x009);
        ACC_SQUARES(-0x008);
        ACC_SQUARES(-0x007);
        ACC_SQUARES(-0x006);
        ACC_SQUARES(-0x005);
        ACC_SQUARES(-0x004);
        ACC_SQUARES(-0x003);
        ACC_SQUARES(-0x002);
        ACC_SQUARES(-0x001);
    }
    while(len >= 0x10)
    {
        buf += 0x10;
        len -= 0x10;
        ACC_SQUARES(-0x10);
        ACC_SQUARES(-0x0f);
        ACC_SQUARES(-0x0e);
        ACC_SQUARES(-0x0d);
        ACC_SQUARES(-0x0c);
        ACC_SQUARES(-0x0b);
        ACC_SQUARES(-0x0a);
        ACC_SQUARES(-0x09);
        ACC_SQUARES(-0x08);
        ACC_SQUARES(-0x07);
        ACC_SQUARES(-0x06);
        ACC_SQUARES(-0x05);
        ACC_SQUARES(-0x04);
        ACC_SQUARES(-0x03);
        ACC_SQUARES(-0x02);
        ACC_SQUARES(-0x01);
    }
#endif
    while(len--)
        { x = *buf++ ; x *= x ; accum += x; }
    bins += ZERO;
    return sqrt(accum/bins);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 31-JAN-2003               Richard B. Johnson
//
//  The FFT routine sometimes returns NaNs. Once you have a NaN, you
//  can't perform operations upon it. You are screwed. Real-world data
//  will sometimes give you the kind of junk that can produce NaNs.
//  Therefore, here is a ix86-specific routine to find a NaN. This
//  is used in place of "isnan()" because Windows doesn't have it.
//
int SIG::isNaN(double val)
{
    union {
        double a;
        unsigned short b[4];     /* Warning!  Machine-specific! */
        } u;
    u.a = val;
    return (u.b[3] == (unsigned short)0xfff8);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 31-JAN-2003               Richard B. Johnson
//
//  This gets the dB ratio of 20.0 log(A/B) while preventing NaN and
//  other overflow problems. Real world data contains junk.
//
double SIG::get_db(double ref, double val)
{
    if(ref < 0.0) ref = DYN;
    if(val < 0.0) val = DYN;
    if(ref < DYN) ref = DYN;
    if(val < DYN) val = DYN;
    if(isNaN(val))val = DYN;
    return 20.0 * log10(val/ref);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 29-JAN-2003               Richard B. Johnson
//
//  Gets the data in the bins on each side of a center element
//  (power series). It returns the square-root of the sum of the
//  squares of these data.
//
double SIG::get_bins(double *array, int ctr, int nr_bins)
{
    int i;
    double result, x;
    result = 0.0;
    array += (ctr - (nr_bins/2));
    for(i=0; i< nr_bins; i++)
    {
        x = *array++;
        result += (x * x);
    }
    return sqrt(result);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*
//
//  Created 29-JAN-2003               Richard B. Johnson
//
//  Performs the square-root of the sum of the squares on the input
//  vector and returns the result in the output array.
//

#define SQRT_SUMS(n) out[n] = _hypot(a[n], b[n])

void SIG::get_mag(double *out, double *a, double *b, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        out  += 0x100;
        a    += 0x100;
        b    += 0x100;
        len  -= 0x100;
ALIGN;
        SQRT_SUMS(-0x100);
        SQRT_SUMS(-0x0ff);
        SQRT_SUMS(-0x0fe);
        SQRT_SUMS(-0x0fd);
        SQRT_SUMS(-0x0fc);
        SQRT_SUMS(-0x0fb);
        SQRT_SUMS(-0x0fa);
        SQRT_SUMS(-0x0f9);
        SQRT_SUMS(-0x0f8);
        SQRT_SUMS(-0x0f7);
        SQRT_SUMS(-0x0f6);
        SQRT_SUMS(-0x0f5);
        SQRT_SUMS(-0x0f4);
        SQRT_SUMS(-0x0f3);
        SQRT_SUMS(-0x0f2);
        SQRT_SUMS(-0x0f1);
        SQRT_SUMS(-0x0f0);
        SQRT_SUMS(-0x0ef);
        SQRT_SUMS(-0x0ee);
        SQRT_SUMS(-0x0ed);
        SQRT_SUMS(-0x0ec);
        SQRT_SUMS(-0x0eb);
        SQRT_SUMS(-0x0ea);
        SQRT_SUMS(-0x0e9);
        SQRT_SUMS(-0x0e8);
        SQRT_SUMS(-0x0e7);
        SQRT_SUMS(-0x0e6);
        SQRT_SUMS(-0x0e5);
        SQRT_SUMS(-0x0e4);
        SQRT_SUMS(-0x0e3);
        SQRT_SUMS(-0x0e2);
        SQRT_SUMS(-0x0e1);
        SQRT_SUMS(-0x0e0);
        SQRT_SUMS(-0x0df);
        SQRT_SUMS(-0x0de);
        SQRT_SUMS(-0x0dd);
        SQRT_SUMS(-0x0dc);
        SQRT_SUMS(-0x0db);
        SQRT_SUMS(-0x0da);
        SQRT_SUMS(-0x0d9);
        SQRT_SUMS(-0x0d8);
        SQRT_SUMS(-0x0d7);
        SQRT_SUMS(-0x0d6);
        SQRT_SUMS(-0x0d5);
        SQRT_SUMS(-0x0d4);
        SQRT_SUMS(-0x0d3);
        SQRT_SUMS(-0x0d2);
        SQRT_SUMS(-0x0d1);
        SQRT_SUMS(-0x0d0);
        SQRT_SUMS(-0x0cf);
        SQRT_SUMS(-0x0ce);
        SQRT_SUMS(-0x0cd);
        SQRT_SUMS(-0x0cc);
        SQRT_SUMS(-0x0cb);
        SQRT_SUMS(-0x0ca);
        SQRT_SUMS(-0x0c9);
        SQRT_SUMS(-0x0c8);
        SQRT_SUMS(-0x0c7);
        SQRT_SUMS(-0x0c6);
        SQRT_SUMS(-0x0c5);
        SQRT_SUMS(-0x0c4);
        SQRT_SUMS(-0x0c3);
        SQRT_SUMS(-0x0c2);
        SQRT_SUMS(-0x0c1);
        SQRT_SUMS(-0x0c0);
        SQRT_SUMS(-0x0bf);
        SQRT_SUMS(-0x0be);
        SQRT_SUMS(-0x0bd);
        SQRT_SUMS(-0x0bc);
        SQRT_SUMS(-0x0bb);
        SQRT_SUMS(-0x0ba);
        SQRT_SUMS(-0x0b9);
        SQRT_SUMS(-0x0b8);
        SQRT_SUMS(-0x0b7);
        SQRT_SUMS(-0x0b6);
        SQRT_SUMS(-0x0b5);
        SQRT_SUMS(-0x0b4);
        SQRT_SUMS(-0x0b3);
        SQRT_SUMS(-0x0b2);
        SQRT_SUMS(-0x0b1);
        SQRT_SUMS(-0x0b0);
        SQRT_SUMS(-0x0af);
        SQRT_SUMS(-0x0ae);
        SQRT_SUMS(-0x0ad);
        SQRT_SUMS(-0x0ac);
        SQRT_SUMS(-0x0ab);
        SQRT_SUMS(-0x0aa);
        SQRT_SUMS(-0x0a9);
        SQRT_SUMS(-0x0a8);
        SQRT_SUMS(-0x0a7);
        SQRT_SUMS(-0x0a6);
        SQRT_SUMS(-0x0a5);
        SQRT_SUMS(-0x0a4);
        SQRT_SUMS(-0x0a3);
        SQRT_SUMS(-0x0a2);
        SQRT_SUMS(-0x0a1);
        SQRT_SUMS(-0x0a0);
        SQRT_SUMS(-0x09f);
        SQRT_SUMS(-0x09e);
        SQRT_SUMS(-0x09d);
        SQRT_SUMS(-0x09c);
        SQRT_SUMS(-0x09b);
        SQRT_SUMS(-0x09a);
        SQRT_SUMS(-0x099);
        SQRT_SUMS(-0x098);
        SQRT_SUMS(-0x097);
        SQRT_SUMS(-0x096);
        SQRT_SUMS(-0x095);
        SQRT_SUMS(-0x094);
        SQRT_SUMS(-0x093);
        SQRT_SUMS(-0x092);
        SQRT_SUMS(-0x091);
        SQRT_SUMS(-0x090);
        SQRT_SUMS(-0x08f);
        SQRT_SUMS(-0x08e);
        SQRT_SUMS(-0x08d);
        SQRT_SUMS(-0x08c);
        SQRT_SUMS(-0x08b);
        SQRT_SUMS(-0x08a);
        SQRT_SUMS(-0x089);
        SQRT_SUMS(-0x088);
        SQRT_SUMS(-0x087);
        SQRT_SUMS(-0x086);
        SQRT_SUMS(-0x085);
        SQRT_SUMS(-0x084);
        SQRT_SUMS(-0x083);
        SQRT_SUMS(-0x082);
        SQRT_SUMS(-0x081);
        SQRT_SUMS(-0x080);
        SQRT_SUMS(-0x07f);
        SQRT_SUMS(-0x07e);
        SQRT_SUMS(-0x07d);
        SQRT_SUMS(-0x07c);
        SQRT_SUMS(-0x07b);
        SQRT_SUMS(-0x07a);
        SQRT_SUMS(-0x079);
        SQRT_SUMS(-0x078);
        SQRT_SUMS(-0x077);
        SQRT_SUMS(-0x076);
        SQRT_SUMS(-0x075);
        SQRT_SUMS(-0x074);
        SQRT_SUMS(-0x073);
        SQRT_SUMS(-0x072);
        SQRT_SUMS(-0x071);
        SQRT_SUMS(-0x070);
        SQRT_SUMS(-0x06f);
        SQRT_SUMS(-0x06e);
        SQRT_SUMS(-0x06d);
        SQRT_SUMS(-0x06c);
        SQRT_SUMS(-0x06b);
        SQRT_SUMS(-0x06a);
        SQRT_SUMS(-0x069);
        SQRT_SUMS(-0x068);
        SQRT_SUMS(-0x067);
        SQRT_SUMS(-0x066);
        SQRT_SUMS(-0x065);
        SQRT_SUMS(-0x064);
        SQRT_SUMS(-0x063);
        SQRT_SUMS(-0x062);
        SQRT_SUMS(-0x061);
        SQRT_SUMS(-0x060);
        SQRT_SUMS(-0x05f);
        SQRT_SUMS(-0x05e);
        SQRT_SUMS(-0x05d);
        SQRT_SUMS(-0x05c);
        SQRT_SUMS(-0x05b);
        SQRT_SUMS(-0x05a);
        SQRT_SUMS(-0x059);
        SQRT_SUMS(-0x058);
        SQRT_SUMS(-0x057);
        SQRT_SUMS(-0x056);
        SQRT_SUMS(-0x055);
        SQRT_SUMS(-0x054);
        SQRT_SUMS(-0x053);
        SQRT_SUMS(-0x052);
        SQRT_SUMS(-0x051);
        SQRT_SUMS(-0x050);
        SQRT_SUMS(-0x04f);
        SQRT_SUMS(-0x04e);
        SQRT_SUMS(-0x04d);
        SQRT_SUMS(-0x04c);
        SQRT_SUMS(-0x04b);
        SQRT_SUMS(-0x04a);
        SQRT_SUMS(-0x049);
        SQRT_SUMS(-0x048);
        SQRT_SUMS(-0x047);
        SQRT_SUMS(-0x046);
        SQRT_SUMS(-0x045);
        SQRT_SUMS(-0x044);
        SQRT_SUMS(-0x043);
        SQRT_SUMS(-0x042);
        SQRT_SUMS(-0x041);
        SQRT_SUMS(-0x040);
        SQRT_SUMS(-0x03f);
        SQRT_SUMS(-0x03e);
        SQRT_SUMS(-0x03d);
        SQRT_SUMS(-0x03c);
        SQRT_SUMS(-0x03b);
        SQRT_SUMS(-0x03a);
        SQRT_SUMS(-0x039);
        SQRT_SUMS(-0x038);
        SQRT_SUMS(-0x037);
        SQRT_SUMS(-0x036);
        SQRT_SUMS(-0x035);
        SQRT_SUMS(-0x034);
        SQRT_SUMS(-0x033);
        SQRT_SUMS(-0x032);
        SQRT_SUMS(-0x031);
        SQRT_SUMS(-0x030);
        SQRT_SUMS(-0x02f);
        SQRT_SUMS(-0x02e);
        SQRT_SUMS(-0x02d);
        SQRT_SUMS(-0x02c);
        SQRT_SUMS(-0x02b);
        SQRT_SUMS(-0x02a);
        SQRT_SUMS(-0x029);
        SQRT_SUMS(-0x028);
        SQRT_SUMS(-0x027);
        SQRT_SUMS(-0x026);
        SQRT_SUMS(-0x025);
        SQRT_SUMS(-0x024);
        SQRT_SUMS(-0x023);
        SQRT_SUMS(-0x022);
        SQRT_SUMS(-0x021);
        SQRT_SUMS(-0x020);
        SQRT_SUMS(-0x01f);
        SQRT_SUMS(-0x01e);
        SQRT_SUMS(-0x01d);
        SQRT_SUMS(-0x01c);
        SQRT_SUMS(-0x01b);
        SQRT_SUMS(-0x01a);
        SQRT_SUMS(-0x019);
        SQRT_SUMS(-0x018);
        SQRT_SUMS(-0x017);
        SQRT_SUMS(-0x016);
        SQRT_SUMS(-0x015);
        SQRT_SUMS(-0x014);
        SQRT_SUMS(-0x013);
        SQRT_SUMS(-0x012);
        SQRT_SUMS(-0x011);
        SQRT_SUMS(-0x010);
        SQRT_SUMS(-0x00f);
        SQRT_SUMS(-0x00e);
        SQRT_SUMS(-0x00d);
        SQRT_SUMS(-0x00c);
        SQRT_SUMS(-0x00b);
        SQRT_SUMS(-0x00a);
        SQRT_SUMS(-0x009);
        SQRT_SUMS(-0x008);
        SQRT_SUMS(-0x007);
        SQRT_SUMS(-0x006);
        SQRT_SUMS(-0x005);
        SQRT_SUMS(-0x004);
        SQRT_SUMS(-0x003);
        SQRT_SUMS(-0x002);
        SQRT_SUMS(-0x001);
    }
    while(len >= 0x10)
    {
        out  += 0x10;
        a    += 0x10;
        b    += 0x10;
        len  -= 0x10;
        SQRT_SUMS(-0x10);
        SQRT_SUMS(-0x0f);
        SQRT_SUMS(-0x0e);
        SQRT_SUMS(-0x0d);
        SQRT_SUMS(-0x0c);
        SQRT_SUMS(-0x0b);
        SQRT_SUMS(-0x0a);
        SQRT_SUMS(-0x09);
        SQRT_SUMS(-0x08);
        SQRT_SUMS(-0x07);
        SQRT_SUMS(-0x06);
        SQRT_SUMS(-0x05);
        SQRT_SUMS(-0x04);
        SQRT_SUMS(-0x03);
        SQRT_SUMS(-0x02);
        SQRT_SUMS(-0x01);
    }
#endif
    while(len--)
        *out++ =  _hypot(*a++, *b++);
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 28-JAN-2003                Richard B. Johnson
//
//  This performs the FFT secretarial work so we return with an
//  array, "out" that contains the frequency components from the
//  sampled data in "in". It returns the floating-point index
//  of the lowest non-zero frequency found.
//
//  Note: This is floating-point so you can find the nth harmonic
//  by multiplying it by n, then converting to an integer index.
//  If you disagree, talk to Hans Weedon. He does this for a living.
//
double SIG::do_FFT(double *out, double *in, enum SIG::WINDOW_TYPE win, int len)
{
    double *a, *b;
    int j, i;

    for(i = 0, j = 1; i < 32; i++, j <<= 1)
        if(j >= len)
            break;

    if((a = new double [j]) == NULL)
        return 0;
    if((b = new double [j]) == NULL)
    {
        delete[] a;
        return 0;
    }

    memset(a, 0x00, j * sizeof(double));
    memset(b, 0x00, j * sizeof(double));
    memcpy(a, in,   len * sizeof(double));
    SubConst(a, MeasMean(a, j), j);
    Window(a, win,  j);
    parse_fft(a, b, i, 0);
    get_mag(out, a, b, len);
    delete[] a;
    delete[] b;
    return IndexToFirstPeak(out, (len/ 2));
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 28-JAN-2003                Richard B. Johnson
//
//  This windows the supplied data according to some defined window.
//
//
void SIG::Window(double *array, enum WINDOW_TYPE type, int len)
{
    double *dp;
    if((dp = new double [len]) == NULL)
        return;
    switch(type)
    {
    case WINDOW_TYPE_RCOS:
        MakeRaisedCOS(dp, len);
        break;
    case WINDOW_TYPE_HAN:
        MakeHanningWIN(dp, len);
        break;
    case WINDOW_TYPE_HAM:
        MakeHammingWIN(dp, len);
        break;
    case WINDOW_TYPE_KAIS:
        MakeKaiserWIN(dp, len);
        break;
    case WINDOW_TYPE_NONE:
		MakeRectWIN(dp, len);
        break;
    case WINDOW_TYPE_ALOG:
        MakeAnalogicWIN(dp, len);
        break;
    case WINDOW_TYPE_WEED:
        MakeWeedonGauss(dp, len);
        break;
    case WINDOW_TYPE_BKHA:
        MakeBlackmanHarris(dp, len);
		break;
	case WINDOW_TYPE_BKMN:
		MakeBlackman(dp, len);
        break;
	case WINDOW_TYPE_NUTA:
		MakeNutall(dp, len);
		break;
	case WINDOW_TYPE_BKNT:
		MakeBlackNutall(dp, len);
		break;
	case WINDOW_TYPE_LANC:
		MakeLanczos(dp, len);
        break;
	case WINDOW_TYPE_RECT:
		MakeRectWIN(dp, len);
        break;
    default:
        break;
    }
	MultArray(array, dp, len);
    delete[] dp;
    return;
}


//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 30-JAN-2003                Richard B. Johnson
//
//  This performs a Regular Modified Cylindrical Bessel Function (Bessel I).
//
double SIG::BesselI0(double x)
{
   double denominator;
   double numerator;
   double z;

   if (fabs(x) < 1E-18)
   {
      return one;
   }
   else
   {
      z = x * x;
      numerator = (z* (z* (z* (z* (z* (z* (z* (z* (z* (z* (z* (z* (z*
                  (z* 0.210580722890567e-22  + 0.380715242345326e-19 ) +
                      0.479440257548300e-16) + 0.435125971262668e-13 ) +
                      0.300931127112960e-10) + 0.160224679395361e-7  ) +
                      0.654858370096785e-5)  + 0.202591084143397e-2  ) +
                      0.463076284721000e0)   + 0.754337328948189e2   ) +
                      0.830792541809429e4)   + 0.571661130563785e6   ) +
                      0.216415572361227e8)   + 0.356644482244025e9   ) +
                      0.144048298227235e10);
      denominator = (z*(z*(z-0.307646912682801e4)+
                      0.347626332405882e7)-0.144048298227235e10);
   }
   return -numerator/denominator;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 12-FEB-2003               Richard B. Johnson
//
//   This creates a Blackman window kernel.
//

#define DO_BLKM(o) \
    array[o] = a0 - a1 * cos(two * PI * (double)k/n)   \
                  + a2 * cos(cos(4.0 * PI * (double)k/n)) ; k++

void SIG::MakeBlackman(double *array, int len)
{
    double a0, a1, a2;
    double n = (double)(len - 1);
    int k;
/*
 *  Blackman coefficients.
 */
//    a0 = 0.42323;
	a0 = 0.454747;
    a1 = 0.49755;
    a2 = 0.07922;
    k = 0;
#ifdef UNROLL
    while(len >= 0x100)
    {
        len   -= 0x100;
        array += 0x100;
ALIGN;
        DO_BLKM(-0x100);
        DO_BLKM(-0x0ff);
        DO_BLKM(-0x0fe);
        DO_BLKM(-0x0fd);
        DO_BLKM(-0x0fc);
        DO_BLKM(-0x0fb);
        DO_BLKM(-0x0fa);
        DO_BLKM(-0x0f9);
        DO_BLKM(-0x0f8);
        DO_BLKM(-0x0f7);
        DO_BLKM(-0x0f6);
        DO_BLKM(-0x0f5);
        DO_BLKM(-0x0f4);
        DO_BLKM(-0x0f3);
        DO_BLKM(-0x0f2);
        DO_BLKM(-0x0f1);
        DO_BLKM(-0x0f0);
        DO_BLKM(-0x0ef);
        DO_BLKM(-0x0ee);
        DO_BLKM(-0x0ed);
        DO_BLKM(-0x0ec);
        DO_BLKM(-0x0eb);
        DO_BLKM(-0x0ea);
        DO_BLKM(-0x0e9);
        DO_BLKM(-0x0e8);
        DO_BLKM(-0x0e7);
        DO_BLKM(-0x0e6);
        DO_BLKM(-0x0e5);
        DO_BLKM(-0x0e4);
        DO_BLKM(-0x0e3);
        DO_BLKM(-0x0e2);
        DO_BLKM(-0x0e1);
        DO_BLKM(-0x0e0);
        DO_BLKM(-0x0df);
        DO_BLKM(-0x0de);
        DO_BLKM(-0x0dd);
        DO_BLKM(-0x0dc);
        DO_BLKM(-0x0db);
        DO_BLKM(-0x0da);
        DO_BLKM(-0x0d9);
        DO_BLKM(-0x0d8);
        DO_BLKM(-0x0d7);
        DO_BLKM(-0x0d6);
        DO_BLKM(-0x0d5);
        DO_BLKM(-0x0d4);
        DO_BLKM(-0x0d3);
        DO_BLKM(-0x0d2);
        DO_BLKM(-0x0d1);
        DO_BLKM(-0x0d0);
        DO_BLKM(-0x0cf);
        DO_BLKM(-0x0ce);
        DO_BLKM(-0x0cd);
        DO_BLKM(-0x0cc);
        DO_BLKM(-0x0cb);
        DO_BLKM(-0x0ca);
        DO_BLKM(-0x0c9);
        DO_BLKM(-0x0c8);
        DO_BLKM(-0x0c7);
        DO_BLKM(-0x0c6);
        DO_BLKM(-0x0c5);
        DO_BLKM(-0x0c4);
        DO_BLKM(-0x0c3);
        DO_BLKM(-0x0c2);
        DO_BLKM(-0x0c1);
        DO_BLKM(-0x0c0);
        DO_BLKM(-0x0bf);
        DO_BLKM(-0x0be);
        DO_BLKM(-0x0bd);
        DO_BLKM(-0x0bc);
        DO_BLKM(-0x0bb);
        DO_BLKM(-0x0ba);
        DO_BLKM(-0x0b9);
        DO_BLKM(-0x0b8);
        DO_BLKM(-0x0b7);
        DO_BLKM(-0x0b6);
        DO_BLKM(-0x0b5);
        DO_BLKM(-0x0b4);
        DO_BLKM(-0x0b3);
        DO_BLKM(-0x0b2);
        DO_BLKM(-0x0b1);
        DO_BLKM(-0x0b0);
        DO_BLKM(-0x0af);
        DO_BLKM(-0x0ae);
        DO_BLKM(-0x0ad);
        DO_BLKM(-0x0ac);
        DO_BLKM(-0x0ab);
        DO_BLKM(-0x0aa);
        DO_BLKM(-0x0a9);
        DO_BLKM(-0x0a8);
        DO_BLKM(-0x0a7);
        DO_BLKM(-0x0a6);
        DO_BLKM(-0x0a5);
        DO_BLKM(-0x0a4);
        DO_BLKM(-0x0a3);
        DO_BLKM(-0x0a2);
        DO_BLKM(-0x0a1);
        DO_BLKM(-0x0a0);
        DO_BLKM(-0x09f);
        DO_BLKM(-0x09e);
        DO_BLKM(-0x09d);
        DO_BLKM(-0x09c);
        DO_BLKM(-0x09b);
        DO_BLKM(-0x09a);
        DO_BLKM(-0x099);
        DO_BLKM(-0x098);
        DO_BLKM(-0x097);
        DO_BLKM(-0x096);
        DO_BLKM(-0x095);
        DO_BLKM(-0x094);
        DO_BLKM(-0x093);
        DO_BLKM(-0x092);
        DO_BLKM(-0x091);
        DO_BLKM(-0x090);
        DO_BLKM(-0x08f);
        DO_BLKM(-0x08e);
        DO_BLKM(-0x08d);
        DO_BLKM(-0x08c);
        DO_BLKM(-0x08b);
        DO_BLKM(-0x08a);
        DO_BLKM(-0x089);
        DO_BLKM(-0x088);
        DO_BLKM(-0x087);
        DO_BLKM(-0x086);
        DO_BLKM(-0x085);
        DO_BLKM(-0x084);
        DO_BLKM(-0x083);
        DO_BLKM(-0x082);
        DO_BLKM(-0x081);
        DO_BLKM(-0x080);
        DO_BLKM(-0x07f);
        DO_BLKM(-0x07e);
        DO_BLKM(-0x07d);
        DO_BLKM(-0x07c);
        DO_BLKM(-0x07b);
        DO_BLKM(-0x07a);
        DO_BLKM(-0x079);
        DO_BLKM(-0x078);
        DO_BLKM(-0x077);
        DO_BLKM(-0x076);
        DO_BLKM(-0x075);
        DO_BLKM(-0x074);
        DO_BLKM(-0x073);
        DO_BLKM(-0x072);
        DO_BLKM(-0x071);
        DO_BLKM(-0x070);
        DO_BLKM(-0x06f);
        DO_BLKM(-0x06e);
        DO_BLKM(-0x06d);
        DO_BLKM(-0x06c);
        DO_BLKM(-0x06b);
        DO_BLKM(-0x06a);
        DO_BLKM(-0x069);
        DO_BLKM(-0x068);
        DO_BLKM(-0x067);
        DO_BLKM(-0x066);
        DO_BLKM(-0x065);
        DO_BLKM(-0x064);
        DO_BLKM(-0x063);
        DO_BLKM(-0x062);
        DO_BLKM(-0x061);
        DO_BLKM(-0x060);
        DO_BLKM(-0x05f);
        DO_BLKM(-0x05e);
        DO_BLKM(-0x05d);
        DO_BLKM(-0x05c);
        DO_BLKM(-0x05b);
        DO_BLKM(-0x05a);
        DO_BLKM(-0x059);
        DO_BLKM(-0x058);
        DO_BLKM(-0x057);
        DO_BLKM(-0x056);
        DO_BLKM(-0x055);
        DO_BLKM(-0x054);
        DO_BLKM(-0x053);
        DO_BLKM(-0x052);
        DO_BLKM(-0x051);
        DO_BLKM(-0x050);
        DO_BLKM(-0x04f);
        DO_BLKM(-0x04e);
        DO_BLKM(-0x04d);
        DO_BLKM(-0x04c);
        DO_BLKM(-0x04b);
        DO_BLKM(-0x04a);
        DO_BLKM(-0x049);
        DO_BLKM(-0x048);
        DO_BLKM(-0x047);
        DO_BLKM(-0x046);
        DO_BLKM(-0x045);
        DO_BLKM(-0x044);
        DO_BLKM(-0x043);
        DO_BLKM(-0x042);
        DO_BLKM(-0x041);
        DO_BLKM(-0x040);
        DO_BLKM(-0x03f);
        DO_BLKM(-0x03e);
        DO_BLKM(-0x03d);
        DO_BLKM(-0x03c);
        DO_BLKM(-0x03b);
        DO_BLKM(-0x03a);
        DO_BLKM(-0x039);
        DO_BLKM(-0x038);
        DO_BLKM(-0x037);
        DO_BLKM(-0x036);
        DO_BLKM(-0x035);
        DO_BLKM(-0x034);
        DO_BLKM(-0x033);
        DO_BLKM(-0x032);
        DO_BLKM(-0x031);
        DO_BLKM(-0x030);
        DO_BLKM(-0x02f);
        DO_BLKM(-0x02e);
        DO_BLKM(-0x02d);
        DO_BLKM(-0x02c);
        DO_BLKM(-0x02b);
        DO_BLKM(-0x02a);
        DO_BLKM(-0x029);
        DO_BLKM(-0x028);
        DO_BLKM(-0x027);
        DO_BLKM(-0x026);
        DO_BLKM(-0x025);
        DO_BLKM(-0x024);
        DO_BLKM(-0x023);
        DO_BLKM(-0x022);
        DO_BLKM(-0x021);
        DO_BLKM(-0x020);
        DO_BLKM(-0x01f);
        DO_BLKM(-0x01e);
        DO_BLKM(-0x01d);
        DO_BLKM(-0x01c);
        DO_BLKM(-0x01b);
        DO_BLKM(-0x01a);
        DO_BLKM(-0x019);
        DO_BLKM(-0x018);
        DO_BLKM(-0x017);
        DO_BLKM(-0x016);
        DO_BLKM(-0x015);
        DO_BLKM(-0x014);
        DO_BLKM(-0x013);
        DO_BLKM(-0x012);
        DO_BLKM(-0x011);
        DO_BLKM(-0x010);
        DO_BLKM(-0x00f);
        DO_BLKM(-0x00e);
        DO_BLKM(-0x00d);
        DO_BLKM(-0x00c);
        DO_BLKM(-0x00b);
        DO_BLKM(-0x00a);
        DO_BLKM(-0x009);
        DO_BLKM(-0x008);
        DO_BLKM(-0x007);
        DO_BLKM(-0x006);
        DO_BLKM(-0x005);
        DO_BLKM(-0x004);
        DO_BLKM(-0x003);
        DO_BLKM(-0x002);
        DO_BLKM(-0x001);
    }
#endif
    while(len--)
    {
        *array++ = a0 - a1 * cos(two * PI * (double)k/n)
                      + a2 * cos(cos(4.0 * PI * (double)k/n)); k++;
    }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 12-FEB-2003               Richard B. Johnson
//
//   This creates a rectangular window kernel. It will likely
//   never be called since it is just an array of ones.
//

void SIG::MakeRectWIN(double *array, int len)
{
	PutConst(array, one, len);
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 12-FEB-2003               Richard B. Johnson
//
//   This creates a Blackman-Harris window kernel.
//

#define DO_BLKHRS(o) \
    array[o] = a0 - a1 * cos(two * PI * (double)k/n)   \
                  + a2 * cos(4.0 * PI * (double)k/n)   \
                  - a3 * cos(6.0 * PI * (double)k/n); k++

void SIG::MakeBlackmanHarris(double *array, int len)
{
    double a0, a1, a2, a3;
    double n = (double)(len - 1);
    int k;
/*
 *  Blackman coefficients. These sum to 1.0
 */
    a0 = 0.35875;
    a1 = 0.48829;
    a2 = 0.14128;
    a3 = 0.01168;
    k = 0;
#ifdef UNROLL
    while(len >= 0x100)
    {
        len   -= 0x100;
        array += 0x100;
ALIGN;
        DO_BLKHRS(-0x100);
        DO_BLKHRS(-0x0ff);
        DO_BLKHRS(-0x0fe);
        DO_BLKHRS(-0x0fd);
        DO_BLKHRS(-0x0fc);
        DO_BLKHRS(-0x0fb);
        DO_BLKHRS(-0x0fa);
        DO_BLKHRS(-0x0f9);
        DO_BLKHRS(-0x0f8);
        DO_BLKHRS(-0x0f7);
        DO_BLKHRS(-0x0f6);
        DO_BLKHRS(-0x0f5);
        DO_BLKHRS(-0x0f4);
        DO_BLKHRS(-0x0f3);
        DO_BLKHRS(-0x0f2);
        DO_BLKHRS(-0x0f1);
        DO_BLKHRS(-0x0f0);
        DO_BLKHRS(-0x0ef);
        DO_BLKHRS(-0x0ee);
        DO_BLKHRS(-0x0ed);
        DO_BLKHRS(-0x0ec);
        DO_BLKHRS(-0x0eb);
        DO_BLKHRS(-0x0ea);
        DO_BLKHRS(-0x0e9);
        DO_BLKHRS(-0x0e8);
        DO_BLKHRS(-0x0e7);
        DO_BLKHRS(-0x0e6);
        DO_BLKHRS(-0x0e5);
        DO_BLKHRS(-0x0e4);
        DO_BLKHRS(-0x0e3);
        DO_BLKHRS(-0x0e2);
        DO_BLKHRS(-0x0e1);
        DO_BLKHRS(-0x0e0);
        DO_BLKHRS(-0x0df);
        DO_BLKHRS(-0x0de);
        DO_BLKHRS(-0x0dd);
        DO_BLKHRS(-0x0dc);
        DO_BLKHRS(-0x0db);
        DO_BLKHRS(-0x0da);
        DO_BLKHRS(-0x0d9);
        DO_BLKHRS(-0x0d8);
        DO_BLKHRS(-0x0d7);
        DO_BLKHRS(-0x0d6);
        DO_BLKHRS(-0x0d5);
        DO_BLKHRS(-0x0d4);
        DO_BLKHRS(-0x0d3);
        DO_BLKHRS(-0x0d2);
        DO_BLKHRS(-0x0d1);
        DO_BLKHRS(-0x0d0);
        DO_BLKHRS(-0x0cf);
        DO_BLKHRS(-0x0ce);
        DO_BLKHRS(-0x0cd);
        DO_BLKHRS(-0x0cc);
        DO_BLKHRS(-0x0cb);
        DO_BLKHRS(-0x0ca);
        DO_BLKHRS(-0x0c9);
        DO_BLKHRS(-0x0c8);
        DO_BLKHRS(-0x0c7);
        DO_BLKHRS(-0x0c6);
        DO_BLKHRS(-0x0c5);
        DO_BLKHRS(-0x0c4);
        DO_BLKHRS(-0x0c3);
        DO_BLKHRS(-0x0c2);
        DO_BLKHRS(-0x0c1);
        DO_BLKHRS(-0x0c0);
        DO_BLKHRS(-0x0bf);
        DO_BLKHRS(-0x0be);
        DO_BLKHRS(-0x0bd);
        DO_BLKHRS(-0x0bc);
        DO_BLKHRS(-0x0bb);
        DO_BLKHRS(-0x0ba);
        DO_BLKHRS(-0x0b9);
        DO_BLKHRS(-0x0b8);
        DO_BLKHRS(-0x0b7);
        DO_BLKHRS(-0x0b6);
        DO_BLKHRS(-0x0b5);
        DO_BLKHRS(-0x0b4);
        DO_BLKHRS(-0x0b3);
        DO_BLKHRS(-0x0b2);
        DO_BLKHRS(-0x0b1);
        DO_BLKHRS(-0x0b0);
        DO_BLKHRS(-0x0af);
        DO_BLKHRS(-0x0ae);
        DO_BLKHRS(-0x0ad);
        DO_BLKHRS(-0x0ac);
        DO_BLKHRS(-0x0ab);
        DO_BLKHRS(-0x0aa);
        DO_BLKHRS(-0x0a9);
        DO_BLKHRS(-0x0a8);
        DO_BLKHRS(-0x0a7);
        DO_BLKHRS(-0x0a6);
        DO_BLKHRS(-0x0a5);
        DO_BLKHRS(-0x0a4);
        DO_BLKHRS(-0x0a3);
        DO_BLKHRS(-0x0a2);
        DO_BLKHRS(-0x0a1);
        DO_BLKHRS(-0x0a0);
        DO_BLKHRS(-0x09f);
        DO_BLKHRS(-0x09e);
        DO_BLKHRS(-0x09d);
        DO_BLKHRS(-0x09c);
        DO_BLKHRS(-0x09b);
        DO_BLKHRS(-0x09a);
        DO_BLKHRS(-0x099);
        DO_BLKHRS(-0x098);
        DO_BLKHRS(-0x097);
        DO_BLKHRS(-0x096);
        DO_BLKHRS(-0x095);
        DO_BLKHRS(-0x094);
        DO_BLKHRS(-0x093);
        DO_BLKHRS(-0x092);
        DO_BLKHRS(-0x091);
        DO_BLKHRS(-0x090);
        DO_BLKHRS(-0x08f);
        DO_BLKHRS(-0x08e);
        DO_BLKHRS(-0x08d);
        DO_BLKHRS(-0x08c);
        DO_BLKHRS(-0x08b);
        DO_BLKHRS(-0x08a);
        DO_BLKHRS(-0x089);
        DO_BLKHRS(-0x088);
        DO_BLKHRS(-0x087);
        DO_BLKHRS(-0x086);
        DO_BLKHRS(-0x085);
        DO_BLKHRS(-0x084);
        DO_BLKHRS(-0x083);
        DO_BLKHRS(-0x082);
        DO_BLKHRS(-0x081);
        DO_BLKHRS(-0x080);
        DO_BLKHRS(-0x07f);
        DO_BLKHRS(-0x07e);
        DO_BLKHRS(-0x07d);
        DO_BLKHRS(-0x07c);
        DO_BLKHRS(-0x07b);
        DO_BLKHRS(-0x07a);
        DO_BLKHRS(-0x079);
        DO_BLKHRS(-0x078);
        DO_BLKHRS(-0x077);
        DO_BLKHRS(-0x076);
        DO_BLKHRS(-0x075);
        DO_BLKHRS(-0x074);
        DO_BLKHRS(-0x073);
        DO_BLKHRS(-0x072);
        DO_BLKHRS(-0x071);
        DO_BLKHRS(-0x070);
        DO_BLKHRS(-0x06f);
        DO_BLKHRS(-0x06e);
        DO_BLKHRS(-0x06d);
        DO_BLKHRS(-0x06c);
        DO_BLKHRS(-0x06b);
        DO_BLKHRS(-0x06a);
        DO_BLKHRS(-0x069);
        DO_BLKHRS(-0x068);
        DO_BLKHRS(-0x067);
        DO_BLKHRS(-0x066);
        DO_BLKHRS(-0x065);
        DO_BLKHRS(-0x064);
        DO_BLKHRS(-0x063);
        DO_BLKHRS(-0x062);
        DO_BLKHRS(-0x061);
        DO_BLKHRS(-0x060);
        DO_BLKHRS(-0x05f);
        DO_BLKHRS(-0x05e);
        DO_BLKHRS(-0x05d);
        DO_BLKHRS(-0x05c);
        DO_BLKHRS(-0x05b);
        DO_BLKHRS(-0x05a);
        DO_BLKHRS(-0x059);
        DO_BLKHRS(-0x058);
        DO_BLKHRS(-0x057);
        DO_BLKHRS(-0x056);
        DO_BLKHRS(-0x055);
        DO_BLKHRS(-0x054);
        DO_BLKHRS(-0x053);
        DO_BLKHRS(-0x052);
        DO_BLKHRS(-0x051);
        DO_BLKHRS(-0x050);
        DO_BLKHRS(-0x04f);
        DO_BLKHRS(-0x04e);
        DO_BLKHRS(-0x04d);
        DO_BLKHRS(-0x04c);
        DO_BLKHRS(-0x04b);
        DO_BLKHRS(-0x04a);
        DO_BLKHRS(-0x049);
        DO_BLKHRS(-0x048);
        DO_BLKHRS(-0x047);
        DO_BLKHRS(-0x046);
        DO_BLKHRS(-0x045);
        DO_BLKHRS(-0x044);
        DO_BLKHRS(-0x043);
        DO_BLKHRS(-0x042);
        DO_BLKHRS(-0x041);
        DO_BLKHRS(-0x040);
        DO_BLKHRS(-0x03f);
        DO_BLKHRS(-0x03e);
        DO_BLKHRS(-0x03d);
        DO_BLKHRS(-0x03c);
        DO_BLKHRS(-0x03b);
        DO_BLKHRS(-0x03a);
        DO_BLKHRS(-0x039);
        DO_BLKHRS(-0x038);
        DO_BLKHRS(-0x037);
        DO_BLKHRS(-0x036);
        DO_BLKHRS(-0x035);
        DO_BLKHRS(-0x034);
        DO_BLKHRS(-0x033);
        DO_BLKHRS(-0x032);
        DO_BLKHRS(-0x031);
        DO_BLKHRS(-0x030);
        DO_BLKHRS(-0x02f);
        DO_BLKHRS(-0x02e);
        DO_BLKHRS(-0x02d);
        DO_BLKHRS(-0x02c);
        DO_BLKHRS(-0x02b);
        DO_BLKHRS(-0x02a);
        DO_BLKHRS(-0x029);
        DO_BLKHRS(-0x028);
        DO_BLKHRS(-0x027);
        DO_BLKHRS(-0x026);
        DO_BLKHRS(-0x025);
        DO_BLKHRS(-0x024);
        DO_BLKHRS(-0x023);
        DO_BLKHRS(-0x022);
        DO_BLKHRS(-0x021);
        DO_BLKHRS(-0x020);
        DO_BLKHRS(-0x01f);
        DO_BLKHRS(-0x01e);
        DO_BLKHRS(-0x01d);
        DO_BLKHRS(-0x01c);
        DO_BLKHRS(-0x01b);
        DO_BLKHRS(-0x01a);
        DO_BLKHRS(-0x019);
        DO_BLKHRS(-0x018);
        DO_BLKHRS(-0x017);
        DO_BLKHRS(-0x016);
        DO_BLKHRS(-0x015);
        DO_BLKHRS(-0x014);
        DO_BLKHRS(-0x013);
        DO_BLKHRS(-0x012);
        DO_BLKHRS(-0x011);
        DO_BLKHRS(-0x010);
        DO_BLKHRS(-0x00f);
        DO_BLKHRS(-0x00e);
        DO_BLKHRS(-0x00d);
        DO_BLKHRS(-0x00c);
        DO_BLKHRS(-0x00b);
        DO_BLKHRS(-0x00a);
        DO_BLKHRS(-0x009);
        DO_BLKHRS(-0x008);
        DO_BLKHRS(-0x007);
        DO_BLKHRS(-0x006);
        DO_BLKHRS(-0x005);
        DO_BLKHRS(-0x004);
        DO_BLKHRS(-0x003);
        DO_BLKHRS(-0x002);
        DO_BLKHRS(-0x001);
    }
#endif
    while(len--)
    {
        *array++ = a0 - a1 * cos(two * PI * (double)k/n)
                      + a2 * cos(4.0 * PI * (double)k/n)
                      - a3 * cos(6.0 * PI * (double)k/n); k++;
    }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 12-FEB-2003               Richard B. Johnson
//
//   This creates a Nutall window kernel.
//
//   Nuttall window, continuous first derivative
//

#define DO_NUTALL(o) \
    array[o] = a0 - a1 * cos(two * PI * (double)k/n)   \
                  + a2 * cos(4.0 * PI * (double)k/n)   \
                  - a3 * cos(6.0 * PI * (double)k/n); k++

void SIG::MakeNutall(double *array, int len)
{
    double a0, a1, a2, a3;
    double n = (double)(len - 1);
    int k;
/*
 *  Nutall coefficients.
 */
    a0 = 0.355768;
    a1 = 0.487396;
    a2 = 0.144232;
    a3 = 0.012604;
    k = 0;
#ifdef UNROLL
    while(len >= 0x100)
    {
        len   -= 0x100;
        array += 0x100;
ALIGN;
        DO_NUTALL(-0x100);
        DO_NUTALL(-0x0ff);
        DO_NUTALL(-0x0fe);
        DO_NUTALL(-0x0fd);
        DO_NUTALL(-0x0fc);
        DO_NUTALL(-0x0fb);
        DO_NUTALL(-0x0fa);
        DO_NUTALL(-0x0f9);
        DO_NUTALL(-0x0f8);
        DO_NUTALL(-0x0f7);
        DO_NUTALL(-0x0f6);
        DO_NUTALL(-0x0f5);
        DO_NUTALL(-0x0f4);
        DO_NUTALL(-0x0f3);
        DO_NUTALL(-0x0f2);
        DO_NUTALL(-0x0f1);
        DO_NUTALL(-0x0f0);
        DO_NUTALL(-0x0ef);
        DO_NUTALL(-0x0ee);
        DO_NUTALL(-0x0ed);
        DO_NUTALL(-0x0ec);
        DO_NUTALL(-0x0eb);
        DO_NUTALL(-0x0ea);
        DO_NUTALL(-0x0e9);
        DO_NUTALL(-0x0e8);
        DO_NUTALL(-0x0e7);
        DO_NUTALL(-0x0e6);
        DO_NUTALL(-0x0e5);
        DO_NUTALL(-0x0e4);
        DO_NUTALL(-0x0e3);
        DO_NUTALL(-0x0e2);
        DO_NUTALL(-0x0e1);
        DO_NUTALL(-0x0e0);
        DO_NUTALL(-0x0df);
        DO_NUTALL(-0x0de);
        DO_NUTALL(-0x0dd);
        DO_NUTALL(-0x0dc);
        DO_NUTALL(-0x0db);
        DO_NUTALL(-0x0da);
        DO_NUTALL(-0x0d9);
        DO_NUTALL(-0x0d8);
        DO_NUTALL(-0x0d7);
        DO_NUTALL(-0x0d6);
        DO_NUTALL(-0x0d5);
        DO_NUTALL(-0x0d4);
        DO_NUTALL(-0x0d3);
        DO_NUTALL(-0x0d2);
        DO_NUTALL(-0x0d1);
        DO_NUTALL(-0x0d0);
        DO_NUTALL(-0x0cf);
        DO_NUTALL(-0x0ce);
        DO_NUTALL(-0x0cd);
        DO_NUTALL(-0x0cc);
        DO_NUTALL(-0x0cb);
        DO_NUTALL(-0x0ca);
        DO_NUTALL(-0x0c9);
        DO_NUTALL(-0x0c8);
        DO_NUTALL(-0x0c7);
        DO_NUTALL(-0x0c6);
        DO_NUTALL(-0x0c5);
        DO_NUTALL(-0x0c4);
        DO_NUTALL(-0x0c3);
        DO_NUTALL(-0x0c2);
        DO_NUTALL(-0x0c1);
        DO_NUTALL(-0x0c0);
        DO_NUTALL(-0x0bf);
        DO_NUTALL(-0x0be);
        DO_NUTALL(-0x0bd);
        DO_NUTALL(-0x0bc);
        DO_NUTALL(-0x0bb);
        DO_NUTALL(-0x0ba);
        DO_NUTALL(-0x0b9);
        DO_NUTALL(-0x0b8);
        DO_NUTALL(-0x0b7);
        DO_NUTALL(-0x0b6);
        DO_NUTALL(-0x0b5);
        DO_NUTALL(-0x0b4);
        DO_NUTALL(-0x0b3);
        DO_NUTALL(-0x0b2);
        DO_NUTALL(-0x0b1);
        DO_NUTALL(-0x0b0);
        DO_NUTALL(-0x0af);
        DO_NUTALL(-0x0ae);
        DO_NUTALL(-0x0ad);
        DO_NUTALL(-0x0ac);
        DO_NUTALL(-0x0ab);
        DO_NUTALL(-0x0aa);
        DO_NUTALL(-0x0a9);
        DO_NUTALL(-0x0a8);
        DO_NUTALL(-0x0a7);
        DO_NUTALL(-0x0a6);
        DO_NUTALL(-0x0a5);
        DO_NUTALL(-0x0a4);
        DO_NUTALL(-0x0a3);
        DO_NUTALL(-0x0a2);
        DO_NUTALL(-0x0a1);
        DO_NUTALL(-0x0a0);
        DO_NUTALL(-0x09f);
        DO_NUTALL(-0x09e);
        DO_NUTALL(-0x09d);
        DO_NUTALL(-0x09c);
        DO_NUTALL(-0x09b);
        DO_NUTALL(-0x09a);
        DO_NUTALL(-0x099);
        DO_NUTALL(-0x098);
        DO_NUTALL(-0x097);
        DO_NUTALL(-0x096);
        DO_NUTALL(-0x095);
        DO_NUTALL(-0x094);
        DO_NUTALL(-0x093);
        DO_NUTALL(-0x092);
        DO_NUTALL(-0x091);
        DO_NUTALL(-0x090);
        DO_NUTALL(-0x08f);
        DO_NUTALL(-0x08e);
        DO_NUTALL(-0x08d);
        DO_NUTALL(-0x08c);
        DO_NUTALL(-0x08b);
        DO_NUTALL(-0x08a);
        DO_NUTALL(-0x089);
        DO_NUTALL(-0x088);
        DO_NUTALL(-0x087);
        DO_NUTALL(-0x086);
        DO_NUTALL(-0x085);
        DO_NUTALL(-0x084);
        DO_NUTALL(-0x083);
        DO_NUTALL(-0x082);
        DO_NUTALL(-0x081);
        DO_NUTALL(-0x080);
        DO_NUTALL(-0x07f);
        DO_NUTALL(-0x07e);
        DO_NUTALL(-0x07d);
        DO_NUTALL(-0x07c);
        DO_NUTALL(-0x07b);
        DO_NUTALL(-0x07a);
        DO_NUTALL(-0x079);
        DO_NUTALL(-0x078);
        DO_NUTALL(-0x077);
        DO_NUTALL(-0x076);
        DO_NUTALL(-0x075);
        DO_NUTALL(-0x074);
        DO_NUTALL(-0x073);
        DO_NUTALL(-0x072);
        DO_NUTALL(-0x071);
        DO_NUTALL(-0x070);
        DO_NUTALL(-0x06f);
        DO_NUTALL(-0x06e);
        DO_NUTALL(-0x06d);
        DO_NUTALL(-0x06c);
        DO_NUTALL(-0x06b);
        DO_NUTALL(-0x06a);
        DO_NUTALL(-0x069);
        DO_NUTALL(-0x068);
        DO_NUTALL(-0x067);
        DO_NUTALL(-0x066);
        DO_NUTALL(-0x065);
        DO_NUTALL(-0x064);
        DO_NUTALL(-0x063);
        DO_NUTALL(-0x062);
        DO_NUTALL(-0x061);
        DO_NUTALL(-0x060);
        DO_NUTALL(-0x05f);
        DO_NUTALL(-0x05e);
        DO_NUTALL(-0x05d);
        DO_NUTALL(-0x05c);
        DO_NUTALL(-0x05b);
        DO_NUTALL(-0x05a);
        DO_NUTALL(-0x059);
        DO_NUTALL(-0x058);
        DO_NUTALL(-0x057);
        DO_NUTALL(-0x056);
        DO_NUTALL(-0x055);
        DO_NUTALL(-0x054);
        DO_NUTALL(-0x053);
        DO_NUTALL(-0x052);
        DO_NUTALL(-0x051);
        DO_NUTALL(-0x050);
        DO_NUTALL(-0x04f);
        DO_NUTALL(-0x04e);
        DO_NUTALL(-0x04d);
        DO_NUTALL(-0x04c);
        DO_NUTALL(-0x04b);
        DO_NUTALL(-0x04a);
        DO_NUTALL(-0x049);
        DO_NUTALL(-0x048);
        DO_NUTALL(-0x047);
        DO_NUTALL(-0x046);
        DO_NUTALL(-0x045);
        DO_NUTALL(-0x044);
        DO_NUTALL(-0x043);
        DO_NUTALL(-0x042);
        DO_NUTALL(-0x041);
        DO_NUTALL(-0x040);
        DO_NUTALL(-0x03f);
        DO_NUTALL(-0x03e);
        DO_NUTALL(-0x03d);
        DO_NUTALL(-0x03c);
        DO_NUTALL(-0x03b);
        DO_NUTALL(-0x03a);
        DO_NUTALL(-0x039);
        DO_NUTALL(-0x038);
        DO_NUTALL(-0x037);
        DO_NUTALL(-0x036);
        DO_NUTALL(-0x035);
        DO_NUTALL(-0x034);
        DO_NUTALL(-0x033);
        DO_NUTALL(-0x032);
        DO_NUTALL(-0x031);
        DO_NUTALL(-0x030);
        DO_NUTALL(-0x02f);
        DO_NUTALL(-0x02e);
        DO_NUTALL(-0x02d);
        DO_NUTALL(-0x02c);
        DO_NUTALL(-0x02b);
        DO_NUTALL(-0x02a);
        DO_NUTALL(-0x029);
        DO_NUTALL(-0x028);
        DO_NUTALL(-0x027);
        DO_NUTALL(-0x026);
        DO_NUTALL(-0x025);
        DO_NUTALL(-0x024);
        DO_NUTALL(-0x023);
        DO_NUTALL(-0x022);
        DO_NUTALL(-0x021);
        DO_NUTALL(-0x020);
        DO_NUTALL(-0x01f);
        DO_NUTALL(-0x01e);
        DO_NUTALL(-0x01d);
        DO_NUTALL(-0x01c);
        DO_NUTALL(-0x01b);
        DO_NUTALL(-0x01a);
        DO_NUTALL(-0x019);
        DO_NUTALL(-0x018);
        DO_NUTALL(-0x017);
        DO_NUTALL(-0x016);
        DO_NUTALL(-0x015);
        DO_NUTALL(-0x014);
        DO_NUTALL(-0x013);
        DO_NUTALL(-0x012);
        DO_NUTALL(-0x011);
        DO_NUTALL(-0x010);
        DO_NUTALL(-0x00f);
        DO_NUTALL(-0x00e);
        DO_NUTALL(-0x00d);
        DO_NUTALL(-0x00c);
        DO_NUTALL(-0x00b);
        DO_NUTALL(-0x00a);
        DO_NUTALL(-0x009);
        DO_NUTALL(-0x008);
        DO_NUTALL(-0x007);
        DO_NUTALL(-0x006);
        DO_NUTALL(-0x005);
        DO_NUTALL(-0x004);
        DO_NUTALL(-0x003);
        DO_NUTALL(-0x002);
        DO_NUTALL(-0x001);
    }
#endif
    while(len--)
    {
        *array++ = a0 - a1 * cos(two * PI * (double)k/n)
                      + a2 * cos(4.0 * PI * (double)k/n)
                      - a3 * cos(6.0 * PI * (double)k/n); k++;
    }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 12-FEB-2003               Richard B. Johnson
//
//   This creates a Blackman-Nutall window kernel.
//
//

#define DO_BLKNUT(o) \
    array[o] = a0 - a1 * cos(two * PI * (double)k/n)   \
                  + a2 * cos(4.0 * PI * (double)k/n)   \
                  - a3 * cos(6.0 * PI * (double)k/n); k++

void SIG::MakeBlackNutall(double *array, int len)
{
    double a0, a1, a2, a3;
    double n = (double)(len - 1);
    int k;
/*
 *  Blackman-Nutall coefficients.
 */
    a0 = 0.3635819;
    a1 = 0.4891755;
    a2 = 0.1365995;
    a3 = 0.0106411;
    k = 0;
#ifdef UNROLL
    while(len >= 0x100)
    {
        len   -= 0x100;
        array += 0x100;
ALIGN;
        DO_BLKNUT(-0x100);
        DO_BLKNUT(-0x0ff);
        DO_BLKNUT(-0x0fe);
        DO_BLKNUT(-0x0fd);
        DO_BLKNUT(-0x0fc);
        DO_BLKNUT(-0x0fb);
        DO_BLKNUT(-0x0fa);
        DO_BLKNUT(-0x0f9);
        DO_BLKNUT(-0x0f8);
        DO_BLKNUT(-0x0f7);
        DO_BLKNUT(-0x0f6);
        DO_BLKNUT(-0x0f5);
        DO_BLKNUT(-0x0f4);
        DO_BLKNUT(-0x0f3);
        DO_BLKNUT(-0x0f2);
        DO_BLKNUT(-0x0f1);
        DO_BLKNUT(-0x0f0);
        DO_BLKNUT(-0x0ef);
        DO_BLKNUT(-0x0ee);
        DO_BLKNUT(-0x0ed);
        DO_BLKNUT(-0x0ec);
        DO_BLKNUT(-0x0eb);
        DO_BLKNUT(-0x0ea);
        DO_BLKNUT(-0x0e9);
        DO_BLKNUT(-0x0e8);
        DO_BLKNUT(-0x0e7);
        DO_BLKNUT(-0x0e6);
        DO_BLKNUT(-0x0e5);
        DO_BLKNUT(-0x0e4);
        DO_BLKNUT(-0x0e3);
        DO_BLKNUT(-0x0e2);
        DO_BLKNUT(-0x0e1);
        DO_BLKNUT(-0x0e0);
        DO_BLKNUT(-0x0df);
        DO_BLKNUT(-0x0de);
        DO_BLKNUT(-0x0dd);
        DO_BLKNUT(-0x0dc);
        DO_BLKNUT(-0x0db);
        DO_BLKNUT(-0x0da);
        DO_BLKNUT(-0x0d9);
        DO_BLKNUT(-0x0d8);
        DO_BLKNUT(-0x0d7);
        DO_BLKNUT(-0x0d6);
        DO_BLKNUT(-0x0d5);
        DO_BLKNUT(-0x0d4);
        DO_BLKNUT(-0x0d3);
        DO_BLKNUT(-0x0d2);
        DO_BLKNUT(-0x0d1);
        DO_BLKNUT(-0x0d0);
        DO_BLKNUT(-0x0cf);
        DO_BLKNUT(-0x0ce);
        DO_BLKNUT(-0x0cd);
        DO_BLKNUT(-0x0cc);
        DO_BLKNUT(-0x0cb);
        DO_BLKNUT(-0x0ca);
        DO_BLKNUT(-0x0c9);
        DO_BLKNUT(-0x0c8);
        DO_BLKNUT(-0x0c7);
        DO_BLKNUT(-0x0c6);
        DO_BLKNUT(-0x0c5);
        DO_BLKNUT(-0x0c4);
        DO_BLKNUT(-0x0c3);
        DO_BLKNUT(-0x0c2);
        DO_BLKNUT(-0x0c1);
        DO_BLKNUT(-0x0c0);
        DO_BLKNUT(-0x0bf);
        DO_BLKNUT(-0x0be);
        DO_BLKNUT(-0x0bd);
        DO_BLKNUT(-0x0bc);
        DO_BLKNUT(-0x0bb);
        DO_BLKNUT(-0x0ba);
        DO_BLKNUT(-0x0b9);
        DO_BLKNUT(-0x0b8);
        DO_BLKNUT(-0x0b7);
        DO_BLKNUT(-0x0b6);
        DO_BLKNUT(-0x0b5);
        DO_BLKNUT(-0x0b4);
        DO_BLKNUT(-0x0b3);
        DO_BLKNUT(-0x0b2);
        DO_BLKNUT(-0x0b1);
        DO_BLKNUT(-0x0b0);
        DO_BLKNUT(-0x0af);
        DO_BLKNUT(-0x0ae);
        DO_BLKNUT(-0x0ad);
        DO_BLKNUT(-0x0ac);
        DO_BLKNUT(-0x0ab);
        DO_BLKNUT(-0x0aa);
        DO_BLKNUT(-0x0a9);
        DO_BLKNUT(-0x0a8);
        DO_BLKNUT(-0x0a7);
        DO_BLKNUT(-0x0a6);
        DO_BLKNUT(-0x0a5);
        DO_BLKNUT(-0x0a4);
        DO_BLKNUT(-0x0a3);
        DO_BLKNUT(-0x0a2);
        DO_BLKNUT(-0x0a1);
        DO_BLKNUT(-0x0a0);
        DO_BLKNUT(-0x09f);
        DO_BLKNUT(-0x09e);
        DO_BLKNUT(-0x09d);
        DO_BLKNUT(-0x09c);
        DO_BLKNUT(-0x09b);
        DO_BLKNUT(-0x09a);
        DO_BLKNUT(-0x099);
        DO_BLKNUT(-0x098);
        DO_BLKNUT(-0x097);
        DO_BLKNUT(-0x096);
        DO_BLKNUT(-0x095);
        DO_BLKNUT(-0x094);
        DO_BLKNUT(-0x093);
        DO_BLKNUT(-0x092);
        DO_BLKNUT(-0x091);
        DO_BLKNUT(-0x090);
        DO_BLKNUT(-0x08f);
        DO_BLKNUT(-0x08e);
        DO_BLKNUT(-0x08d);
        DO_BLKNUT(-0x08c);
        DO_BLKNUT(-0x08b);
        DO_BLKNUT(-0x08a);
        DO_BLKNUT(-0x089);
        DO_BLKNUT(-0x088);
        DO_BLKNUT(-0x087);
        DO_BLKNUT(-0x086);
        DO_BLKNUT(-0x085);
        DO_BLKNUT(-0x084);
        DO_BLKNUT(-0x083);
        DO_BLKNUT(-0x082);
        DO_BLKNUT(-0x081);
        DO_BLKNUT(-0x080);
        DO_BLKNUT(-0x07f);
        DO_BLKNUT(-0x07e);
        DO_BLKNUT(-0x07d);
        DO_BLKNUT(-0x07c);
        DO_BLKNUT(-0x07b);
        DO_BLKNUT(-0x07a);
        DO_BLKNUT(-0x079);
        DO_BLKNUT(-0x078);
        DO_BLKNUT(-0x077);
        DO_BLKNUT(-0x076);
        DO_BLKNUT(-0x075);
        DO_BLKNUT(-0x074);
        DO_BLKNUT(-0x073);
        DO_BLKNUT(-0x072);
        DO_BLKNUT(-0x071);
        DO_BLKNUT(-0x070);
        DO_BLKNUT(-0x06f);
        DO_BLKNUT(-0x06e);
        DO_BLKNUT(-0x06d);
        DO_BLKNUT(-0x06c);
        DO_BLKNUT(-0x06b);
        DO_BLKNUT(-0x06a);
        DO_BLKNUT(-0x069);
        DO_BLKNUT(-0x068);
        DO_BLKNUT(-0x067);
        DO_BLKNUT(-0x066);
        DO_BLKNUT(-0x065);
        DO_BLKNUT(-0x064);
        DO_BLKNUT(-0x063);
        DO_BLKNUT(-0x062);
        DO_BLKNUT(-0x061);
        DO_BLKNUT(-0x060);
        DO_BLKNUT(-0x05f);
        DO_BLKNUT(-0x05e);
        DO_BLKNUT(-0x05d);
        DO_BLKNUT(-0x05c);
        DO_BLKNUT(-0x05b);
        DO_BLKNUT(-0x05a);
        DO_BLKNUT(-0x059);
        DO_BLKNUT(-0x058);
        DO_BLKNUT(-0x057);
        DO_BLKNUT(-0x056);
        DO_BLKNUT(-0x055);
        DO_BLKNUT(-0x054);
        DO_BLKNUT(-0x053);
        DO_BLKNUT(-0x052);
        DO_BLKNUT(-0x051);
        DO_BLKNUT(-0x050);
        DO_BLKNUT(-0x04f);
        DO_BLKNUT(-0x04e);
        DO_BLKNUT(-0x04d);
        DO_BLKNUT(-0x04c);
        DO_BLKNUT(-0x04b);
        DO_BLKNUT(-0x04a);
        DO_BLKNUT(-0x049);
        DO_BLKNUT(-0x048);
        DO_BLKNUT(-0x047);
        DO_BLKNUT(-0x046);
        DO_BLKNUT(-0x045);
        DO_BLKNUT(-0x044);
        DO_BLKNUT(-0x043);
        DO_BLKNUT(-0x042);
        DO_BLKNUT(-0x041);
        DO_BLKNUT(-0x040);
        DO_BLKNUT(-0x03f);
        DO_BLKNUT(-0x03e);
        DO_BLKNUT(-0x03d);
        DO_BLKNUT(-0x03c);
        DO_BLKNUT(-0x03b);
        DO_BLKNUT(-0x03a);
        DO_BLKNUT(-0x039);
        DO_BLKNUT(-0x038);
        DO_BLKNUT(-0x037);
        DO_BLKNUT(-0x036);
        DO_BLKNUT(-0x035);
        DO_BLKNUT(-0x034);
        DO_BLKNUT(-0x033);
        DO_BLKNUT(-0x032);
        DO_BLKNUT(-0x031);
        DO_BLKNUT(-0x030);
        DO_BLKNUT(-0x02f);
        DO_BLKNUT(-0x02e);
        DO_BLKNUT(-0x02d);
        DO_BLKNUT(-0x02c);
        DO_BLKNUT(-0x02b);
        DO_BLKNUT(-0x02a);
        DO_BLKNUT(-0x029);
        DO_BLKNUT(-0x028);
        DO_BLKNUT(-0x027);
        DO_BLKNUT(-0x026);
        DO_BLKNUT(-0x025);
        DO_BLKNUT(-0x024);
        DO_BLKNUT(-0x023);
        DO_BLKNUT(-0x022);
        DO_BLKNUT(-0x021);
        DO_BLKNUT(-0x020);
        DO_BLKNUT(-0x01f);
        DO_BLKNUT(-0x01e);
        DO_BLKNUT(-0x01d);
        DO_BLKNUT(-0x01c);
        DO_BLKNUT(-0x01b);
        DO_BLKNUT(-0x01a);
        DO_BLKNUT(-0x019);
        DO_BLKNUT(-0x018);
        DO_BLKNUT(-0x017);
        DO_BLKNUT(-0x016);
        DO_BLKNUT(-0x015);
        DO_BLKNUT(-0x014);
        DO_BLKNUT(-0x013);
        DO_BLKNUT(-0x012);
        DO_BLKNUT(-0x011);
        DO_BLKNUT(-0x010);
        DO_BLKNUT(-0x00f);
        DO_BLKNUT(-0x00e);
        DO_BLKNUT(-0x00d);
        DO_BLKNUT(-0x00c);
        DO_BLKNUT(-0x00b);
        DO_BLKNUT(-0x00a);
        DO_BLKNUT(-0x009);
        DO_BLKNUT(-0x008);
        DO_BLKNUT(-0x007);
        DO_BLKNUT(-0x006);
        DO_BLKNUT(-0x005);
        DO_BLKNUT(-0x004);
        DO_BLKNUT(-0x003);
        DO_BLKNUT(-0x002);
        DO_BLKNUT(-0x001);
    }
#endif
    while(len--)
    {
        *array++ = a0 - a1 * cos(two * PI * (double)k/n)
                      + a2 * cos(4.0 * PI * (double)k/n)
                      - a3 * cos(6.0 * PI * (double)k/n); k++;
    }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 12-FEB-2003               Richard B. Johnson
//
//   This creates a Lanczos window kernel.
//
//

#ifdef NOINLINE_SINC
double sinc(double x)
{
   x *= PI;
   return sin(x) / x;
}
#define SINC(x) sinc(x)
#else
#define SINC(x) (sin(PI * (x)) / (PI * (x)))
#endif

#define DO_LANCZ(o) \
    array[o] = SINC((2.0 * (double)k / n) - 1.0); k++


void SIG::MakeLanczos(double *array, int len)
{
    double n = (double)(len - 1);
    int k = 0;

#ifdef UNROLL
    while(len >= 0x100)
    {
        len   -= 0x100;
        array += 0x100;
ALIGN;
        DO_LANCZ(-0x100);
        DO_LANCZ(-0x0ff);
        DO_LANCZ(-0x0fe);
        DO_LANCZ(-0x0fd);
        DO_LANCZ(-0x0fc);
        DO_LANCZ(-0x0fb);
        DO_LANCZ(-0x0fa);
        DO_LANCZ(-0x0f9);
        DO_LANCZ(-0x0f8);
        DO_LANCZ(-0x0f7);
        DO_LANCZ(-0x0f6);
        DO_LANCZ(-0x0f5);
        DO_LANCZ(-0x0f4);
        DO_LANCZ(-0x0f3);
        DO_LANCZ(-0x0f2);
        DO_LANCZ(-0x0f1);
        DO_LANCZ(-0x0f0);
        DO_LANCZ(-0x0ef);
        DO_LANCZ(-0x0ee);
        DO_LANCZ(-0x0ed);
        DO_LANCZ(-0x0ec);
        DO_LANCZ(-0x0eb);
        DO_LANCZ(-0x0ea);
        DO_LANCZ(-0x0e9);
        DO_LANCZ(-0x0e8);
        DO_LANCZ(-0x0e7);
        DO_LANCZ(-0x0e6);
        DO_LANCZ(-0x0e5);
        DO_LANCZ(-0x0e4);
        DO_LANCZ(-0x0e3);
        DO_LANCZ(-0x0e2);
        DO_LANCZ(-0x0e1);
        DO_LANCZ(-0x0e0);
        DO_LANCZ(-0x0df);
        DO_LANCZ(-0x0de);
        DO_LANCZ(-0x0dd);
        DO_LANCZ(-0x0dc);
        DO_LANCZ(-0x0db);
        DO_LANCZ(-0x0da);
        DO_LANCZ(-0x0d9);
        DO_LANCZ(-0x0d8);
        DO_LANCZ(-0x0d7);
        DO_LANCZ(-0x0d6);
        DO_LANCZ(-0x0d5);
        DO_LANCZ(-0x0d4);
        DO_LANCZ(-0x0d3);
        DO_LANCZ(-0x0d2);
        DO_LANCZ(-0x0d1);
        DO_LANCZ(-0x0d0);
        DO_LANCZ(-0x0cf);
        DO_LANCZ(-0x0ce);
        DO_LANCZ(-0x0cd);
        DO_LANCZ(-0x0cc);
        DO_LANCZ(-0x0cb);
        DO_LANCZ(-0x0ca);
        DO_LANCZ(-0x0c9);
        DO_LANCZ(-0x0c8);
        DO_LANCZ(-0x0c7);
        DO_LANCZ(-0x0c6);
        DO_LANCZ(-0x0c5);
        DO_LANCZ(-0x0c4);
        DO_LANCZ(-0x0c3);
        DO_LANCZ(-0x0c2);
        DO_LANCZ(-0x0c1);
        DO_LANCZ(-0x0c0);
        DO_LANCZ(-0x0bf);
        DO_LANCZ(-0x0be);
        DO_LANCZ(-0x0bd);
        DO_LANCZ(-0x0bc);
        DO_LANCZ(-0x0bb);
        DO_LANCZ(-0x0ba);
        DO_LANCZ(-0x0b9);
        DO_LANCZ(-0x0b8);
        DO_LANCZ(-0x0b7);
        DO_LANCZ(-0x0b6);
        DO_LANCZ(-0x0b5);
        DO_LANCZ(-0x0b4);
        DO_LANCZ(-0x0b3);
        DO_LANCZ(-0x0b2);
        DO_LANCZ(-0x0b1);
        DO_LANCZ(-0x0b0);
        DO_LANCZ(-0x0af);
        DO_LANCZ(-0x0ae);
        DO_LANCZ(-0x0ad);
        DO_LANCZ(-0x0ac);
        DO_LANCZ(-0x0ab);
        DO_LANCZ(-0x0aa);
        DO_LANCZ(-0x0a9);
        DO_LANCZ(-0x0a8);
        DO_LANCZ(-0x0a7);
        DO_LANCZ(-0x0a6);
        DO_LANCZ(-0x0a5);
        DO_LANCZ(-0x0a4);
        DO_LANCZ(-0x0a3);
        DO_LANCZ(-0x0a2);
        DO_LANCZ(-0x0a1);
        DO_LANCZ(-0x0a0);
        DO_LANCZ(-0x09f);
        DO_LANCZ(-0x09e);
        DO_LANCZ(-0x09d);
        DO_LANCZ(-0x09c);
        DO_LANCZ(-0x09b);
        DO_LANCZ(-0x09a);
        DO_LANCZ(-0x099);
        DO_LANCZ(-0x098);
        DO_LANCZ(-0x097);
        DO_LANCZ(-0x096);
        DO_LANCZ(-0x095);
        DO_LANCZ(-0x094);
        DO_LANCZ(-0x093);
        DO_LANCZ(-0x092);
        DO_LANCZ(-0x091);
        DO_LANCZ(-0x090);
        DO_LANCZ(-0x08f);
        DO_LANCZ(-0x08e);
        DO_LANCZ(-0x08d);
        DO_LANCZ(-0x08c);
        DO_LANCZ(-0x08b);
        DO_LANCZ(-0x08a);
        DO_LANCZ(-0x089);
        DO_LANCZ(-0x088);
        DO_LANCZ(-0x087);
        DO_LANCZ(-0x086);
        DO_LANCZ(-0x085);
        DO_LANCZ(-0x084);
        DO_LANCZ(-0x083);
        DO_LANCZ(-0x082);
        DO_LANCZ(-0x081);
        DO_LANCZ(-0x080);
        DO_LANCZ(-0x07f);
        DO_LANCZ(-0x07e);
        DO_LANCZ(-0x07d);
        DO_LANCZ(-0x07c);
        DO_LANCZ(-0x07b);
        DO_LANCZ(-0x07a);
        DO_LANCZ(-0x079);
        DO_LANCZ(-0x078);
        DO_LANCZ(-0x077);
        DO_LANCZ(-0x076);
        DO_LANCZ(-0x075);
        DO_LANCZ(-0x074);
        DO_LANCZ(-0x073);
        DO_LANCZ(-0x072);
        DO_LANCZ(-0x071);
        DO_LANCZ(-0x070);
        DO_LANCZ(-0x06f);
        DO_LANCZ(-0x06e);
        DO_LANCZ(-0x06d);
        DO_LANCZ(-0x06c);
        DO_LANCZ(-0x06b);
        DO_LANCZ(-0x06a);
        DO_LANCZ(-0x069);
        DO_LANCZ(-0x068);
        DO_LANCZ(-0x067);
        DO_LANCZ(-0x066);
        DO_LANCZ(-0x065);
        DO_LANCZ(-0x064);
        DO_LANCZ(-0x063);
        DO_LANCZ(-0x062);
        DO_LANCZ(-0x061);
        DO_LANCZ(-0x060);
        DO_LANCZ(-0x05f);
        DO_LANCZ(-0x05e);
        DO_LANCZ(-0x05d);
        DO_LANCZ(-0x05c);
        DO_LANCZ(-0x05b);
        DO_LANCZ(-0x05a);
        DO_LANCZ(-0x059);
        DO_LANCZ(-0x058);
        DO_LANCZ(-0x057);
        DO_LANCZ(-0x056);
        DO_LANCZ(-0x055);
        DO_LANCZ(-0x054);
        DO_LANCZ(-0x053);
        DO_LANCZ(-0x052);
        DO_LANCZ(-0x051);
        DO_LANCZ(-0x050);
        DO_LANCZ(-0x04f);
        DO_LANCZ(-0x04e);
        DO_LANCZ(-0x04d);
        DO_LANCZ(-0x04c);
        DO_LANCZ(-0x04b);
        DO_LANCZ(-0x04a);
        DO_LANCZ(-0x049);
        DO_LANCZ(-0x048);
        DO_LANCZ(-0x047);
        DO_LANCZ(-0x046);
        DO_LANCZ(-0x045);
        DO_LANCZ(-0x044);
        DO_LANCZ(-0x043);
        DO_LANCZ(-0x042);
        DO_LANCZ(-0x041);
        DO_LANCZ(-0x040);
        DO_LANCZ(-0x03f);
        DO_LANCZ(-0x03e);
        DO_LANCZ(-0x03d);
        DO_LANCZ(-0x03c);
        DO_LANCZ(-0x03b);
        DO_LANCZ(-0x03a);
        DO_LANCZ(-0x039);
        DO_LANCZ(-0x038);
        DO_LANCZ(-0x037);
        DO_LANCZ(-0x036);
        DO_LANCZ(-0x035);
        DO_LANCZ(-0x034);
        DO_LANCZ(-0x033);
        DO_LANCZ(-0x032);
        DO_LANCZ(-0x031);
        DO_LANCZ(-0x030);
        DO_LANCZ(-0x02f);
        DO_LANCZ(-0x02e);
        DO_LANCZ(-0x02d);
        DO_LANCZ(-0x02c);
        DO_LANCZ(-0x02b);
        DO_LANCZ(-0x02a);
        DO_LANCZ(-0x029);
        DO_LANCZ(-0x028);
        DO_LANCZ(-0x027);
        DO_LANCZ(-0x026);
        DO_LANCZ(-0x025);
        DO_LANCZ(-0x024);
        DO_LANCZ(-0x023);
        DO_LANCZ(-0x022);
        DO_LANCZ(-0x021);
        DO_LANCZ(-0x020);
        DO_LANCZ(-0x01f);
        DO_LANCZ(-0x01e);
        DO_LANCZ(-0x01d);
        DO_LANCZ(-0x01c);
        DO_LANCZ(-0x01b);
        DO_LANCZ(-0x01a);
        DO_LANCZ(-0x019);
        DO_LANCZ(-0x018);
        DO_LANCZ(-0x017);
        DO_LANCZ(-0x016);
        DO_LANCZ(-0x015);
        DO_LANCZ(-0x014);
        DO_LANCZ(-0x013);
        DO_LANCZ(-0x012);
        DO_LANCZ(-0x011);
        DO_LANCZ(-0x010);
        DO_LANCZ(-0x00f);
        DO_LANCZ(-0x00e);
        DO_LANCZ(-0x00d);
        DO_LANCZ(-0x00c);
        DO_LANCZ(-0x00b);
        DO_LANCZ(-0x00a);
        DO_LANCZ(-0x009);
        DO_LANCZ(-0x008);
        DO_LANCZ(-0x007);
        DO_LANCZ(-0x006);
        DO_LANCZ(-0x005);
        DO_LANCZ(-0x004);
        DO_LANCZ(-0x003);
        DO_LANCZ(-0x002);
        DO_LANCZ(-0x001);
    }
#endif
    while(len--)
    {
        *array++ = SINC((2.0 * (double)k / n) - 1.0); k++;
    }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created  30-JAN-2003                Richard B. Johnson
//
//  This creates a Kaiser window kernel.
//

#ifdef UNROLL
#define SUM_AND_WRITE(o) \
  sum += BesselI0(pi * alpha * \
  sqrt(one - pow(4.0 * (double)i++ / (double)size - one, two))); \
  fp[o] = sum
#endif

void SIG::MakeKaiserWIN(double *array, int size)
{
    double alpha   = ALPHA;
    double sum = 0.0;
    double *fp, *bp, x, pi;
    int i, len;
    fp  = array;
    len = size/2;
    pi  = PI;
    i   = 0;
#ifdef UNROLL
    while(len >= 0x10)
    {
        fp  += 0x10;
        len -= 0x10;
        SUM_AND_WRITE(-0x10);
        SUM_AND_WRITE(-0x0f);
        SUM_AND_WRITE(-0x0e);
        SUM_AND_WRITE(-0x0d);
        SUM_AND_WRITE(-0x0c);
        SUM_AND_WRITE(-0x0b);
        SUM_AND_WRITE(-0x0a);
        SUM_AND_WRITE(-0x09);
        SUM_AND_WRITE(-0x08);
        SUM_AND_WRITE(-0x07);
        SUM_AND_WRITE(-0x06);
        SUM_AND_WRITE(-0x05);
        SUM_AND_WRITE(-0x04);
        SUM_AND_WRITE(-0x03);
        SUM_AND_WRITE(-0x02);
        SUM_AND_WRITE(-0x01);
    }
#endif
    while(len--)
    {
        sum += BesselI0(pi * alpha *
               sqrt(one - pow(4.0 * (double)i++ / (double)size - one, two)));
        *fp++ = sum;
    }
//
//  Need to add one more value to the normalization factor at size/2:
//
    sum += BesselI0(pi * alpha * sqrt(one - pow(4.0*(size/2)/size-one, 2)));
//
//  Normalize the window and fill in the righthand side of the window.
//
    fp  = array;              // Forward pointer
    bp  = array + (size-1);   // Backward pointer
    len = size/2;
    while(len--)
    {
        x = sqrt(*fp / sum);
        *fp++ = x;
        *bp-- = x;
    }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created FEB-02-2003               Richard B. Johnson
//
//   This creates the famous Dick Johnson window kernel.
//
//
void SIG::MakeAnalogicWIN(double *array, int len)
{
    double cf1, cf2, tau;
    int i;
    MakeKaiserWIN(array, len);
    tau = two * PI / ((double)len-1);
    cf1 = 0.50010;
    cf2 = one - cf1;
    i = 0;
#ifdef UNROLL
    while(len >= 0x10)
    {
        len   -= 0x10;
        array += 0x10;
        array[-0x10] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0f] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0e] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0d] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0c] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0b] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0a] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x09] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x08] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x07] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x06] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x05] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x04] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x03] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x02] *= cf1 - cf2 * cos((double)i++ * tau);
        array[-0x01] *= cf1 - cf2 * cos((double)i++ * tau);
    }
#endif
    while(len--)
        *array++ *= cf1 - cf2 * cos((double)i++ * tau);
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 29-JAN-2003                Richard B. Johnson
//
//   This creates a Hanning window  kernel.
//
//
void SIG::MakeHanningWIN(double *array, int len)
{
    double cf1, cf2, tau;
    int i;
    tau = two * PI / ((double)len-1);
    cf1 = 0.50;
    cf2 = 0.50;
    i = 0;
#ifdef UNROLL
    while(len >= 0x10)
    {
        len   -= 0x10;
        array += 0x10;
        array[-0x10] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0f] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0e] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0d] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0c] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0b] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0a] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x09] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x08] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x07] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x06] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x05] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x04] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x03] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x02] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x01] = cf1 - cf2 * cos((double)i++ * tau);
    }
#endif
    while(len--)
        *array++ = cf1 - cf2 * cos((double)i++ * tau);
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 29-JAN-2003                Richard B. Johnson
//
//   This creates a Hamming window kernel.
//
void SIG::MakeHammingWIN(double *array, int len)
{
    double cf1, cf2, tau;
    int i;
    tau = two * PI / ((double)len-1);
    cf1 = 0.54;
    cf2 = 0.46;
    i = 0;
#ifdef UNROLL
    while(len >= 0x10)
    {
        len   -= 0x10;
        array += 0x10;
        array[-0x10] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0f] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0e] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0d] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0c] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0b] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x0a] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x09] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x08] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x07] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x06] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x05] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x04] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x03] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x02] = cf1 - cf2 * cos((double)i++ * tau);
        array[-0x01] = cf1 - cf2 * cos((double)i++ * tau);
    }
#endif
    while(len--)
        *array++ = cf1 - cf2 * cos((double)i++ * tau);
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 28-JAN-2003                Richard B. Johnson
//
//  This makes a raised cosine  kernel. This is used to window
//  data.
//
void SIG::MakeRaisedCOS(double *array, int len)
{
    int i;
    double tau = two * PI / ((double)len-1);
    i = 0;
#ifdef UNROLL
    while(len >= 0x10)
    {
        array  += 0x10;
        len    -= 0x10;
        array[-0x10] = one - cos((double)i++ * tau);
        array[-0x0f] = one - cos((double)i++ * tau);
        array[-0x0e] = one - cos((double)i++ * tau);
        array[-0x0d] = one - cos((double)i++ * tau);
        array[-0x0c] = one - cos((double)i++ * tau);
        array[-0x0b] = one - cos((double)i++ * tau);
        array[-0x0a] = one - cos((double)i++ * tau);
        array[-0x09] = one - cos((double)i++ * tau);
        array[-0x08] = one - cos((double)i++ * tau);
        array[-0x07] = one - cos((double)i++ * tau);
        array[-0x06] = one - cos((double)i++ * tau);
        array[-0x05] = one - cos((double)i++ * tau);
        array[-0x04] = one - cos((double)i++ * tau);
        array[-0x03] = one - cos((double)i++ * tau);
        array[-0x02] = one - cos((double)i++ * tau);
        array[-0x01] = one - cos((double)i++ * tau);
    }
#endif
    while(len--)
        *array++ = one - cos((double)i++ * tau);
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 05-MAR-2003                       Richard B. Johnson
//  The creates the Weedon/Gauss window kernel.
//

#define DO_WEED(a) n = (double) i++ - d; buf[a] = exp(n * n * k)

void SIG::MakeWeedonGauss(double *buf, int len)
{
    int i = 0;
    double d, k, n;
    d = (double) len;
    k = (-250.0 * 0.4605) / (d * d);
    d /= two;
#ifdef UNROLL
    while(len >= 0x10)
    {
        len -= 0x10;
        buf += 0x10;
        DO_WEED(-0x10);
        DO_WEED(-0x0f);
        DO_WEED(-0x0e);
        DO_WEED(-0x0d);
        DO_WEED(-0x0c);
        DO_WEED(-0x0b);
        DO_WEED(-0x0a);
        DO_WEED(-0x09);
        DO_WEED(-0x08);
        DO_WEED(-0x07);
        DO_WEED(-0x06);
        DO_WEED(-0x05);
        DO_WEED(-0x04);
        DO_WEED(-0x03);
        DO_WEED(-0x02);
        DO_WEED(-0x01);
    }
#endif
    while(len--)
    {
        n = (double) i++ - d;
        *buf++ = exp(n * n * k);
    }
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 15-FEB-2003                Richard B. Johnson
//
//   This puts a constant value into every element in an array.
//
void SIG::PutConst(double *outbuf, double val, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        len    -= 0x100;
        outbuf += 0x100;
        outbuf[-0x100] = val;
        outbuf[-0x0ff] = val;
        outbuf[-0x0fe] = val;
        outbuf[-0x0fd] = val;
        outbuf[-0x0fc] = val;
        outbuf[-0x0fb] = val;
        outbuf[-0x0fa] = val;
        outbuf[-0x0f9] = val;
        outbuf[-0x0f8] = val;
        outbuf[-0x0f7] = val;
        outbuf[-0x0f6] = val;
        outbuf[-0x0f5] = val;
        outbuf[-0x0f4] = val;
        outbuf[-0x0f3] = val;
        outbuf[-0x0f2] = val;
        outbuf[-0x0f1] = val;
        outbuf[-0x0f0] = val;
        outbuf[-0x0ef] = val;
        outbuf[-0x0ee] = val;
        outbuf[-0x0ed] = val;
        outbuf[-0x0ec] = val;
        outbuf[-0x0eb] = val;
        outbuf[-0x0ea] = val;
        outbuf[-0x0e9] = val;
        outbuf[-0x0e8] = val;
        outbuf[-0x0e7] = val;
        outbuf[-0x0e6] = val;
        outbuf[-0x0e5] = val;
        outbuf[-0x0e4] = val;
        outbuf[-0x0e3] = val;
        outbuf[-0x0e2] = val;
        outbuf[-0x0e1] = val;
        outbuf[-0x0e0] = val;
        outbuf[-0x0df] = val;
        outbuf[-0x0de] = val;
        outbuf[-0x0dd] = val;
        outbuf[-0x0dc] = val;
        outbuf[-0x0db] = val;
        outbuf[-0x0da] = val;
        outbuf[-0x0d9] = val;
        outbuf[-0x0d8] = val;
        outbuf[-0x0d7] = val;
        outbuf[-0x0d6] = val;
        outbuf[-0x0d5] = val;
        outbuf[-0x0d4] = val;
        outbuf[-0x0d3] = val;
        outbuf[-0x0d2] = val;
        outbuf[-0x0d1] = val;
        outbuf[-0x0d0] = val;
        outbuf[-0x0cf] = val;
        outbuf[-0x0ce] = val;
        outbuf[-0x0cd] = val;
        outbuf[-0x0cc] = val;
        outbuf[-0x0cb] = val;
        outbuf[-0x0ca] = val;
        outbuf[-0x0c9] = val;
        outbuf[-0x0c8] = val;
        outbuf[-0x0c7] = val;
        outbuf[-0x0c6] = val;
        outbuf[-0x0c5] = val;
        outbuf[-0x0c4] = val;
        outbuf[-0x0c3] = val;
        outbuf[-0x0c2] = val;
        outbuf[-0x0c1] = val;
        outbuf[-0x0c0] = val;
        outbuf[-0x0bf] = val;
        outbuf[-0x0be] = val;
        outbuf[-0x0bd] = val;
        outbuf[-0x0bc] = val;
        outbuf[-0x0bb] = val;
        outbuf[-0x0ba] = val;
        outbuf[-0x0b9] = val;
        outbuf[-0x0b8] = val;
        outbuf[-0x0b7] = val;
        outbuf[-0x0b6] = val;
        outbuf[-0x0b5] = val;
        outbuf[-0x0b4] = val;
        outbuf[-0x0b3] = val;
        outbuf[-0x0b2] = val;
        outbuf[-0x0b1] = val;
        outbuf[-0x0b0] = val;
        outbuf[-0x0af] = val;
        outbuf[-0x0ae] = val;
        outbuf[-0x0ad] = val;
        outbuf[-0x0ac] = val;
        outbuf[-0x0ab] = val;
        outbuf[-0x0aa] = val;
        outbuf[-0x0a9] = val;
        outbuf[-0x0a8] = val;
        outbuf[-0x0a7] = val;
        outbuf[-0x0a6] = val;
        outbuf[-0x0a5] = val;
        outbuf[-0x0a4] = val;
        outbuf[-0x0a3] = val;
        outbuf[-0x0a2] = val;
        outbuf[-0x0a1] = val;
        outbuf[-0x0a0] = val;
        outbuf[-0x09f] = val;
        outbuf[-0x09e] = val;
        outbuf[-0x09d] = val;
        outbuf[-0x09c] = val;
        outbuf[-0x09b] = val;
        outbuf[-0x09a] = val;
        outbuf[-0x099] = val;
        outbuf[-0x098] = val;
        outbuf[-0x097] = val;
        outbuf[-0x096] = val;
        outbuf[-0x095] = val;
        outbuf[-0x094] = val;
        outbuf[-0x093] = val;
        outbuf[-0x092] = val;
        outbuf[-0x091] = val;
        outbuf[-0x090] = val;
        outbuf[-0x08f] = val;
        outbuf[-0x08e] = val;
        outbuf[-0x08d] = val;
        outbuf[-0x08c] = val;
        outbuf[-0x08b] = val;
        outbuf[-0x08a] = val;
        outbuf[-0x089] = val;
        outbuf[-0x088] = val;
        outbuf[-0x087] = val;
        outbuf[-0x086] = val;
        outbuf[-0x085] = val;
        outbuf[-0x084] = val;
        outbuf[-0x083] = val;
        outbuf[-0x082] = val;
        outbuf[-0x081] = val;
        outbuf[-0x080] = val;
        outbuf[-0x07f] = val;
        outbuf[-0x07e] = val;
        outbuf[-0x07d] = val;
        outbuf[-0x07c] = val;
        outbuf[-0x07b] = val;
        outbuf[-0x07a] = val;
        outbuf[-0x079] = val;
        outbuf[-0x078] = val;
        outbuf[-0x077] = val;
        outbuf[-0x076] = val;
        outbuf[-0x075] = val;
        outbuf[-0x074] = val;
        outbuf[-0x073] = val;
        outbuf[-0x072] = val;
        outbuf[-0x071] = val;
        outbuf[-0x070] = val;
        outbuf[-0x06f] = val;
        outbuf[-0x06e] = val;
        outbuf[-0x06d] = val;
        outbuf[-0x06c] = val;
        outbuf[-0x06b] = val;
        outbuf[-0x06a] = val;
        outbuf[-0x069] = val;
        outbuf[-0x068] = val;
        outbuf[-0x067] = val;
        outbuf[-0x066] = val;
        outbuf[-0x065] = val;
        outbuf[-0x064] = val;
        outbuf[-0x063] = val;
        outbuf[-0x062] = val;
        outbuf[-0x061] = val;
        outbuf[-0x060] = val;
        outbuf[-0x05f] = val;
        outbuf[-0x05e] = val;
        outbuf[-0x05d] = val;
        outbuf[-0x05c] = val;
        outbuf[-0x05b] = val;
        outbuf[-0x05a] = val;
        outbuf[-0x059] = val;
        outbuf[-0x058] = val;
        outbuf[-0x057] = val;
        outbuf[-0x056] = val;
        outbuf[-0x055] = val;
        outbuf[-0x054] = val;
        outbuf[-0x053] = val;
        outbuf[-0x052] = val;
        outbuf[-0x051] = val;
        outbuf[-0x050] = val;
        outbuf[-0x04f] = val;
        outbuf[-0x04e] = val;
        outbuf[-0x04d] = val;
        outbuf[-0x04c] = val;
        outbuf[-0x04b] = val;
        outbuf[-0x04a] = val;
        outbuf[-0x049] = val;
        outbuf[-0x048] = val;
        outbuf[-0x047] = val;
        outbuf[-0x046] = val;
        outbuf[-0x045] = val;
        outbuf[-0x044] = val;
        outbuf[-0x043] = val;
        outbuf[-0x042] = val;
        outbuf[-0x041] = val;
        outbuf[-0x040] = val;
        outbuf[-0x03f] = val;
        outbuf[-0x03e] = val;
        outbuf[-0x03d] = val;
        outbuf[-0x03c] = val;
        outbuf[-0x03b] = val;
        outbuf[-0x03a] = val;
        outbuf[-0x039] = val;
        outbuf[-0x038] = val;
        outbuf[-0x037] = val;
        outbuf[-0x036] = val;
        outbuf[-0x035] = val;
        outbuf[-0x034] = val;
        outbuf[-0x033] = val;
        outbuf[-0x032] = val;
        outbuf[-0x031] = val;
        outbuf[-0x030] = val;
        outbuf[-0x02f] = val;
        outbuf[-0x02e] = val;
        outbuf[-0x02d] = val;
        outbuf[-0x02c] = val;
        outbuf[-0x02b] = val;
        outbuf[-0x02a] = val;
        outbuf[-0x029] = val;
        outbuf[-0x028] = val;
        outbuf[-0x027] = val;
        outbuf[-0x026] = val;
        outbuf[-0x025] = val;
        outbuf[-0x024] = val;
        outbuf[-0x023] = val;
        outbuf[-0x022] = val;
        outbuf[-0x021] = val;
        outbuf[-0x020] = val;
        outbuf[-0x01f] = val;
        outbuf[-0x01e] = val;
        outbuf[-0x01d] = val;
        outbuf[-0x01c] = val;
        outbuf[-0x01b] = val;
        outbuf[-0x01a] = val;
        outbuf[-0x019] = val;
        outbuf[-0x018] = val;
        outbuf[-0x017] = val;
        outbuf[-0x016] = val;
        outbuf[-0x015] = val;
        outbuf[-0x014] = val;
        outbuf[-0x013] = val;
        outbuf[-0x012] = val;
        outbuf[-0x011] = val;
        outbuf[-0x010] = val;
        outbuf[-0x00f] = val;
        outbuf[-0x00e] = val;
        outbuf[-0x00d] = val;
        outbuf[-0x00c] = val;
        outbuf[-0x00b] = val;
        outbuf[-0x00a] = val;
        outbuf[-0x009] = val;
        outbuf[-0x008] = val;
        outbuf[-0x007] = val;
        outbuf[-0x006] = val;
        outbuf[-0x005] = val;
        outbuf[-0x004] = val;
        outbuf[-0x003] = val;
        outbuf[-0x002] = val;
        outbuf[-0x001] = val;
    }
    while(len >= 0x10)
    {
        len    -= 0x10;
        outbuf += 0x10;
        outbuf[-0x10] = val;
        outbuf[-0x0f] = val;
        outbuf[-0x0e] = val;
        outbuf[-0x0d] = val;
        outbuf[-0x0c] = val;
        outbuf[-0x0b] = val;
        outbuf[-0x0a] = val;
        outbuf[-0x09] = val;
        outbuf[-0x08] = val;
        outbuf[-0x07] = val;
        outbuf[-0x06] = val;
        outbuf[-0x05] = val;
        outbuf[-0x04] = val;
        outbuf[-0x03] = val;
        outbuf[-0x02] = val;
        outbuf[-0x01] = val;
    }
#endif
    while (len--)
        *outbuf++ = val;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002               Richard B. Johnson
//
//   This adds a constant to every element in the array. This is typically
//   used to correct offset.
//
void SIG::AddConst(double *outbuf, double val, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        outbuf += 0x100;
        len    -= 0x100;
ALIGN;
        outbuf[-0x100] += val;
        outbuf[-0x0ff] += val;
        outbuf[-0x0fe] += val;
        outbuf[-0x0fd] += val;
        outbuf[-0x0fc] += val;
        outbuf[-0x0fb] += val;
        outbuf[-0x0fa] += val;
        outbuf[-0x0f9] += val;
        outbuf[-0x0f8] += val;
        outbuf[-0x0f7] += val;
        outbuf[-0x0f6] += val;
        outbuf[-0x0f5] += val;
        outbuf[-0x0f4] += val;
        outbuf[-0x0f3] += val;
        outbuf[-0x0f2] += val;
        outbuf[-0x0f1] += val;
        outbuf[-0x0f0] += val;
        outbuf[-0x0ef] += val;
        outbuf[-0x0ee] += val;
        outbuf[-0x0ed] += val;
        outbuf[-0x0ec] += val;
        outbuf[-0x0eb] += val;
        outbuf[-0x0ea] += val;
        outbuf[-0x0e9] += val;
        outbuf[-0x0e8] += val;
        outbuf[-0x0e7] += val;
        outbuf[-0x0e6] += val;
        outbuf[-0x0e5] += val;
        outbuf[-0x0e4] += val;
        outbuf[-0x0e3] += val;
        outbuf[-0x0e2] += val;
        outbuf[-0x0e1] += val;
        outbuf[-0x0e0] += val;
        outbuf[-0x0df] += val;
        outbuf[-0x0de] += val;
        outbuf[-0x0dd] += val;
        outbuf[-0x0dc] += val;
        outbuf[-0x0db] += val;
        outbuf[-0x0da] += val;
        outbuf[-0x0d9] += val;
        outbuf[-0x0d8] += val;
        outbuf[-0x0d7] += val;
        outbuf[-0x0d6] += val;
        outbuf[-0x0d5] += val;
        outbuf[-0x0d4] += val;
        outbuf[-0x0d3] += val;
        outbuf[-0x0d2] += val;
        outbuf[-0x0d1] += val;
        outbuf[-0x0d0] += val;
        outbuf[-0x0cf] += val;
        outbuf[-0x0ce] += val;
        outbuf[-0x0cd] += val;
        outbuf[-0x0cc] += val;
        outbuf[-0x0cb] += val;
        outbuf[-0x0ca] += val;
        outbuf[-0x0c9] += val;
        outbuf[-0x0c8] += val;
        outbuf[-0x0c7] += val;
        outbuf[-0x0c6] += val;
        outbuf[-0x0c5] += val;
        outbuf[-0x0c4] += val;
        outbuf[-0x0c3] += val;
        outbuf[-0x0c2] += val;
        outbuf[-0x0c1] += val;
        outbuf[-0x0c0] += val;
        outbuf[-0x0bf] += val;
        outbuf[-0x0be] += val;
        outbuf[-0x0bd] += val;
        outbuf[-0x0bc] += val;
        outbuf[-0x0bb] += val;
        outbuf[-0x0ba] += val;
        outbuf[-0x0b9] += val;
        outbuf[-0x0b8] += val;
        outbuf[-0x0b7] += val;
        outbuf[-0x0b6] += val;
        outbuf[-0x0b5] += val;
        outbuf[-0x0b4] += val;
        outbuf[-0x0b3] += val;
        outbuf[-0x0b2] += val;
        outbuf[-0x0b1] += val;
        outbuf[-0x0b0] += val;
        outbuf[-0x0af] += val;
        outbuf[-0x0ae] += val;
        outbuf[-0x0ad] += val;
        outbuf[-0x0ac] += val;
        outbuf[-0x0ab] += val;
        outbuf[-0x0aa] += val;
        outbuf[-0x0a9] += val;
        outbuf[-0x0a8] += val;
        outbuf[-0x0a7] += val;
        outbuf[-0x0a6] += val;
        outbuf[-0x0a5] += val;
        outbuf[-0x0a4] += val;
        outbuf[-0x0a3] += val;
        outbuf[-0x0a2] += val;
        outbuf[-0x0a1] += val;
        outbuf[-0x0a0] += val;
        outbuf[-0x09f] += val;
        outbuf[-0x09e] += val;
        outbuf[-0x09d] += val;
        outbuf[-0x09c] += val;
        outbuf[-0x09b] += val;
        outbuf[-0x09a] += val;
        outbuf[-0x099] += val;
        outbuf[-0x098] += val;
        outbuf[-0x097] += val;
        outbuf[-0x096] += val;
        outbuf[-0x095] += val;
        outbuf[-0x094] += val;
        outbuf[-0x093] += val;
        outbuf[-0x092] += val;
        outbuf[-0x091] += val;
        outbuf[-0x090] += val;
        outbuf[-0x08f] += val;
        outbuf[-0x08e] += val;
        outbuf[-0x08d] += val;
        outbuf[-0x08c] += val;
        outbuf[-0x08b] += val;
        outbuf[-0x08a] += val;
        outbuf[-0x089] += val;
        outbuf[-0x088] += val;
        outbuf[-0x087] += val;
        outbuf[-0x086] += val;
        outbuf[-0x085] += val;
        outbuf[-0x084] += val;
        outbuf[-0x083] += val;
        outbuf[-0x082] += val;
        outbuf[-0x081] += val;
        outbuf[-0x080] += val;
        outbuf[-0x07f] += val;
        outbuf[-0x07e] += val;
        outbuf[-0x07d] += val;
        outbuf[-0x07c] += val;
        outbuf[-0x07b] += val;
        outbuf[-0x07a] += val;
        outbuf[-0x079] += val;
        outbuf[-0x078] += val;
        outbuf[-0x077] += val;
        outbuf[-0x076] += val;
        outbuf[-0x075] += val;
        outbuf[-0x074] += val;
        outbuf[-0x073] += val;
        outbuf[-0x072] += val;
        outbuf[-0x071] += val;
        outbuf[-0x070] += val;
        outbuf[-0x06f] += val;
        outbuf[-0x06e] += val;
        outbuf[-0x06d] += val;
        outbuf[-0x06c] += val;
        outbuf[-0x06b] += val;
        outbuf[-0x06a] += val;
        outbuf[-0x069] += val;
        outbuf[-0x068] += val;
        outbuf[-0x067] += val;
        outbuf[-0x066] += val;
        outbuf[-0x065] += val;
        outbuf[-0x064] += val;
        outbuf[-0x063] += val;
        outbuf[-0x062] += val;
        outbuf[-0x061] += val;
        outbuf[-0x060] += val;
        outbuf[-0x05f] += val;
        outbuf[-0x05e] += val;
        outbuf[-0x05d] += val;
        outbuf[-0x05c] += val;
        outbuf[-0x05b] += val;
        outbuf[-0x05a] += val;
        outbuf[-0x059] += val;
        outbuf[-0x058] += val;
        outbuf[-0x057] += val;
        outbuf[-0x056] += val;
        outbuf[-0x055] += val;
        outbuf[-0x054] += val;
        outbuf[-0x053] += val;
        outbuf[-0x052] += val;
        outbuf[-0x051] += val;
        outbuf[-0x050] += val;
        outbuf[-0x04f] += val;
        outbuf[-0x04e] += val;
        outbuf[-0x04d] += val;
        outbuf[-0x04c] += val;
        outbuf[-0x04b] += val;
        outbuf[-0x04a] += val;
        outbuf[-0x049] += val;
        outbuf[-0x048] += val;
        outbuf[-0x047] += val;
        outbuf[-0x046] += val;
        outbuf[-0x045] += val;
        outbuf[-0x044] += val;
        outbuf[-0x043] += val;
        outbuf[-0x042] += val;
        outbuf[-0x041] += val;
        outbuf[-0x040] += val;
        outbuf[-0x03f] += val;
        outbuf[-0x03e] += val;
        outbuf[-0x03d] += val;
        outbuf[-0x03c] += val;
        outbuf[-0x03b] += val;
        outbuf[-0x03a] += val;
        outbuf[-0x039] += val;
        outbuf[-0x038] += val;
        outbuf[-0x037] += val;
        outbuf[-0x036] += val;
        outbuf[-0x035] += val;
        outbuf[-0x034] += val;
        outbuf[-0x033] += val;
        outbuf[-0x032] += val;
        outbuf[-0x031] += val;
        outbuf[-0x030] += val;
        outbuf[-0x02f] += val;
        outbuf[-0x02e] += val;
        outbuf[-0x02d] += val;
        outbuf[-0x02c] += val;
        outbuf[-0x02b] += val;
        outbuf[-0x02a] += val;
        outbuf[-0x029] += val;
        outbuf[-0x028] += val;
        outbuf[-0x027] += val;
        outbuf[-0x026] += val;
        outbuf[-0x025] += val;
        outbuf[-0x024] += val;
        outbuf[-0x023] += val;
        outbuf[-0x022] += val;
        outbuf[-0x021] += val;
        outbuf[-0x020] += val;
        outbuf[-0x01f] += val;
        outbuf[-0x01e] += val;
        outbuf[-0x01d] += val;
        outbuf[-0x01c] += val;
        outbuf[-0x01b] += val;
        outbuf[-0x01a] += val;
        outbuf[-0x019] += val;
        outbuf[-0x018] += val;
        outbuf[-0x017] += val;
        outbuf[-0x016] += val;
        outbuf[-0x015] += val;
        outbuf[-0x014] += val;
        outbuf[-0x013] += val;
        outbuf[-0x012] += val;
        outbuf[-0x011] += val;
        outbuf[-0x010] += val;
        outbuf[-0x00f] += val;
        outbuf[-0x00e] += val;
        outbuf[-0x00d] += val;
        outbuf[-0x00c] += val;
        outbuf[-0x00b] += val;
        outbuf[-0x00a] += val;
        outbuf[-0x009] += val;
        outbuf[-0x008] += val;
        outbuf[-0x007] += val;
        outbuf[-0x006] += val;
        outbuf[-0x005] += val;
        outbuf[-0x004] += val;
        outbuf[-0x003] += val;
        outbuf[-0x002] += val;
        outbuf[-0x001] += val;
    }
    while(len >= 0x10)
    {
        outbuf += 0x10;
        len    -= 0x10;
        outbuf[-0x10] += val;
        outbuf[-0x0f] += val;
        outbuf[-0x0e] += val;
        outbuf[-0x0d] += val;
        outbuf[-0x0c] += val;
        outbuf[-0x0b] += val;
        outbuf[-0x0a] += val;
        outbuf[-0x09] += val;
        outbuf[-0x08] += val;
        outbuf[-0x07] += val;
        outbuf[-0x06] += val;
        outbuf[-0x05] += val;
        outbuf[-0x04] += val;
        outbuf[-0x03] += val;
        outbuf[-0x02] += val;
        outbuf[-0x01] += val;
    }
#endif
    while(len--)
        *outbuf++ += val;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002                   Richard B. Johnson
//
//   This subtracts a constant from every element in the array. This is
//   typically used to correct offset.
//
void SIG::SubConst(double *outbuf, double val, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        outbuf += 0x100;
        len    -= 0x100;
ALIGN;
        outbuf[-0x100] -= val;
        outbuf[-0x0ff] -= val;
        outbuf[-0x0fe] -= val;
        outbuf[-0x0fd] -= val;
        outbuf[-0x0fc] -= val;
        outbuf[-0x0fb] -= val;
        outbuf[-0x0fa] -= val;
        outbuf[-0x0f9] -= val;
        outbuf[-0x0f8] -= val;
        outbuf[-0x0f7] -= val;
        outbuf[-0x0f6] -= val;
        outbuf[-0x0f5] -= val;
        outbuf[-0x0f4] -= val;
        outbuf[-0x0f3] -= val;
        outbuf[-0x0f2] -= val;
        outbuf[-0x0f1] -= val;
        outbuf[-0x0f0] -= val;
        outbuf[-0x0ef] -= val;
        outbuf[-0x0ee] -= val;
        outbuf[-0x0ed] -= val;
        outbuf[-0x0ec] -= val;
        outbuf[-0x0eb] -= val;
        outbuf[-0x0ea] -= val;
        outbuf[-0x0e9] -= val;
        outbuf[-0x0e8] -= val;
        outbuf[-0x0e7] -= val;
        outbuf[-0x0e6] -= val;
        outbuf[-0x0e5] -= val;
        outbuf[-0x0e4] -= val;
        outbuf[-0x0e3] -= val;
        outbuf[-0x0e2] -= val;
        outbuf[-0x0e1] -= val;
        outbuf[-0x0e0] -= val;
        outbuf[-0x0df] -= val;
        outbuf[-0x0de] -= val;
        outbuf[-0x0dd] -= val;
        outbuf[-0x0dc] -= val;
        outbuf[-0x0db] -= val;
        outbuf[-0x0da] -= val;
        outbuf[-0x0d9] -= val;
        outbuf[-0x0d8] -= val;
        outbuf[-0x0d7] -= val;
        outbuf[-0x0d6] -= val;
        outbuf[-0x0d5] -= val;
        outbuf[-0x0d4] -= val;
        outbuf[-0x0d3] -= val;
        outbuf[-0x0d2] -= val;
        outbuf[-0x0d1] -= val;
        outbuf[-0x0d0] -= val;
        outbuf[-0x0cf] -= val;
        outbuf[-0x0ce] -= val;
        outbuf[-0x0cd] -= val;
        outbuf[-0x0cc] -= val;
        outbuf[-0x0cb] -= val;
        outbuf[-0x0ca] -= val;
        outbuf[-0x0c9] -= val;
        outbuf[-0x0c8] -= val;
        outbuf[-0x0c7] -= val;
        outbuf[-0x0c6] -= val;
        outbuf[-0x0c5] -= val;
        outbuf[-0x0c4] -= val;
        outbuf[-0x0c3] -= val;
        outbuf[-0x0c2] -= val;
        outbuf[-0x0c1] -= val;
        outbuf[-0x0c0] -= val;
        outbuf[-0x0bf] -= val;
        outbuf[-0x0be] -= val;
        outbuf[-0x0bd] -= val;
        outbuf[-0x0bc] -= val;
        outbuf[-0x0bb] -= val;
        outbuf[-0x0ba] -= val;
        outbuf[-0x0b9] -= val;
        outbuf[-0x0b8] -= val;
        outbuf[-0x0b7] -= val;
        outbuf[-0x0b6] -= val;
        outbuf[-0x0b5] -= val;
        outbuf[-0x0b4] -= val;
        outbuf[-0x0b3] -= val;
        outbuf[-0x0b2] -= val;
        outbuf[-0x0b1] -= val;
        outbuf[-0x0b0] -= val;
        outbuf[-0x0af] -= val;
        outbuf[-0x0ae] -= val;
        outbuf[-0x0ad] -= val;
        outbuf[-0x0ac] -= val;
        outbuf[-0x0ab] -= val;
        outbuf[-0x0aa] -= val;
        outbuf[-0x0a9] -= val;
        outbuf[-0x0a8] -= val;
        outbuf[-0x0a7] -= val;
        outbuf[-0x0a6] -= val;
        outbuf[-0x0a5] -= val;
        outbuf[-0x0a4] -= val;
        outbuf[-0x0a3] -= val;
        outbuf[-0x0a2] -= val;
        outbuf[-0x0a1] -= val;
        outbuf[-0x0a0] -= val;
        outbuf[-0x09f] -= val;
        outbuf[-0x09e] -= val;
        outbuf[-0x09d] -= val;
        outbuf[-0x09c] -= val;
        outbuf[-0x09b] -= val;
        outbuf[-0x09a] -= val;
        outbuf[-0x099] -= val;
        outbuf[-0x098] -= val;
        outbuf[-0x097] -= val;
        outbuf[-0x096] -= val;
        outbuf[-0x095] -= val;
        outbuf[-0x094] -= val;
        outbuf[-0x093] -= val;
        outbuf[-0x092] -= val;
        outbuf[-0x091] -= val;
        outbuf[-0x090] -= val;
        outbuf[-0x08f] -= val;
        outbuf[-0x08e] -= val;
        outbuf[-0x08d] -= val;
        outbuf[-0x08c] -= val;
        outbuf[-0x08b] -= val;
        outbuf[-0x08a] -= val;
        outbuf[-0x089] -= val;
        outbuf[-0x088] -= val;
        outbuf[-0x087] -= val;
        outbuf[-0x086] -= val;
        outbuf[-0x085] -= val;
        outbuf[-0x084] -= val;
        outbuf[-0x083] -= val;
        outbuf[-0x082] -= val;
        outbuf[-0x081] -= val;
        outbuf[-0x080] -= val;
        outbuf[-0x07f] -= val;
        outbuf[-0x07e] -= val;
        outbuf[-0x07d] -= val;
        outbuf[-0x07c] -= val;
        outbuf[-0x07b] -= val;
        outbuf[-0x07a] -= val;
        outbuf[-0x079] -= val;
        outbuf[-0x078] -= val;
        outbuf[-0x077] -= val;
        outbuf[-0x076] -= val;
        outbuf[-0x075] -= val;
        outbuf[-0x074] -= val;
        outbuf[-0x073] -= val;
        outbuf[-0x072] -= val;
        outbuf[-0x071] -= val;
        outbuf[-0x070] -= val;
        outbuf[-0x06f] -= val;
        outbuf[-0x06e] -= val;
        outbuf[-0x06d] -= val;
        outbuf[-0x06c] -= val;
        outbuf[-0x06b] -= val;
        outbuf[-0x06a] -= val;
        outbuf[-0x069] -= val;
        outbuf[-0x068] -= val;
        outbuf[-0x067] -= val;
        outbuf[-0x066] -= val;
        outbuf[-0x065] -= val;
        outbuf[-0x064] -= val;
        outbuf[-0x063] -= val;
        outbuf[-0x062] -= val;
        outbuf[-0x061] -= val;
        outbuf[-0x060] -= val;
        outbuf[-0x05f] -= val;
        outbuf[-0x05e] -= val;
        outbuf[-0x05d] -= val;
        outbuf[-0x05c] -= val;
        outbuf[-0x05b] -= val;
        outbuf[-0x05a] -= val;
        outbuf[-0x059] -= val;
        outbuf[-0x058] -= val;
        outbuf[-0x057] -= val;
        outbuf[-0x056] -= val;
        outbuf[-0x055] -= val;
        outbuf[-0x054] -= val;
        outbuf[-0x053] -= val;
        outbuf[-0x052] -= val;
        outbuf[-0x051] -= val;
        outbuf[-0x050] -= val;
        outbuf[-0x04f] -= val;
        outbuf[-0x04e] -= val;
        outbuf[-0x04d] -= val;
        outbuf[-0x04c] -= val;
        outbuf[-0x04b] -= val;
        outbuf[-0x04a] -= val;
        outbuf[-0x049] -= val;
        outbuf[-0x048] -= val;
        outbuf[-0x047] -= val;
        outbuf[-0x046] -= val;
        outbuf[-0x045] -= val;
        outbuf[-0x044] -= val;
        outbuf[-0x043] -= val;
        outbuf[-0x042] -= val;
        outbuf[-0x041] -= val;
        outbuf[-0x040] -= val;
        outbuf[-0x03f] -= val;
        outbuf[-0x03e] -= val;
        outbuf[-0x03d] -= val;
        outbuf[-0x03c] -= val;
        outbuf[-0x03b] -= val;
        outbuf[-0x03a] -= val;
        outbuf[-0x039] -= val;
        outbuf[-0x038] -= val;
        outbuf[-0x037] -= val;
        outbuf[-0x036] -= val;
        outbuf[-0x035] -= val;
        outbuf[-0x034] -= val;
        outbuf[-0x033] -= val;
        outbuf[-0x032] -= val;
        outbuf[-0x031] -= val;
        outbuf[-0x030] -= val;
        outbuf[-0x02f] -= val;
        outbuf[-0x02e] -= val;
        outbuf[-0x02d] -= val;
        outbuf[-0x02c] -= val;
        outbuf[-0x02b] -= val;
        outbuf[-0x02a] -= val;
        outbuf[-0x029] -= val;
        outbuf[-0x028] -= val;
        outbuf[-0x027] -= val;
        outbuf[-0x026] -= val;
        outbuf[-0x025] -= val;
        outbuf[-0x024] -= val;
        outbuf[-0x023] -= val;
        outbuf[-0x022] -= val;
        outbuf[-0x021] -= val;
        outbuf[-0x020] -= val;
        outbuf[-0x01f] -= val;
        outbuf[-0x01e] -= val;
        outbuf[-0x01d] -= val;
        outbuf[-0x01c] -= val;
        outbuf[-0x01b] -= val;
        outbuf[-0x01a] -= val;
        outbuf[-0x019] -= val;
        outbuf[-0x018] -= val;
        outbuf[-0x017] -= val;
        outbuf[-0x016] -= val;
        outbuf[-0x015] -= val;
        outbuf[-0x014] -= val;
        outbuf[-0x013] -= val;
        outbuf[-0x012] -= val;
        outbuf[-0x011] -= val;
        outbuf[-0x010] -= val;
        outbuf[-0x00f] -= val;
        outbuf[-0x00e] -= val;
        outbuf[-0x00d] -= val;
        outbuf[-0x00c] -= val;
        outbuf[-0x00b] -= val;
        outbuf[-0x00a] -= val;
        outbuf[-0x009] -= val;
        outbuf[-0x008] -= val;
        outbuf[-0x007] -= val;
        outbuf[-0x006] -= val;
        outbuf[-0x005] -= val;
        outbuf[-0x004] -= val;
        outbuf[-0x003] -= val;
        outbuf[-0x002] -= val;
        outbuf[-0x001] -= val;
    }
    while(len >= 0x10)
    {
        outbuf += 0x10;
        len    -= 0x10;
        outbuf[-0x10] -= val;
        outbuf[-0x0f] -= val;
        outbuf[-0x0e] -= val;
        outbuf[-0x0d] -= val;
        outbuf[-0x0c] -= val;
        outbuf[-0x0b] -= val;
        outbuf[-0x0a] -= val;
        outbuf[-0x09] -= val;
        outbuf[-0x08] -= val;
        outbuf[-0x07] -= val;
        outbuf[-0x06] -= val;
        outbuf[-0x05] -= val;
        outbuf[-0x04] -= val;
        outbuf[-0x03] -= val;
        outbuf[-0x02] -= val;
        outbuf[-0x01] -= val;
    }
#endif
    while(len--)
        *outbuf++ -= val;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002                  Richard B. Johnson
//
//   This multiplies every element in an array by a constant. It is
//   typically used to correct gain.
//
void SIG::MulConst(double *outbuf, double val, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        outbuf += 0x100;
        len    -= 0x100;
ALIGN;
        outbuf[-0x100] *= val;
        outbuf[-0x0ff] *= val;
        outbuf[-0x0fe] *= val;
        outbuf[-0x0fd] *= val;
        outbuf[-0x0fc] *= val;
        outbuf[-0x0fb] *= val;
        outbuf[-0x0fa] *= val;
        outbuf[-0x0f9] *= val;
        outbuf[-0x0f8] *= val;
        outbuf[-0x0f7] *= val;
        outbuf[-0x0f6] *= val;
        outbuf[-0x0f5] *= val;
        outbuf[-0x0f4] *= val;
        outbuf[-0x0f3] *= val;
        outbuf[-0x0f2] *= val;
        outbuf[-0x0f1] *= val;
        outbuf[-0x0f0] *= val;
        outbuf[-0x0ef] *= val;
        outbuf[-0x0ee] *= val;
        outbuf[-0x0ed] *= val;
        outbuf[-0x0ec] *= val;
        outbuf[-0x0eb] *= val;
        outbuf[-0x0ea] *= val;
        outbuf[-0x0e9] *= val;
        outbuf[-0x0e8] *= val;
        outbuf[-0x0e7] *= val;
        outbuf[-0x0e6] *= val;
        outbuf[-0x0e5] *= val;
        outbuf[-0x0e4] *= val;
        outbuf[-0x0e3] *= val;
        outbuf[-0x0e2] *= val;
        outbuf[-0x0e1] *= val;
        outbuf[-0x0e0] *= val;
        outbuf[-0x0df] *= val;
        outbuf[-0x0de] *= val;
        outbuf[-0x0dd] *= val;
        outbuf[-0x0dc] *= val;
        outbuf[-0x0db] *= val;
        outbuf[-0x0da] *= val;
        outbuf[-0x0d9] *= val;
        outbuf[-0x0d8] *= val;
        outbuf[-0x0d7] *= val;
        outbuf[-0x0d6] *= val;
        outbuf[-0x0d5] *= val;
        outbuf[-0x0d4] *= val;
        outbuf[-0x0d3] *= val;
        outbuf[-0x0d2] *= val;
        outbuf[-0x0d1] *= val;
        outbuf[-0x0d0] *= val;
        outbuf[-0x0cf] *= val;
        outbuf[-0x0ce] *= val;
        outbuf[-0x0cd] *= val;
        outbuf[-0x0cc] *= val;
        outbuf[-0x0cb] *= val;
        outbuf[-0x0ca] *= val;
        outbuf[-0x0c9] *= val;
        outbuf[-0x0c8] *= val;
        outbuf[-0x0c7] *= val;
        outbuf[-0x0c6] *= val;
        outbuf[-0x0c5] *= val;
        outbuf[-0x0c4] *= val;
        outbuf[-0x0c3] *= val;
        outbuf[-0x0c2] *= val;
        outbuf[-0x0c1] *= val;
        outbuf[-0x0c0] *= val;
        outbuf[-0x0bf] *= val;
        outbuf[-0x0be] *= val;
        outbuf[-0x0bd] *= val;
        outbuf[-0x0bc] *= val;
        outbuf[-0x0bb] *= val;
        outbuf[-0x0ba] *= val;
        outbuf[-0x0b9] *= val;
        outbuf[-0x0b8] *= val;
        outbuf[-0x0b7] *= val;
        outbuf[-0x0b6] *= val;
        outbuf[-0x0b5] *= val;
        outbuf[-0x0b4] *= val;
        outbuf[-0x0b3] *= val;
        outbuf[-0x0b2] *= val;
        outbuf[-0x0b1] *= val;
        outbuf[-0x0b0] *= val;
        outbuf[-0x0af] *= val;
        outbuf[-0x0ae] *= val;
        outbuf[-0x0ad] *= val;
        outbuf[-0x0ac] *= val;
        outbuf[-0x0ab] *= val;
        outbuf[-0x0aa] *= val;
        outbuf[-0x0a9] *= val;
        outbuf[-0x0a8] *= val;
        outbuf[-0x0a7] *= val;
        outbuf[-0x0a6] *= val;
        outbuf[-0x0a5] *= val;
        outbuf[-0x0a4] *= val;
        outbuf[-0x0a3] *= val;
        outbuf[-0x0a2] *= val;
        outbuf[-0x0a1] *= val;
        outbuf[-0x0a0] *= val;
        outbuf[-0x09f] *= val;
        outbuf[-0x09e] *= val;
        outbuf[-0x09d] *= val;
        outbuf[-0x09c] *= val;
        outbuf[-0x09b] *= val;
        outbuf[-0x09a] *= val;
        outbuf[-0x099] *= val;
        outbuf[-0x098] *= val;
        outbuf[-0x097] *= val;
        outbuf[-0x096] *= val;
        outbuf[-0x095] *= val;
        outbuf[-0x094] *= val;
        outbuf[-0x093] *= val;
        outbuf[-0x092] *= val;
        outbuf[-0x091] *= val;
        outbuf[-0x090] *= val;
        outbuf[-0x08f] *= val;
        outbuf[-0x08e] *= val;
        outbuf[-0x08d] *= val;
        outbuf[-0x08c] *= val;
        outbuf[-0x08b] *= val;
        outbuf[-0x08a] *= val;
        outbuf[-0x089] *= val;
        outbuf[-0x088] *= val;
        outbuf[-0x087] *= val;
        outbuf[-0x086] *= val;
        outbuf[-0x085] *= val;
        outbuf[-0x084] *= val;
        outbuf[-0x083] *= val;
        outbuf[-0x082] *= val;
        outbuf[-0x081] *= val;
        outbuf[-0x080] *= val;
        outbuf[-0x07f] *= val;
        outbuf[-0x07e] *= val;
        outbuf[-0x07d] *= val;
        outbuf[-0x07c] *= val;
        outbuf[-0x07b] *= val;
        outbuf[-0x07a] *= val;
        outbuf[-0x079] *= val;
        outbuf[-0x078] *= val;
        outbuf[-0x077] *= val;
        outbuf[-0x076] *= val;
        outbuf[-0x075] *= val;
        outbuf[-0x074] *= val;
        outbuf[-0x073] *= val;
        outbuf[-0x072] *= val;
        outbuf[-0x071] *= val;
        outbuf[-0x070] *= val;
        outbuf[-0x06f] *= val;
        outbuf[-0x06e] *= val;
        outbuf[-0x06d] *= val;
        outbuf[-0x06c] *= val;
        outbuf[-0x06b] *= val;
        outbuf[-0x06a] *= val;
        outbuf[-0x069] *= val;
        outbuf[-0x068] *= val;
        outbuf[-0x067] *= val;
        outbuf[-0x066] *= val;
        outbuf[-0x065] *= val;
        outbuf[-0x064] *= val;
        outbuf[-0x063] *= val;
        outbuf[-0x062] *= val;
        outbuf[-0x061] *= val;
        outbuf[-0x060] *= val;
        outbuf[-0x05f] *= val;
        outbuf[-0x05e] *= val;
        outbuf[-0x05d] *= val;
        outbuf[-0x05c] *= val;
        outbuf[-0x05b] *= val;
        outbuf[-0x05a] *= val;
        outbuf[-0x059] *= val;
        outbuf[-0x058] *= val;
        outbuf[-0x057] *= val;
        outbuf[-0x056] *= val;
        outbuf[-0x055] *= val;
        outbuf[-0x054] *= val;
        outbuf[-0x053] *= val;
        outbuf[-0x052] *= val;
        outbuf[-0x051] *= val;
        outbuf[-0x050] *= val;
        outbuf[-0x04f] *= val;
        outbuf[-0x04e] *= val;
        outbuf[-0x04d] *= val;
        outbuf[-0x04c] *= val;
        outbuf[-0x04b] *= val;
        outbuf[-0x04a] *= val;
        outbuf[-0x049] *= val;
        outbuf[-0x048] *= val;
        outbuf[-0x047] *= val;
        outbuf[-0x046] *= val;
        outbuf[-0x045] *= val;
        outbuf[-0x044] *= val;
        outbuf[-0x043] *= val;
        outbuf[-0x042] *= val;
        outbuf[-0x041] *= val;
        outbuf[-0x040] *= val;
        outbuf[-0x03f] *= val;
        outbuf[-0x03e] *= val;
        outbuf[-0x03d] *= val;
        outbuf[-0x03c] *= val;
        outbuf[-0x03b] *= val;
        outbuf[-0x03a] *= val;
        outbuf[-0x039] *= val;
        outbuf[-0x038] *= val;
        outbuf[-0x037] *= val;
        outbuf[-0x036] *= val;
        outbuf[-0x035] *= val;
        outbuf[-0x034] *= val;
        outbuf[-0x033] *= val;
        outbuf[-0x032] *= val;
        outbuf[-0x031] *= val;
        outbuf[-0x030] *= val;
        outbuf[-0x02f] *= val;
        outbuf[-0x02e] *= val;
        outbuf[-0x02d] *= val;
        outbuf[-0x02c] *= val;
        outbuf[-0x02b] *= val;
        outbuf[-0x02a] *= val;
        outbuf[-0x029] *= val;
        outbuf[-0x028] *= val;
        outbuf[-0x027] *= val;
        outbuf[-0x026] *= val;
        outbuf[-0x025] *= val;
        outbuf[-0x024] *= val;
        outbuf[-0x023] *= val;
        outbuf[-0x022] *= val;
        outbuf[-0x021] *= val;
        outbuf[-0x020] *= val;
        outbuf[-0x01f] *= val;
        outbuf[-0x01e] *= val;
        outbuf[-0x01d] *= val;
        outbuf[-0x01c] *= val;
        outbuf[-0x01b] *= val;
        outbuf[-0x01a] *= val;
        outbuf[-0x019] *= val;
        outbuf[-0x018] *= val;
        outbuf[-0x017] *= val;
        outbuf[-0x016] *= val;
        outbuf[-0x015] *= val;
        outbuf[-0x014] *= val;
        outbuf[-0x013] *= val;
        outbuf[-0x012] *= val;
        outbuf[-0x011] *= val;
        outbuf[-0x010] *= val;
        outbuf[-0x00f] *= val;
        outbuf[-0x00e] *= val;
        outbuf[-0x00d] *= val;
        outbuf[-0x00c] *= val;
        outbuf[-0x00b] *= val;
        outbuf[-0x00a] *= val;
        outbuf[-0x009] *= val;
        outbuf[-0x008] *= val;
        outbuf[-0x007] *= val;
        outbuf[-0x006] *= val;
        outbuf[-0x005] *= val;
        outbuf[-0x004] *= val;
        outbuf[-0x003] *= val;
        outbuf[-0x002] *= val;
        outbuf[-0x001] *= val;
    }
    while(len >= 0x10)
    {
        outbuf += 0x10;
        len    -= 0x10;
        outbuf[-0x10] *= val;
        outbuf[-0x0f] *= val;
        outbuf[-0x0e] *= val;
        outbuf[-0x0d] *= val;
        outbuf[-0x0c] *= val;
        outbuf[-0x0b] *= val;
        outbuf[-0x0a] *= val;
        outbuf[-0x09] *= val;
        outbuf[-0x08] *= val;
        outbuf[-0x07] *= val;
        outbuf[-0x06] *= val;
        outbuf[-0x05] *= val;
        outbuf[-0x04] *= val;
        outbuf[-0x03] *= val;
        outbuf[-0x02] *= val;
        outbuf[-0x01] *= val;
    }
#endif
    while(len--)
        *outbuf++ *= val;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002                   Richard B. Johnson
//
//   This divides every element of an array by a constant. This may
//   be used to correct gain. Since it's slower than a multiply, one
//   should really use the multiply for gain correction.
//
void SIG::DivConst(double *outbuf, double val, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        outbuf += 0x100;
        len    -= 0x100;
ALIGN;
        outbuf[-0x100] /= val;
        outbuf[-0x0ff] /= val;
        outbuf[-0x0fe] /= val;
        outbuf[-0x0fd] /= val;
        outbuf[-0x0fc] /= val;
        outbuf[-0x0fb] /= val;
        outbuf[-0x0fa] /= val;
        outbuf[-0x0f9] /= val;
        outbuf[-0x0f8] /= val;
        outbuf[-0x0f7] /= val;
        outbuf[-0x0f6] /= val;
        outbuf[-0x0f5] /= val;
        outbuf[-0x0f4] /= val;
        outbuf[-0x0f3] /= val;
        outbuf[-0x0f2] /= val;
        outbuf[-0x0f1] /= val;
        outbuf[-0x0f0] /= val;
        outbuf[-0x0ef] /= val;
        outbuf[-0x0ee] /= val;
        outbuf[-0x0ed] /= val;
        outbuf[-0x0ec] /= val;
        outbuf[-0x0eb] /= val;
        outbuf[-0x0ea] /= val;
        outbuf[-0x0e9] /= val;
        outbuf[-0x0e8] /= val;
        outbuf[-0x0e7] /= val;
        outbuf[-0x0e6] /= val;
        outbuf[-0x0e5] /= val;
        outbuf[-0x0e4] /= val;
        outbuf[-0x0e3] /= val;
        outbuf[-0x0e2] /= val;
        outbuf[-0x0e1] /= val;
        outbuf[-0x0e0] /= val;
        outbuf[-0x0df] /= val;
        outbuf[-0x0de] /= val;
        outbuf[-0x0dd] /= val;
        outbuf[-0x0dc] /= val;
        outbuf[-0x0db] /= val;
        outbuf[-0x0da] /= val;
        outbuf[-0x0d9] /= val;
        outbuf[-0x0d8] /= val;
        outbuf[-0x0d7] /= val;
        outbuf[-0x0d6] /= val;
        outbuf[-0x0d5] /= val;
        outbuf[-0x0d4] /= val;
        outbuf[-0x0d3] /= val;
        outbuf[-0x0d2] /= val;
        outbuf[-0x0d1] /= val;
        outbuf[-0x0d0] /= val;
        outbuf[-0x0cf] /= val;
        outbuf[-0x0ce] /= val;
        outbuf[-0x0cd] /= val;
        outbuf[-0x0cc] /= val;
        outbuf[-0x0cb] /= val;
        outbuf[-0x0ca] /= val;
        outbuf[-0x0c9] /= val;
        outbuf[-0x0c8] /= val;
        outbuf[-0x0c7] /= val;
        outbuf[-0x0c6] /= val;
        outbuf[-0x0c5] /= val;
        outbuf[-0x0c4] /= val;
        outbuf[-0x0c3] /= val;
        outbuf[-0x0c2] /= val;
        outbuf[-0x0c1] /= val;
        outbuf[-0x0c0] /= val;
        outbuf[-0x0bf] /= val;
        outbuf[-0x0be] /= val;
        outbuf[-0x0bd] /= val;
        outbuf[-0x0bc] /= val;
        outbuf[-0x0bb] /= val;
        outbuf[-0x0ba] /= val;
        outbuf[-0x0b9] /= val;
        outbuf[-0x0b8] /= val;
        outbuf[-0x0b7] /= val;
        outbuf[-0x0b6] /= val;
        outbuf[-0x0b5] /= val;
        outbuf[-0x0b4] /= val;
        outbuf[-0x0b3] /= val;
        outbuf[-0x0b2] /= val;
        outbuf[-0x0b1] /= val;
        outbuf[-0x0b0] /= val;
        outbuf[-0x0af] /= val;
        outbuf[-0x0ae] /= val;
        outbuf[-0x0ad] /= val;
        outbuf[-0x0ac] /= val;
        outbuf[-0x0ab] /= val;
        outbuf[-0x0aa] /= val;
        outbuf[-0x0a9] /= val;
        outbuf[-0x0a8] /= val;
        outbuf[-0x0a7] /= val;
        outbuf[-0x0a6] /= val;
        outbuf[-0x0a5] /= val;
        outbuf[-0x0a4] /= val;
        outbuf[-0x0a3] /= val;
        outbuf[-0x0a2] /= val;
        outbuf[-0x0a1] /= val;
        outbuf[-0x0a0] /= val;
        outbuf[-0x09f] /= val;
        outbuf[-0x09e] /= val;
        outbuf[-0x09d] /= val;
        outbuf[-0x09c] /= val;
        outbuf[-0x09b] /= val;
        outbuf[-0x09a] /= val;
        outbuf[-0x099] /= val;
        outbuf[-0x098] /= val;
        outbuf[-0x097] /= val;
        outbuf[-0x096] /= val;
        outbuf[-0x095] /= val;
        outbuf[-0x094] /= val;
        outbuf[-0x093] /= val;
        outbuf[-0x092] /= val;
        outbuf[-0x091] /= val;
        outbuf[-0x090] /= val;
        outbuf[-0x08f] /= val;
        outbuf[-0x08e] /= val;
        outbuf[-0x08d] /= val;
        outbuf[-0x08c] /= val;
        outbuf[-0x08b] /= val;
        outbuf[-0x08a] /= val;
        outbuf[-0x089] /= val;
        outbuf[-0x088] /= val;
        outbuf[-0x087] /= val;
        outbuf[-0x086] /= val;
        outbuf[-0x085] /= val;
        outbuf[-0x084] /= val;
        outbuf[-0x083] /= val;
        outbuf[-0x082] /= val;
        outbuf[-0x081] /= val;
        outbuf[-0x080] /= val;
        outbuf[-0x07f] /= val;
        outbuf[-0x07e] /= val;
        outbuf[-0x07d] /= val;
        outbuf[-0x07c] /= val;
        outbuf[-0x07b] /= val;
        outbuf[-0x07a] /= val;
        outbuf[-0x079] /= val;
        outbuf[-0x078] /= val;
        outbuf[-0x077] /= val;
        outbuf[-0x076] /= val;
        outbuf[-0x075] /= val;
        outbuf[-0x074] /= val;
        outbuf[-0x073] /= val;
        outbuf[-0x072] /= val;
        outbuf[-0x071] /= val;
        outbuf[-0x070] /= val;
        outbuf[-0x06f] /= val;
        outbuf[-0x06e] /= val;
        outbuf[-0x06d] /= val;
        outbuf[-0x06c] /= val;
        outbuf[-0x06b] /= val;
        outbuf[-0x06a] /= val;
        outbuf[-0x069] /= val;
        outbuf[-0x068] /= val;
        outbuf[-0x067] /= val;
        outbuf[-0x066] /= val;
        outbuf[-0x065] /= val;
        outbuf[-0x064] /= val;
        outbuf[-0x063] /= val;
        outbuf[-0x062] /= val;
        outbuf[-0x061] /= val;
        outbuf[-0x060] /= val;
        outbuf[-0x05f] /= val;
        outbuf[-0x05e] /= val;
        outbuf[-0x05d] /= val;
        outbuf[-0x05c] /= val;
        outbuf[-0x05b] /= val;
        outbuf[-0x05a] /= val;
        outbuf[-0x059] /= val;
        outbuf[-0x058] /= val;
        outbuf[-0x057] /= val;
        outbuf[-0x056] /= val;
        outbuf[-0x055] /= val;
        outbuf[-0x054] /= val;
        outbuf[-0x053] /= val;
        outbuf[-0x052] /= val;
        outbuf[-0x051] /= val;
        outbuf[-0x050] /= val;
        outbuf[-0x04f] /= val;
        outbuf[-0x04e] /= val;
        outbuf[-0x04d] /= val;
        outbuf[-0x04c] /= val;
        outbuf[-0x04b] /= val;
        outbuf[-0x04a] /= val;
        outbuf[-0x049] /= val;
        outbuf[-0x048] /= val;
        outbuf[-0x047] /= val;
        outbuf[-0x046] /= val;
        outbuf[-0x045] /= val;
        outbuf[-0x044] /= val;
        outbuf[-0x043] /= val;
        outbuf[-0x042] /= val;
        outbuf[-0x041] /= val;
        outbuf[-0x040] /= val;
        outbuf[-0x03f] /= val;
        outbuf[-0x03e] /= val;
        outbuf[-0x03d] /= val;
        outbuf[-0x03c] /= val;
        outbuf[-0x03b] /= val;
        outbuf[-0x03a] /= val;
        outbuf[-0x039] /= val;
        outbuf[-0x038] /= val;
        outbuf[-0x037] /= val;
        outbuf[-0x036] /= val;
        outbuf[-0x035] /= val;
        outbuf[-0x034] /= val;
        outbuf[-0x033] /= val;
        outbuf[-0x032] /= val;
        outbuf[-0x031] /= val;
        outbuf[-0x030] /= val;
        outbuf[-0x02f] /= val;
        outbuf[-0x02e] /= val;
        outbuf[-0x02d] /= val;
        outbuf[-0x02c] /= val;
        outbuf[-0x02b] /= val;
        outbuf[-0x02a] /= val;
        outbuf[-0x029] /= val;
        outbuf[-0x028] /= val;
        outbuf[-0x027] /= val;
        outbuf[-0x026] /= val;
        outbuf[-0x025] /= val;
        outbuf[-0x024] /= val;
        outbuf[-0x023] /= val;
        outbuf[-0x022] /= val;
        outbuf[-0x021] /= val;
        outbuf[-0x020] /= val;
        outbuf[-0x01f] /= val;
        outbuf[-0x01e] /= val;
        outbuf[-0x01d] /= val;
        outbuf[-0x01c] /= val;
        outbuf[-0x01b] /= val;
        outbuf[-0x01a] /= val;
        outbuf[-0x019] /= val;
        outbuf[-0x018] /= val;
        outbuf[-0x017] /= val;
        outbuf[-0x016] /= val;
        outbuf[-0x015] /= val;
        outbuf[-0x014] /= val;
        outbuf[-0x013] /= val;
        outbuf[-0x012] /= val;
        outbuf[-0x011] /= val;
        outbuf[-0x010] /= val;
        outbuf[-0x00f] /= val;
        outbuf[-0x00e] /= val;
        outbuf[-0x00d] /= val;
        outbuf[-0x00c] /= val;
        outbuf[-0x00b] /= val;
        outbuf[-0x00a] /= val;
        outbuf[-0x009] /= val;
        outbuf[-0x008] /= val;
        outbuf[-0x007] /= val;
        outbuf[-0x006] /= val;
        outbuf[-0x005] /= val;
        outbuf[-0x004] /= val;
        outbuf[-0x003] /= val;
        outbuf[-0x002] /= val;
        outbuf[-0x001] /= val;
    }
    while(len >= 0x10)
    {
        outbuf += 0x10;
        len    -= 0x10;
        outbuf[-0x10] /= val;
        outbuf[-0x0f] /= val;
        outbuf[-0x0e] /= val;
        outbuf[-0x0d] /= val;
        outbuf[-0x0c] /= val;
        outbuf[-0x0b] /= val;
        outbuf[-0x0a] /= val;
        outbuf[-0x09] /= val;
        outbuf[-0x08] /= val;
        outbuf[-0x07] /= val;
        outbuf[-0x06] /= val;
        outbuf[-0x05] /= val;
        outbuf[-0x04] /= val;
        outbuf[-0x03] /= val;
        outbuf[-0x02] /= val;
        outbuf[-0x01] /= val;
    }
#endif
    while(len--)
        *outbuf++ /= val;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002                   Richard B. Johnson
//
//   This multiplies every element in array by an element in another
//   array.
//

#define CONV(n) outbuf[n] *= kern[n]

void SIG::MultArray(double *outbuf, double *kern, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        outbuf += 0x100;
        kern   += 0x100;
        len    -= 0x100;
ALIGN;
        CONV(-0x100);
        CONV(-0x0ff);
        CONV(-0x0fe);
        CONV(-0x0fd);
        CONV(-0x0fc);
        CONV(-0x0fb);
        CONV(-0x0fa);
        CONV(-0x0f9);
        CONV(-0x0f8);
        CONV(-0x0f7);
        CONV(-0x0f6);
        CONV(-0x0f5);
        CONV(-0x0f4);
        CONV(-0x0f3);
        CONV(-0x0f2);
        CONV(-0x0f1);
        CONV(-0x0f0);
        CONV(-0x0ef);
        CONV(-0x0ee);
        CONV(-0x0ed);
        CONV(-0x0ec);
        CONV(-0x0eb);
        CONV(-0x0ea);
        CONV(-0x0e9);
        CONV(-0x0e8);
        CONV(-0x0e7);
        CONV(-0x0e6);
        CONV(-0x0e5);
        CONV(-0x0e4);
        CONV(-0x0e3);
        CONV(-0x0e2);
        CONV(-0x0e1);
        CONV(-0x0e0);
        CONV(-0x0df);
        CONV(-0x0de);
        CONV(-0x0dd);
        CONV(-0x0dc);
        CONV(-0x0db);
        CONV(-0x0da);
        CONV(-0x0d9);
        CONV(-0x0d8);
        CONV(-0x0d7);
        CONV(-0x0d6);
        CONV(-0x0d5);
        CONV(-0x0d4);
        CONV(-0x0d3);
        CONV(-0x0d2);
        CONV(-0x0d1);
        CONV(-0x0d0);
        CONV(-0x0cf);
        CONV(-0x0ce);
        CONV(-0x0cd);
        CONV(-0x0cc);
        CONV(-0x0cb);
        CONV(-0x0ca);
        CONV(-0x0c9);
        CONV(-0x0c8);
        CONV(-0x0c7);
        CONV(-0x0c6);
        CONV(-0x0c5);
        CONV(-0x0c4);
        CONV(-0x0c3);
        CONV(-0x0c2);
        CONV(-0x0c1);
        CONV(-0x0c0);
        CONV(-0x0bf);
        CONV(-0x0be);
        CONV(-0x0bd);
        CONV(-0x0bc);
        CONV(-0x0bb);
        CONV(-0x0ba);
        CONV(-0x0b9);
        CONV(-0x0b8);
        CONV(-0x0b7);
        CONV(-0x0b6);
        CONV(-0x0b5);
        CONV(-0x0b4);
        CONV(-0x0b3);
        CONV(-0x0b2);
        CONV(-0x0b1);
        CONV(-0x0b0);
        CONV(-0x0af);
        CONV(-0x0ae);
        CONV(-0x0ad);
        CONV(-0x0ac);
        CONV(-0x0ab);
        CONV(-0x0aa);
        CONV(-0x0a9);
        CONV(-0x0a8);
        CONV(-0x0a7);
        CONV(-0x0a6);
        CONV(-0x0a5);
        CONV(-0x0a4);
        CONV(-0x0a3);
        CONV(-0x0a2);
        CONV(-0x0a1);
        CONV(-0x0a0);
        CONV(-0x09f);
        CONV(-0x09e);
        CONV(-0x09d);
        CONV(-0x09c);
        CONV(-0x09b);
        CONV(-0x09a);
        CONV(-0x099);
        CONV(-0x098);
        CONV(-0x097);
        CONV(-0x096);
        CONV(-0x095);
        CONV(-0x094);
        CONV(-0x093);
        CONV(-0x092);
        CONV(-0x091);
        CONV(-0x090);
        CONV(-0x08f);
        CONV(-0x08e);
        CONV(-0x08d);
        CONV(-0x08c);
        CONV(-0x08b);
        CONV(-0x08a);
        CONV(-0x089);
        CONV(-0x088);
        CONV(-0x087);
        CONV(-0x086);
        CONV(-0x085);
        CONV(-0x084);
        CONV(-0x083);
        CONV(-0x082);
        CONV(-0x081);
        CONV(-0x080);
        CONV(-0x07f);
        CONV(-0x07e);
        CONV(-0x07d);
        CONV(-0x07c);
        CONV(-0x07b);
        CONV(-0x07a);
        CONV(-0x079);
        CONV(-0x078);
        CONV(-0x077);
        CONV(-0x076);
        CONV(-0x075);
        CONV(-0x074);
        CONV(-0x073);
        CONV(-0x072);
        CONV(-0x071);
        CONV(-0x070);
        CONV(-0x06f);
        CONV(-0x06e);
        CONV(-0x06d);
        CONV(-0x06c);
        CONV(-0x06b);
        CONV(-0x06a);
        CONV(-0x069);
        CONV(-0x068);
        CONV(-0x067);
        CONV(-0x066);
        CONV(-0x065);
        CONV(-0x064);
        CONV(-0x063);
        CONV(-0x062);
        CONV(-0x061);
        CONV(-0x060);
        CONV(-0x05f);
        CONV(-0x05e);
        CONV(-0x05d);
        CONV(-0x05c);
        CONV(-0x05b);
        CONV(-0x05a);
        CONV(-0x059);
        CONV(-0x058);
        CONV(-0x057);
        CONV(-0x056);
        CONV(-0x055);
        CONV(-0x054);
        CONV(-0x053);
        CONV(-0x052);
        CONV(-0x051);
        CONV(-0x050);
        CONV(-0x04f);
        CONV(-0x04e);
        CONV(-0x04d);
        CONV(-0x04c);
        CONV(-0x04b);
        CONV(-0x04a);
        CONV(-0x049);
        CONV(-0x048);
        CONV(-0x047);
        CONV(-0x046);
        CONV(-0x045);
        CONV(-0x044);
        CONV(-0x043);
        CONV(-0x042);
        CONV(-0x041);
        CONV(-0x040);
        CONV(-0x03f);
        CONV(-0x03e);
        CONV(-0x03d);
        CONV(-0x03c);
        CONV(-0x03b);
        CONV(-0x03a);
        CONV(-0x039);
        CONV(-0x038);
        CONV(-0x037);
        CONV(-0x036);
        CONV(-0x035);
        CONV(-0x034);
        CONV(-0x033);
        CONV(-0x032);
        CONV(-0x031);
        CONV(-0x030);
        CONV(-0x02f);
        CONV(-0x02e);
        CONV(-0x02d);
        CONV(-0x02c);
        CONV(-0x02b);
        CONV(-0x02a);
        CONV(-0x029);
        CONV(-0x028);
        CONV(-0x027);
        CONV(-0x026);
        CONV(-0x025);
        CONV(-0x024);
        CONV(-0x023);
        CONV(-0x022);
        CONV(-0x021);
        CONV(-0x020);
        CONV(-0x01f);
        CONV(-0x01e);
        CONV(-0x01d);
        CONV(-0x01c);
        CONV(-0x01b);
        CONV(-0x01a);
        CONV(-0x019);
        CONV(-0x018);
        CONV(-0x017);
        CONV(-0x016);
        CONV(-0x015);
        CONV(-0x014);
        CONV(-0x013);
        CONV(-0x012);
        CONV(-0x011);
        CONV(-0x010);
        CONV(-0x00f);
        CONV(-0x00e);
        CONV(-0x00d);
        CONV(-0x00c);
        CONV(-0x00b);
        CONV(-0x00a);
        CONV(-0x009);
        CONV(-0x008);
        CONV(-0x007);
        CONV(-0x006);
        CONV(-0x005);
        CONV(-0x004);
        CONV(-0x003);
        CONV(-0x002);
        CONV(-0x001);
    }
    while(len >= 0x10)
    {
        outbuf += 0x10;
        kern   += 0x10;
        len    -= 0x10;
        CONV(-0x10);
        CONV(-0x0f);
        CONV(-0x0e);
        CONV(-0x0d);
        CONV(-0x0c);
        CONV(-0x0b);
        CONV(-0x0a);
        CONV(-0x09);
        CONV(-0x08);
        CONV(-0x07);
        CONV(-0x06);
        CONV(-0x05);
        CONV(-0x04);
        CONV(-0x03);
        CONV(-0x02);
        CONV(-0x01);
    }
#endif
    while(len--)
        *outbuf++ *= *kern++;
    return;
}
#ifdef NORMAL_ABS
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 24-JAN-2003            Richard B. Johnson
//
//   This function makes every element in the array positive.
//

#define MAKE_POS(n) if(outbuf[n] < 0.0) outbuf[n] = -outbuf[n];

void SIG::AbsValue(double *outbuf, int len)
{
#ifdef UNROLL
    while(len >= 0x10)
    {
        outbuf += 0x10;
        len    -= 0x10;
ALIGN;
        MAKE_POS(-0x10);
        MAKE_POS(-0x0f);
        MAKE_POS(-0x0e);
        MAKE_POS(-0x0d);
        MAKE_POS(-0x0c);
        MAKE_POS(-0x0b);
        MAKE_POS(-0x0a);
        MAKE_POS(-0x09);
        MAKE_POS(-0x08);
        MAKE_POS(-0x07);
        MAKE_POS(-0x06);
        MAKE_POS(-0x05);
        MAKE_POS(-0x04);
        MAKE_POS(-0x03);
        MAKE_POS(-0x02);
        MAKE_POS(-0x01);
    }
#endif
    while(len--)
    {
        if(*outbuf < 0.0) *outbuf = -(*outbuf);
        outbuf++;
    }
    return;
}
#else
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 24-JAN-2003                   Richard B. Johnson
//
//   This function makes every element in the array positive. It does
//   very bad things but is probably okay for the ix86 and limited
//   dynamic range signals. The "very bad" things are:
//   It presumes it knows how 'double' floating-point is constructed.
//   It mucks with these components as though they were short ints.
//
//   This is quite-likely safe on any machine that uses the Intel
//   floating-point processor.
//
#define MUCK_FP(i)  ((unsigned short *)&outbuf[i])[3] &= ~0x8000

void SIG::AbsValue(double *outbuf, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        len    -= 0x100;
        outbuf += 0x100;
        MUCK_FP(-0x100);
        MUCK_FP(-0x0ff);
        MUCK_FP(-0x0fe);
        MUCK_FP(-0x0fd);
        MUCK_FP(-0x0fc);
        MUCK_FP(-0x0fb);
        MUCK_FP(-0x0fa);
        MUCK_FP(-0x0f9);
        MUCK_FP(-0x0f8);
        MUCK_FP(-0x0f7);
        MUCK_FP(-0x0f6);
        MUCK_FP(-0x0f5);
        MUCK_FP(-0x0f4);
        MUCK_FP(-0x0f3);
        MUCK_FP(-0x0f2);
        MUCK_FP(-0x0f1);
        MUCK_FP(-0x0f0);
        MUCK_FP(-0x0ef);
        MUCK_FP(-0x0ee);
        MUCK_FP(-0x0ed);
        MUCK_FP(-0x0ec);
        MUCK_FP(-0x0eb);
        MUCK_FP(-0x0ea);
        MUCK_FP(-0x0e9);
        MUCK_FP(-0x0e8);
        MUCK_FP(-0x0e7);
        MUCK_FP(-0x0e6);
        MUCK_FP(-0x0e5);
        MUCK_FP(-0x0e4);
        MUCK_FP(-0x0e3);
        MUCK_FP(-0x0e2);
        MUCK_FP(-0x0e1);
        MUCK_FP(-0x0e0);
        MUCK_FP(-0x0df);
        MUCK_FP(-0x0de);
        MUCK_FP(-0x0dd);
        MUCK_FP(-0x0dc);
        MUCK_FP(-0x0db);
        MUCK_FP(-0x0da);
        MUCK_FP(-0x0d9);
        MUCK_FP(-0x0d8);
        MUCK_FP(-0x0d7);
        MUCK_FP(-0x0d6);
        MUCK_FP(-0x0d5);
        MUCK_FP(-0x0d4);
        MUCK_FP(-0x0d3);
        MUCK_FP(-0x0d2);
        MUCK_FP(-0x0d1);
        MUCK_FP(-0x0d0);
        MUCK_FP(-0x0cf);
        MUCK_FP(-0x0ce);
        MUCK_FP(-0x0cd);
        MUCK_FP(-0x0cc);
        MUCK_FP(-0x0cb);
        MUCK_FP(-0x0ca);
        MUCK_FP(-0x0c9);
        MUCK_FP(-0x0c8);
        MUCK_FP(-0x0c7);
        MUCK_FP(-0x0c6);
        MUCK_FP(-0x0c5);
        MUCK_FP(-0x0c4);
        MUCK_FP(-0x0c3);
        MUCK_FP(-0x0c2);
        MUCK_FP(-0x0c1);
        MUCK_FP(-0x0c0);
        MUCK_FP(-0x0bf);
        MUCK_FP(-0x0be);
        MUCK_FP(-0x0bd);
        MUCK_FP(-0x0bc);
        MUCK_FP(-0x0bb);
        MUCK_FP(-0x0ba);
        MUCK_FP(-0x0b9);
        MUCK_FP(-0x0b8);
        MUCK_FP(-0x0b7);
        MUCK_FP(-0x0b6);
        MUCK_FP(-0x0b5);
        MUCK_FP(-0x0b4);
        MUCK_FP(-0x0b3);
        MUCK_FP(-0x0b2);
        MUCK_FP(-0x0b1);
        MUCK_FP(-0x0b0);
        MUCK_FP(-0x0af);
        MUCK_FP(-0x0ae);
        MUCK_FP(-0x0ad);
        MUCK_FP(-0x0ac);
        MUCK_FP(-0x0ab);
        MUCK_FP(-0x0aa);
        MUCK_FP(-0x0a9);
        MUCK_FP(-0x0a8);
        MUCK_FP(-0x0a7);
        MUCK_FP(-0x0a6);
        MUCK_FP(-0x0a5);
        MUCK_FP(-0x0a4);
        MUCK_FP(-0x0a3);
        MUCK_FP(-0x0a2);
        MUCK_FP(-0x0a1);
        MUCK_FP(-0x0a0);
        MUCK_FP(-0x09f);
        MUCK_FP(-0x09e);
        MUCK_FP(-0x09d);
        MUCK_FP(-0x09c);
        MUCK_FP(-0x09b);
        MUCK_FP(-0x09a);
        MUCK_FP(-0x099);
        MUCK_FP(-0x098);
        MUCK_FP(-0x097);
        MUCK_FP(-0x096);
        MUCK_FP(-0x095);
        MUCK_FP(-0x094);
        MUCK_FP(-0x093);
        MUCK_FP(-0x092);
        MUCK_FP(-0x091);
        MUCK_FP(-0x090);
        MUCK_FP(-0x08f);
        MUCK_FP(-0x08e);
        MUCK_FP(-0x08d);
        MUCK_FP(-0x08c);
        MUCK_FP(-0x08b);
        MUCK_FP(-0x08a);
        MUCK_FP(-0x089);
        MUCK_FP(-0x088);
        MUCK_FP(-0x087);
        MUCK_FP(-0x086);
        MUCK_FP(-0x085);
        MUCK_FP(-0x084);
        MUCK_FP(-0x083);
        MUCK_FP(-0x082);
        MUCK_FP(-0x081);
        MUCK_FP(-0x080);
        MUCK_FP(-0x07f);
        MUCK_FP(-0x07e);
        MUCK_FP(-0x07d);
        MUCK_FP(-0x07c);
        MUCK_FP(-0x07b);
        MUCK_FP(-0x07a);
        MUCK_FP(-0x079);
        MUCK_FP(-0x078);
        MUCK_FP(-0x077);
        MUCK_FP(-0x076);
        MUCK_FP(-0x075);
        MUCK_FP(-0x074);
        MUCK_FP(-0x073);
        MUCK_FP(-0x072);
        MUCK_FP(-0x071);
        MUCK_FP(-0x070);
        MUCK_FP(-0x06f);
        MUCK_FP(-0x06e);
        MUCK_FP(-0x06d);
        MUCK_FP(-0x06c);
        MUCK_FP(-0x06b);
        MUCK_FP(-0x06a);
        MUCK_FP(-0x069);
        MUCK_FP(-0x068);
        MUCK_FP(-0x067);
        MUCK_FP(-0x066);
        MUCK_FP(-0x065);
        MUCK_FP(-0x064);
        MUCK_FP(-0x063);
        MUCK_FP(-0x062);
        MUCK_FP(-0x061);
        MUCK_FP(-0x060);
        MUCK_FP(-0x05f);
        MUCK_FP(-0x05e);
        MUCK_FP(-0x05d);
        MUCK_FP(-0x05c);
        MUCK_FP(-0x05b);
        MUCK_FP(-0x05a);
        MUCK_FP(-0x059);
        MUCK_FP(-0x058);
        MUCK_FP(-0x057);
        MUCK_FP(-0x056);
        MUCK_FP(-0x055);
        MUCK_FP(-0x054);
        MUCK_FP(-0x053);
        MUCK_FP(-0x052);
        MUCK_FP(-0x051);
        MUCK_FP(-0x050);
        MUCK_FP(-0x04f);
        MUCK_FP(-0x04e);
        MUCK_FP(-0x04d);
        MUCK_FP(-0x04c);
        MUCK_FP(-0x04b);
        MUCK_FP(-0x04a);
        MUCK_FP(-0x049);
        MUCK_FP(-0x048);
        MUCK_FP(-0x047);
        MUCK_FP(-0x046);
        MUCK_FP(-0x045);
        MUCK_FP(-0x044);
        MUCK_FP(-0x043);
        MUCK_FP(-0x042);
        MUCK_FP(-0x041);
        MUCK_FP(-0x040);
        MUCK_FP(-0x03f);
        MUCK_FP(-0x03e);
        MUCK_FP(-0x03d);
        MUCK_FP(-0x03c);
        MUCK_FP(-0x03b);
        MUCK_FP(-0x03a);
        MUCK_FP(-0x039);
        MUCK_FP(-0x038);
        MUCK_FP(-0x037);
        MUCK_FP(-0x036);
        MUCK_FP(-0x035);
        MUCK_FP(-0x034);
        MUCK_FP(-0x033);
        MUCK_FP(-0x032);
        MUCK_FP(-0x031);
        MUCK_FP(-0x030);
        MUCK_FP(-0x02f);
        MUCK_FP(-0x02e);
        MUCK_FP(-0x02d);
        MUCK_FP(-0x02c);
        MUCK_FP(-0x02b);
        MUCK_FP(-0x02a);
        MUCK_FP(-0x029);
        MUCK_FP(-0x028);
        MUCK_FP(-0x027);
        MUCK_FP(-0x026);
        MUCK_FP(-0x025);
        MUCK_FP(-0x024);
        MUCK_FP(-0x023);
        MUCK_FP(-0x022);
        MUCK_FP(-0x021);
        MUCK_FP(-0x020);
        MUCK_FP(-0x01f);
        MUCK_FP(-0x01e);
        MUCK_FP(-0x01d);
        MUCK_FP(-0x01c);
        MUCK_FP(-0x01b);
        MUCK_FP(-0x01a);
        MUCK_FP(-0x019);
        MUCK_FP(-0x018);
        MUCK_FP(-0x017);
        MUCK_FP(-0x016);
        MUCK_FP(-0x015);
        MUCK_FP(-0x014);
        MUCK_FP(-0x013);
        MUCK_FP(-0x012);
        MUCK_FP(-0x011);
        MUCK_FP(-0x010);
        MUCK_FP(-0x00f);
        MUCK_FP(-0x00e);
        MUCK_FP(-0x00d);
        MUCK_FP(-0x00c);
        MUCK_FP(-0x00b);
        MUCK_FP(-0x00a);
        MUCK_FP(-0x009);
        MUCK_FP(-0x008);
        MUCK_FP(-0x007);
        MUCK_FP(-0x006);
        MUCK_FP(-0x005);
        MUCK_FP(-0x004);
        MUCK_FP(-0x003);
        MUCK_FP(-0x002);
        MUCK_FP(-0x001);
    }
    while(len >= 0x10)
    {
        len    -= 0x10;
        outbuf += 0x10;
        MUCK_FP(-0x10);
        MUCK_FP(-0x0f);
        MUCK_FP(-0x0e);
        MUCK_FP(-0x0d);
        MUCK_FP(-0x0c);
        MUCK_FP(-0x0b);
        MUCK_FP(-0x0a);
        MUCK_FP(-0x09);
        MUCK_FP(-0x08);
        MUCK_FP(-0x07);
        MUCK_FP(-0x06);
        MUCK_FP(-0x05);
        MUCK_FP(-0x04);
        MUCK_FP(-0x03);
        MUCK_FP(-0x02);
        MUCK_FP(-0x01);
    }
#endif
    while(len--)
        ((unsigned short *)outbuf++)[3] &= ~0x8000;
    return;
}
#endif
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002                  Richard B. Johnson
//
//   This gets a buffer of short integers and converts them to a buffer
//   of double-precision floats. This is not very hard to do, but it's
//   done in a common procedure where some optimization can occur.
//

#define CVT_S2D(a) outbuf[a] = (double) inbuf[a]

void SIG::CvtShort2Double(double *outbuf, short *inbuf, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        outbuf += 0x100;
        inbuf  += 0x100;
        len    -= 0x100;
ALIGN;
        CVT_S2D(-0x100);
        CVT_S2D(-0x0ff);
        CVT_S2D(-0x0fe);
        CVT_S2D(-0x0fd);
        CVT_S2D(-0x0fc);
        CVT_S2D(-0x0fb);
        CVT_S2D(-0x0fa);
        CVT_S2D(-0x0f9);
        CVT_S2D(-0x0f8);
        CVT_S2D(-0x0f7);
        CVT_S2D(-0x0f6);
        CVT_S2D(-0x0f5);
        CVT_S2D(-0x0f4);
        CVT_S2D(-0x0f3);
        CVT_S2D(-0x0f2);
        CVT_S2D(-0x0f1);
        CVT_S2D(-0x0f0);
        CVT_S2D(-0x0ef);
        CVT_S2D(-0x0ee);
        CVT_S2D(-0x0ed);
        CVT_S2D(-0x0ec);
        CVT_S2D(-0x0eb);
        CVT_S2D(-0x0ea);
        CVT_S2D(-0x0e9);
        CVT_S2D(-0x0e8);
        CVT_S2D(-0x0e7);
        CVT_S2D(-0x0e6);
        CVT_S2D(-0x0e5);
        CVT_S2D(-0x0e4);
        CVT_S2D(-0x0e3);
        CVT_S2D(-0x0e2);
        CVT_S2D(-0x0e1);
        CVT_S2D(-0x0e0);
        CVT_S2D(-0x0df);
        CVT_S2D(-0x0de);
        CVT_S2D(-0x0dd);
        CVT_S2D(-0x0dc);
        CVT_S2D(-0x0db);
        CVT_S2D(-0x0da);
        CVT_S2D(-0x0d9);
        CVT_S2D(-0x0d8);
        CVT_S2D(-0x0d7);
        CVT_S2D(-0x0d6);
        CVT_S2D(-0x0d5);
        CVT_S2D(-0x0d4);
        CVT_S2D(-0x0d3);
        CVT_S2D(-0x0d2);
        CVT_S2D(-0x0d1);
        CVT_S2D(-0x0d0);
        CVT_S2D(-0x0cf);
        CVT_S2D(-0x0ce);
        CVT_S2D(-0x0cd);
        CVT_S2D(-0x0cc);
        CVT_S2D(-0x0cb);
        CVT_S2D(-0x0ca);
        CVT_S2D(-0x0c9);
        CVT_S2D(-0x0c8);
        CVT_S2D(-0x0c7);
        CVT_S2D(-0x0c6);
        CVT_S2D(-0x0c5);
        CVT_S2D(-0x0c4);
        CVT_S2D(-0x0c3);
        CVT_S2D(-0x0c2);
        CVT_S2D(-0x0c1);
        CVT_S2D(-0x0c0);
        CVT_S2D(-0x0bf);
        CVT_S2D(-0x0be);
        CVT_S2D(-0x0bd);
        CVT_S2D(-0x0bc);
        CVT_S2D(-0x0bb);
        CVT_S2D(-0x0ba);
        CVT_S2D(-0x0b9);
        CVT_S2D(-0x0b8);
        CVT_S2D(-0x0b7);
        CVT_S2D(-0x0b6);
        CVT_S2D(-0x0b5);
        CVT_S2D(-0x0b4);
        CVT_S2D(-0x0b3);
        CVT_S2D(-0x0b2);
        CVT_S2D(-0x0b1);
        CVT_S2D(-0x0b0);
        CVT_S2D(-0x0af);
        CVT_S2D(-0x0ae);
        CVT_S2D(-0x0ad);
        CVT_S2D(-0x0ac);
        CVT_S2D(-0x0ab);
        CVT_S2D(-0x0aa);
        CVT_S2D(-0x0a9);
        CVT_S2D(-0x0a8);
        CVT_S2D(-0x0a7);
        CVT_S2D(-0x0a6);
        CVT_S2D(-0x0a5);
        CVT_S2D(-0x0a4);
        CVT_S2D(-0x0a3);
        CVT_S2D(-0x0a2);
        CVT_S2D(-0x0a1);
        CVT_S2D(-0x0a0);
        CVT_S2D(-0x09f);
        CVT_S2D(-0x09e);
        CVT_S2D(-0x09d);
        CVT_S2D(-0x09c);
        CVT_S2D(-0x09b);
        CVT_S2D(-0x09a);
        CVT_S2D(-0x099);
        CVT_S2D(-0x098);
        CVT_S2D(-0x097);
        CVT_S2D(-0x096);
        CVT_S2D(-0x095);
        CVT_S2D(-0x094);
        CVT_S2D(-0x093);
        CVT_S2D(-0x092);
        CVT_S2D(-0x091);
        CVT_S2D(-0x090);
        CVT_S2D(-0x08f);
        CVT_S2D(-0x08e);
        CVT_S2D(-0x08d);
        CVT_S2D(-0x08c);
        CVT_S2D(-0x08b);
        CVT_S2D(-0x08a);
        CVT_S2D(-0x089);
        CVT_S2D(-0x088);
        CVT_S2D(-0x087);
        CVT_S2D(-0x086);
        CVT_S2D(-0x085);
        CVT_S2D(-0x084);
        CVT_S2D(-0x083);
        CVT_S2D(-0x082);
        CVT_S2D(-0x081);
        CVT_S2D(-0x080);
        CVT_S2D(-0x07f);
        CVT_S2D(-0x07e);
        CVT_S2D(-0x07d);
        CVT_S2D(-0x07c);
        CVT_S2D(-0x07b);
        CVT_S2D(-0x07a);
        CVT_S2D(-0x079);
        CVT_S2D(-0x078);
        CVT_S2D(-0x077);
        CVT_S2D(-0x076);
        CVT_S2D(-0x075);
        CVT_S2D(-0x074);
        CVT_S2D(-0x073);
        CVT_S2D(-0x072);
        CVT_S2D(-0x071);
        CVT_S2D(-0x070);
        CVT_S2D(-0x06f);
        CVT_S2D(-0x06e);
        CVT_S2D(-0x06d);
        CVT_S2D(-0x06c);
        CVT_S2D(-0x06b);
        CVT_S2D(-0x06a);
        CVT_S2D(-0x069);
        CVT_S2D(-0x068);
        CVT_S2D(-0x067);
        CVT_S2D(-0x066);
        CVT_S2D(-0x065);
        CVT_S2D(-0x064);
        CVT_S2D(-0x063);
        CVT_S2D(-0x062);
        CVT_S2D(-0x061);
        CVT_S2D(-0x060);
        CVT_S2D(-0x05f);
        CVT_S2D(-0x05e);
        CVT_S2D(-0x05d);
        CVT_S2D(-0x05c);
        CVT_S2D(-0x05b);
        CVT_S2D(-0x05a);
        CVT_S2D(-0x059);
        CVT_S2D(-0x058);
        CVT_S2D(-0x057);
        CVT_S2D(-0x056);
        CVT_S2D(-0x055);
        CVT_S2D(-0x054);
        CVT_S2D(-0x053);
        CVT_S2D(-0x052);
        CVT_S2D(-0x051);
        CVT_S2D(-0x050);
        CVT_S2D(-0x04f);
        CVT_S2D(-0x04e);
        CVT_S2D(-0x04d);
        CVT_S2D(-0x04c);
        CVT_S2D(-0x04b);
        CVT_S2D(-0x04a);
        CVT_S2D(-0x049);
        CVT_S2D(-0x048);
        CVT_S2D(-0x047);
        CVT_S2D(-0x046);
        CVT_S2D(-0x045);
        CVT_S2D(-0x044);
        CVT_S2D(-0x043);
        CVT_S2D(-0x042);
        CVT_S2D(-0x041);
        CVT_S2D(-0x040);
        CVT_S2D(-0x03f);
        CVT_S2D(-0x03e);
        CVT_S2D(-0x03d);
        CVT_S2D(-0x03c);
        CVT_S2D(-0x03b);
        CVT_S2D(-0x03a);
        CVT_S2D(-0x039);
        CVT_S2D(-0x038);
        CVT_S2D(-0x037);
        CVT_S2D(-0x036);
        CVT_S2D(-0x035);
        CVT_S2D(-0x034);
        CVT_S2D(-0x033);
        CVT_S2D(-0x032);
        CVT_S2D(-0x031);
        CVT_S2D(-0x030);
        CVT_S2D(-0x02f);
        CVT_S2D(-0x02e);
        CVT_S2D(-0x02d);
        CVT_S2D(-0x02c);
        CVT_S2D(-0x02b);
        CVT_S2D(-0x02a);
        CVT_S2D(-0x029);
        CVT_S2D(-0x028);
        CVT_S2D(-0x027);
        CVT_S2D(-0x026);
        CVT_S2D(-0x025);
        CVT_S2D(-0x024);
        CVT_S2D(-0x023);
        CVT_S2D(-0x022);
        CVT_S2D(-0x021);
        CVT_S2D(-0x020);
        CVT_S2D(-0x01f);
        CVT_S2D(-0x01e);
        CVT_S2D(-0x01d);
        CVT_S2D(-0x01c);
        CVT_S2D(-0x01b);
        CVT_S2D(-0x01a);
        CVT_S2D(-0x019);
        CVT_S2D(-0x018);
        CVT_S2D(-0x017);
        CVT_S2D(-0x016);
        CVT_S2D(-0x015);
        CVT_S2D(-0x014);
        CVT_S2D(-0x013);
        CVT_S2D(-0x012);
        CVT_S2D(-0x011);
        CVT_S2D(-0x010);
        CVT_S2D(-0x00f);
        CVT_S2D(-0x00e);
        CVT_S2D(-0x00d);
        CVT_S2D(-0x00c);
        CVT_S2D(-0x00b);
        CVT_S2D(-0x00a);
        CVT_S2D(-0x009);
        CVT_S2D(-0x008);
        CVT_S2D(-0x007);
        CVT_S2D(-0x006);
        CVT_S2D(-0x005);
        CVT_S2D(-0x004);
        CVT_S2D(-0x003);
        CVT_S2D(-0x002);
        CVT_S2D(-0x001);
    }
    while(len >= 0x10)
    {
        outbuf += 0x10;
        inbuf  += 0x10;
        len    -= 0x10;
        CVT_S2D(-0x10);
        CVT_S2D(-0x0f);
        CVT_S2D(-0x0e);
        CVT_S2D(-0x0d);
        CVT_S2D(-0x0c);
        CVT_S2D(-0x0b);
        CVT_S2D(-0x0a);
        CVT_S2D(-0x09);
        CVT_S2D(-0x08);
        CVT_S2D(-0x07);
        CVT_S2D(-0x06);
        CVT_S2D(-0x05);
        CVT_S2D(-0x04);
        CVT_S2D(-0x03);
        CVT_S2D(-0x02);
        CVT_S2D(-0x01);
    }
#endif
    while(len--)
        *outbuf++ = (double) *inbuf++;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002               Richard B. Johnson
//
//   This gets a buffer of integers and converts them to a buffer of
//   double-precision floats. This is not very hard to do, but it's
//   done in a common procedure where some optimization can occur.
//

#define CVT_I2D(a) outbuf[a] = (double) inbuf[a]

void SIG::CvtInt2Double(double *outbuf, int *inbuf, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        outbuf += 0x100;
        inbuf  += 0x100;
        len    -= 0x100;
ALIGN;
        CVT_I2D(-0x100);
        CVT_I2D(-0x0ff);
        CVT_I2D(-0x0fe);
        CVT_I2D(-0x0fd);
        CVT_I2D(-0x0fc);
        CVT_I2D(-0x0fb);
        CVT_I2D(-0x0fa);
        CVT_I2D(-0x0f9);
        CVT_I2D(-0x0f8);
        CVT_I2D(-0x0f7);
        CVT_I2D(-0x0f6);
        CVT_I2D(-0x0f5);
        CVT_I2D(-0x0f4);
        CVT_I2D(-0x0f3);
        CVT_I2D(-0x0f2);
        CVT_I2D(-0x0f1);
        CVT_I2D(-0x0f0);
        CVT_I2D(-0x0ef);
        CVT_I2D(-0x0ee);
        CVT_I2D(-0x0ed);
        CVT_I2D(-0x0ec);
        CVT_I2D(-0x0eb);
        CVT_I2D(-0x0ea);
        CVT_I2D(-0x0e9);
        CVT_I2D(-0x0e8);
        CVT_I2D(-0x0e7);
        CVT_I2D(-0x0e6);
        CVT_I2D(-0x0e5);
        CVT_I2D(-0x0e4);
        CVT_I2D(-0x0e3);
        CVT_I2D(-0x0e2);
        CVT_I2D(-0x0e1);
        CVT_I2D(-0x0e0);
        CVT_I2D(-0x0df);
        CVT_I2D(-0x0de);
        CVT_I2D(-0x0dd);
        CVT_I2D(-0x0dc);
        CVT_I2D(-0x0db);
        CVT_I2D(-0x0da);
        CVT_I2D(-0x0d9);
        CVT_I2D(-0x0d8);
        CVT_I2D(-0x0d7);
        CVT_I2D(-0x0d6);
        CVT_I2D(-0x0d5);
        CVT_I2D(-0x0d4);
        CVT_I2D(-0x0d3);
        CVT_I2D(-0x0d2);
        CVT_I2D(-0x0d1);
        CVT_I2D(-0x0d0);
        CVT_I2D(-0x0cf);
        CVT_I2D(-0x0ce);
        CVT_I2D(-0x0cd);
        CVT_I2D(-0x0cc);
        CVT_I2D(-0x0cb);
        CVT_I2D(-0x0ca);
        CVT_I2D(-0x0c9);
        CVT_I2D(-0x0c8);
        CVT_I2D(-0x0c7);
        CVT_I2D(-0x0c6);
        CVT_I2D(-0x0c5);
        CVT_I2D(-0x0c4);
        CVT_I2D(-0x0c3);
        CVT_I2D(-0x0c2);
        CVT_I2D(-0x0c1);
        CVT_I2D(-0x0c0);
        CVT_I2D(-0x0bf);
        CVT_I2D(-0x0be);
        CVT_I2D(-0x0bd);
        CVT_I2D(-0x0bc);
        CVT_I2D(-0x0bb);
        CVT_I2D(-0x0ba);
        CVT_I2D(-0x0b9);
        CVT_I2D(-0x0b8);
        CVT_I2D(-0x0b7);
        CVT_I2D(-0x0b6);
        CVT_I2D(-0x0b5);
        CVT_I2D(-0x0b4);
        CVT_I2D(-0x0b3);
        CVT_I2D(-0x0b2);
        CVT_I2D(-0x0b1);
        CVT_I2D(-0x0b0);
        CVT_I2D(-0x0af);
        CVT_I2D(-0x0ae);
        CVT_I2D(-0x0ad);
        CVT_I2D(-0x0ac);
        CVT_I2D(-0x0ab);
        CVT_I2D(-0x0aa);
        CVT_I2D(-0x0a9);
        CVT_I2D(-0x0a8);
        CVT_I2D(-0x0a7);
        CVT_I2D(-0x0a6);
        CVT_I2D(-0x0a5);
        CVT_I2D(-0x0a4);
        CVT_I2D(-0x0a3);
        CVT_I2D(-0x0a2);
        CVT_I2D(-0x0a1);
        CVT_I2D(-0x0a0);
        CVT_I2D(-0x09f);
        CVT_I2D(-0x09e);
        CVT_I2D(-0x09d);
        CVT_I2D(-0x09c);
        CVT_I2D(-0x09b);
        CVT_I2D(-0x09a);
        CVT_I2D(-0x099);
        CVT_I2D(-0x098);
        CVT_I2D(-0x097);
        CVT_I2D(-0x096);
        CVT_I2D(-0x095);
        CVT_I2D(-0x094);
        CVT_I2D(-0x093);
        CVT_I2D(-0x092);
        CVT_I2D(-0x091);
        CVT_I2D(-0x090);
        CVT_I2D(-0x08f);
        CVT_I2D(-0x08e);
        CVT_I2D(-0x08d);
        CVT_I2D(-0x08c);
        CVT_I2D(-0x08b);
        CVT_I2D(-0x08a);
        CVT_I2D(-0x089);
        CVT_I2D(-0x088);
        CVT_I2D(-0x087);
        CVT_I2D(-0x086);
        CVT_I2D(-0x085);
        CVT_I2D(-0x084);
        CVT_I2D(-0x083);
        CVT_I2D(-0x082);
        CVT_I2D(-0x081);
        CVT_I2D(-0x080);
        CVT_I2D(-0x07f);
        CVT_I2D(-0x07e);
        CVT_I2D(-0x07d);
        CVT_I2D(-0x07c);
        CVT_I2D(-0x07b);
        CVT_I2D(-0x07a);
        CVT_I2D(-0x079);
        CVT_I2D(-0x078);
        CVT_I2D(-0x077);
        CVT_I2D(-0x076);
        CVT_I2D(-0x075);
        CVT_I2D(-0x074);
        CVT_I2D(-0x073);
        CVT_I2D(-0x072);
        CVT_I2D(-0x071);
        CVT_I2D(-0x070);
        CVT_I2D(-0x06f);
        CVT_I2D(-0x06e);
        CVT_I2D(-0x06d);
        CVT_I2D(-0x06c);
        CVT_I2D(-0x06b);
        CVT_I2D(-0x06a);
        CVT_I2D(-0x069);
        CVT_I2D(-0x068);
        CVT_I2D(-0x067);
        CVT_I2D(-0x066);
        CVT_I2D(-0x065);
        CVT_I2D(-0x064);
        CVT_I2D(-0x063);
        CVT_I2D(-0x062);
        CVT_I2D(-0x061);
        CVT_I2D(-0x060);
        CVT_I2D(-0x05f);
        CVT_I2D(-0x05e);
        CVT_I2D(-0x05d);
        CVT_I2D(-0x05c);
        CVT_I2D(-0x05b);
        CVT_I2D(-0x05a);
        CVT_I2D(-0x059);
        CVT_I2D(-0x058);
        CVT_I2D(-0x057);
        CVT_I2D(-0x056);
        CVT_I2D(-0x055);
        CVT_I2D(-0x054);
        CVT_I2D(-0x053);
        CVT_I2D(-0x052);
        CVT_I2D(-0x051);
        CVT_I2D(-0x050);
        CVT_I2D(-0x04f);
        CVT_I2D(-0x04e);
        CVT_I2D(-0x04d);
        CVT_I2D(-0x04c);
        CVT_I2D(-0x04b);
        CVT_I2D(-0x04a);
        CVT_I2D(-0x049);
        CVT_I2D(-0x048);
        CVT_I2D(-0x047);
        CVT_I2D(-0x046);
        CVT_I2D(-0x045);
        CVT_I2D(-0x044);
        CVT_I2D(-0x043);
        CVT_I2D(-0x042);
        CVT_I2D(-0x041);
        CVT_I2D(-0x040);
        CVT_I2D(-0x03f);
        CVT_I2D(-0x03e);
        CVT_I2D(-0x03d);
        CVT_I2D(-0x03c);
        CVT_I2D(-0x03b);
        CVT_I2D(-0x03a);
        CVT_I2D(-0x039);
        CVT_I2D(-0x038);
        CVT_I2D(-0x037);
        CVT_I2D(-0x036);
        CVT_I2D(-0x035);
        CVT_I2D(-0x034);
        CVT_I2D(-0x033);
        CVT_I2D(-0x032);
        CVT_I2D(-0x031);
        CVT_I2D(-0x030);
        CVT_I2D(-0x02f);
        CVT_I2D(-0x02e);
        CVT_I2D(-0x02d);
        CVT_I2D(-0x02c);
        CVT_I2D(-0x02b);
        CVT_I2D(-0x02a);
        CVT_I2D(-0x029);
        CVT_I2D(-0x028);
        CVT_I2D(-0x027);
        CVT_I2D(-0x026);
        CVT_I2D(-0x025);
        CVT_I2D(-0x024);
        CVT_I2D(-0x023);
        CVT_I2D(-0x022);
        CVT_I2D(-0x021);
        CVT_I2D(-0x020);
        CVT_I2D(-0x01f);
        CVT_I2D(-0x01e);
        CVT_I2D(-0x01d);
        CVT_I2D(-0x01c);
        CVT_I2D(-0x01b);
        CVT_I2D(-0x01a);
        CVT_I2D(-0x019);
        CVT_I2D(-0x018);
        CVT_I2D(-0x017);
        CVT_I2D(-0x016);
        CVT_I2D(-0x015);
        CVT_I2D(-0x014);
        CVT_I2D(-0x013);
        CVT_I2D(-0x012);
        CVT_I2D(-0x011);
        CVT_I2D(-0x010);
        CVT_I2D(-0x00f);
        CVT_I2D(-0x00e);
        CVT_I2D(-0x00d);
        CVT_I2D(-0x00c);
        CVT_I2D(-0x00b);
        CVT_I2D(-0x00a);
        CVT_I2D(-0x009);
        CVT_I2D(-0x008);
        CVT_I2D(-0x007);
        CVT_I2D(-0x006);
        CVT_I2D(-0x005);
        CVT_I2D(-0x004);
        CVT_I2D(-0x003);
        CVT_I2D(-0x002);
        CVT_I2D(-0x001);
    }
    while(len >= 0x10)
    {
        outbuf += 0x10;
        inbuf  += 0x10;
        len    -= 0x10;
        CVT_I2D(-0x10);
        CVT_I2D(-0x0f);
        CVT_I2D(-0x0e);
        CVT_I2D(-0x0d);
        CVT_I2D(-0x0c);
        CVT_I2D(-0x0b);
        CVT_I2D(-0x0a);
        CVT_I2D(-0x09);
        CVT_I2D(-0x08);
        CVT_I2D(-0x07);
        CVT_I2D(-0x06);
        CVT_I2D(-0x05);
        CVT_I2D(-0x04);
        CVT_I2D(-0x03);
        CVT_I2D(-0x02);
        CVT_I2D(-0x01);
    }
#endif
    while(len--)
        *outbuf++ = (double) *inbuf++;
    return;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002            Richard B. Johnson
//
//   This returns the settling time (in samples) to within the input limits.
//   the input limits would typically be 0.01 (1 percent) or 0.001
//   (0.1 percent). You can input anything. This first scans the array,
//   looking for peak-to-peak values. From this, it calculates the
//   upper and lower bounds. It then calls the WithinLimits() procedure.
//
int SIG::SettlingTime(double *array, double ref, int len)
{
    double x, lower, upper, peak, *start;
    int i;
    start = array;
    lower = upper = peak = 0.0;
    i = len;
#ifdef UNROLL
    while (i >= 0x10)
    {
        array += 0x10;
        i  -= 0x10;
        x = array[-0x10]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x0f]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x0e]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x0d]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x0c]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x0b]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x0a]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x09]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x08]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x07]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x06]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x05]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x04]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x03]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x02]; if(x < lower)lower = x; else if(x > upper)upper = x;
        x = array[-0x01]; if(x < lower)lower = x; else if(x > upper)upper = x;
    }
#endif
    while(i--)
    {
       x = *array++;
       if(x < lower)
           lower = x;
       else if(x > upper)
           upper = x;
    }
    x = upper * ref;
    if((i = WithinLimits(start, upper + x, upper - x, len)) == len)
    {
        x = lower * ref;
        i = WithinLimits(start, lower + x, lower - x, len);
    }
    return i;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002                   Richard B. Johnson
//
//   This returns the time (in samples) where the data is within the
//   supplied limits. If it is never within limits, it returns the
//   length of the array. Uses some loop-unrolling.
//
int SIG::WithinLimits(double *array, double upper, double lower, int len)
{
    double x;
    double *start = array;
#ifdef UNROLL
    while (len >= 0x10)
    {
        array += 0x10;
        len  -= 0x10;
        x=array[-0x10];if((x<upper)&&(x>lower)) return(&array[-0x10] - start);
        x=array[-0x0f];if((x<upper)&&(x>lower)) return(&array[-0x0f] - start);
        x=array[-0x0e];if((x<upper)&&(x>lower)) return(&array[-0x0e] - start);
        x=array[-0x0d];if((x<upper)&&(x>lower)) return(&array[-0x0d] - start);
        x=array[-0x0c];if((x<upper)&&(x>lower)) return(&array[-0x0c] - start);
        x=array[-0x0b];if((x<upper)&&(x>lower)) return(&array[-0x0b] - start);
        x=array[-0x0a];if((x<upper)&&(x>lower)) return(&array[-0x0a] - start);
        x=array[-0x09];if((x<upper)&&(x>lower)) return(&array[-0x09] - start);
        x=array[-0x08];if((x<upper)&&(x>lower)) return(&array[-0x08] - start);
        x=array[-0x07];if((x<upper)&&(x>lower)) return(&array[-0x07] - start);
        x=array[-0x06];if((x<upper)&&(x>lower)) return(&array[-0x06] - start);
        x=array[-0x05];if((x<upper)&&(x>lower)) return(&array[-0x05] - start);
        x=array[-0x04];if((x<upper)&&(x>lower)) return(&array[-0x04] - start);
        x=array[-0x03];if((x<upper)&&(x>lower)) return(&array[-0x03] - start);
        x=array[-0x02];if((x<upper)&&(x>lower)) return(&array[-0x02] - start);
        x=array[-0x01];if((x<upper)&&(x>lower)) return(&array[-0x01] - start);
    }
#endif
    while(len--)
    {
        x = *array;
        if((x < upper) && (x > lower))
            break;
        else
            array++;
    }
    return (array - start);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created       30-JAN-2003            Richard B. Johnson
//
//  This returns the array index to the first peak. It scans lowest to
//  the highest first to find the highest peak. It continues just in
//  case there are higher peaks after they start to decrease.
//
//  The return value is a floating point number that contains the
//  calculated "real" peak of the peak found. This is so one can
//  multiply the result by N and index into the Nth harmonic.
//

#define IF_PEAK(n) if(a[n] > pk) { pk = a[n]; ix = (&a[n] - b); }

double SIG::IndexToFirstPeak(double *a, int len)
{
    int ix, st;
    double pk, x, *b;
    b  = a;
    ix = 0;
    st = len;
    pk = -1.0;
#ifdef UNROLL
    while(len >=0x100)
    {
        a   += 0x100;
        len -= 0x100;
ALIGN;
        IF_PEAK(-0x100);
        IF_PEAK(-0x0ff);
        IF_PEAK(-0x0fe);
        IF_PEAK(-0x0fd);
        IF_PEAK(-0x0fc);
        IF_PEAK(-0x0fb);
        IF_PEAK(-0x0fa);
        IF_PEAK(-0x0f9);
        IF_PEAK(-0x0f8);
        IF_PEAK(-0x0f7);
        IF_PEAK(-0x0f6);
        IF_PEAK(-0x0f5);
        IF_PEAK(-0x0f4);
        IF_PEAK(-0x0f3);
        IF_PEAK(-0x0f2);
        IF_PEAK(-0x0f1);
        IF_PEAK(-0x0f0);
        IF_PEAK(-0x0ef);
        IF_PEAK(-0x0ee);
        IF_PEAK(-0x0ed);
        IF_PEAK(-0x0ec);
        IF_PEAK(-0x0eb);
        IF_PEAK(-0x0ea);
        IF_PEAK(-0x0e9);
        IF_PEAK(-0x0e8);
        IF_PEAK(-0x0e7);
        IF_PEAK(-0x0e6);
        IF_PEAK(-0x0e5);
        IF_PEAK(-0x0e4);
        IF_PEAK(-0x0e3);
        IF_PEAK(-0x0e2);
        IF_PEAK(-0x0e1);
        IF_PEAK(-0x0e0);
        IF_PEAK(-0x0df);
        IF_PEAK(-0x0de);
        IF_PEAK(-0x0dd);
        IF_PEAK(-0x0dc);
        IF_PEAK(-0x0db);
        IF_PEAK(-0x0da);
        IF_PEAK(-0x0d9);
        IF_PEAK(-0x0d8);
        IF_PEAK(-0x0d7);
        IF_PEAK(-0x0d6);
        IF_PEAK(-0x0d5);
        IF_PEAK(-0x0d4);
        IF_PEAK(-0x0d3);
        IF_PEAK(-0x0d2);
        IF_PEAK(-0x0d1);
        IF_PEAK(-0x0d0);
        IF_PEAK(-0x0cf);
        IF_PEAK(-0x0ce);
        IF_PEAK(-0x0cd);
        IF_PEAK(-0x0cc);
        IF_PEAK(-0x0cb);
        IF_PEAK(-0x0ca);
        IF_PEAK(-0x0c9);
        IF_PEAK(-0x0c8);
        IF_PEAK(-0x0c7);
        IF_PEAK(-0x0c6);
        IF_PEAK(-0x0c5);
        IF_PEAK(-0x0c4);
        IF_PEAK(-0x0c3);
        IF_PEAK(-0x0c2);
        IF_PEAK(-0x0c1);
        IF_PEAK(-0x0c0);
        IF_PEAK(-0x0bf);
        IF_PEAK(-0x0be);
        IF_PEAK(-0x0bd);
        IF_PEAK(-0x0bc);
        IF_PEAK(-0x0bb);
        IF_PEAK(-0x0ba);
        IF_PEAK(-0x0b9);
        IF_PEAK(-0x0b8);
        IF_PEAK(-0x0b7);
        IF_PEAK(-0x0b6);
        IF_PEAK(-0x0b5);
        IF_PEAK(-0x0b4);
        IF_PEAK(-0x0b3);
        IF_PEAK(-0x0b2);
        IF_PEAK(-0x0b1);
        IF_PEAK(-0x0b0);
        IF_PEAK(-0x0af);
        IF_PEAK(-0x0ae);
        IF_PEAK(-0x0ad);
        IF_PEAK(-0x0ac);
        IF_PEAK(-0x0ab);
        IF_PEAK(-0x0aa);
        IF_PEAK(-0x0a9);
        IF_PEAK(-0x0a8);
        IF_PEAK(-0x0a7);
        IF_PEAK(-0x0a6);
        IF_PEAK(-0x0a5);
        IF_PEAK(-0x0a4);
        IF_PEAK(-0x0a3);
        IF_PEAK(-0x0a2);
        IF_PEAK(-0x0a1);
        IF_PEAK(-0x0a0);
        IF_PEAK(-0x09f);
        IF_PEAK(-0x09e);
        IF_PEAK(-0x09d);
        IF_PEAK(-0x09c);
        IF_PEAK(-0x09b);
        IF_PEAK(-0x09a);
        IF_PEAK(-0x099);
        IF_PEAK(-0x098);
        IF_PEAK(-0x097);
        IF_PEAK(-0x096);
        IF_PEAK(-0x095);
        IF_PEAK(-0x094);
        IF_PEAK(-0x093);
        IF_PEAK(-0x092);
        IF_PEAK(-0x091);
        IF_PEAK(-0x090);
        IF_PEAK(-0x08f);
        IF_PEAK(-0x08e);
        IF_PEAK(-0x08d);
        IF_PEAK(-0x08c);
        IF_PEAK(-0x08b);
        IF_PEAK(-0x08a);
        IF_PEAK(-0x089);
        IF_PEAK(-0x088);
        IF_PEAK(-0x087);
        IF_PEAK(-0x086);
        IF_PEAK(-0x085);
        IF_PEAK(-0x084);
        IF_PEAK(-0x083);
        IF_PEAK(-0x082);
        IF_PEAK(-0x081);
        IF_PEAK(-0x080);
        IF_PEAK(-0x07f);
        IF_PEAK(-0x07e);
        IF_PEAK(-0x07d);
        IF_PEAK(-0x07c);
        IF_PEAK(-0x07b);
        IF_PEAK(-0x07a);
        IF_PEAK(-0x079);
        IF_PEAK(-0x078);
        IF_PEAK(-0x077);
        IF_PEAK(-0x076);
        IF_PEAK(-0x075);
        IF_PEAK(-0x074);
        IF_PEAK(-0x073);
        IF_PEAK(-0x072);
        IF_PEAK(-0x071);
        IF_PEAK(-0x070);
        IF_PEAK(-0x06f);
        IF_PEAK(-0x06e);
        IF_PEAK(-0x06d);
        IF_PEAK(-0x06c);
        IF_PEAK(-0x06b);
        IF_PEAK(-0x06a);
        IF_PEAK(-0x069);
        IF_PEAK(-0x068);
        IF_PEAK(-0x067);
        IF_PEAK(-0x066);
        IF_PEAK(-0x065);
        IF_PEAK(-0x064);
        IF_PEAK(-0x063);
        IF_PEAK(-0x062);
        IF_PEAK(-0x061);
        IF_PEAK(-0x060);
        IF_PEAK(-0x05f);
        IF_PEAK(-0x05e);
        IF_PEAK(-0x05d);
        IF_PEAK(-0x05c);
        IF_PEAK(-0x05b);
        IF_PEAK(-0x05a);
        IF_PEAK(-0x059);
        IF_PEAK(-0x058);
        IF_PEAK(-0x057);
        IF_PEAK(-0x056);
        IF_PEAK(-0x055);
        IF_PEAK(-0x054);
        IF_PEAK(-0x053);
        IF_PEAK(-0x052);
        IF_PEAK(-0x051);
        IF_PEAK(-0x050);
        IF_PEAK(-0x04f);
        IF_PEAK(-0x04e);
        IF_PEAK(-0x04d);
        IF_PEAK(-0x04c);
        IF_PEAK(-0x04b);
        IF_PEAK(-0x04a);
        IF_PEAK(-0x049);
        IF_PEAK(-0x048);
        IF_PEAK(-0x047);
        IF_PEAK(-0x046);
        IF_PEAK(-0x045);
        IF_PEAK(-0x044);
        IF_PEAK(-0x043);
        IF_PEAK(-0x042);
        IF_PEAK(-0x041);
        IF_PEAK(-0x040);
        IF_PEAK(-0x03f);
        IF_PEAK(-0x03e);
        IF_PEAK(-0x03d);
        IF_PEAK(-0x03c);
        IF_PEAK(-0x03b);
        IF_PEAK(-0x03a);
        IF_PEAK(-0x039);
        IF_PEAK(-0x038);
        IF_PEAK(-0x037);
        IF_PEAK(-0x036);
        IF_PEAK(-0x035);
        IF_PEAK(-0x034);
        IF_PEAK(-0x033);
        IF_PEAK(-0x032);
        IF_PEAK(-0x031);
        IF_PEAK(-0x030);
        IF_PEAK(-0x02f);
        IF_PEAK(-0x02e);
        IF_PEAK(-0x02d);
        IF_PEAK(-0x02c);
        IF_PEAK(-0x02b);
        IF_PEAK(-0x02a);
        IF_PEAK(-0x029);
        IF_PEAK(-0x028);
        IF_PEAK(-0x027);
        IF_PEAK(-0x026);
        IF_PEAK(-0x025);
        IF_PEAK(-0x024);
        IF_PEAK(-0x023);
        IF_PEAK(-0x022);
        IF_PEAK(-0x021);
        IF_PEAK(-0x020);
        IF_PEAK(-0x01f);
        IF_PEAK(-0x01e);
        IF_PEAK(-0x01d);
        IF_PEAK(-0x01c);
        IF_PEAK(-0x01b);
        IF_PEAK(-0x01a);
        IF_PEAK(-0x019);
        IF_PEAK(-0x018);
        IF_PEAK(-0x017);
        IF_PEAK(-0x016);
        IF_PEAK(-0x015);
        IF_PEAK(-0x014);
        IF_PEAK(-0x013);
        IF_PEAK(-0x012);
        IF_PEAK(-0x011);
        IF_PEAK(-0x010);
        IF_PEAK(-0x00f);
        IF_PEAK(-0x00e);
        IF_PEAK(-0x00d);
        IF_PEAK(-0x00c);
        IF_PEAK(-0x00b);
        IF_PEAK(-0x00a);
        IF_PEAK(-0x009);
        IF_PEAK(-0x008);
        IF_PEAK(-0x007);
        IF_PEAK(-0x006);
        IF_PEAK(-0x005);
        IF_PEAK(-0x004);
        IF_PEAK(-0x003);
        IF_PEAK(-0x002);
        IF_PEAK(-0x001);
    }
    while(len >=0x10)
    {
        a   += 0x10;
        len -= 0x10;
        IF_PEAK(-0x10);
        IF_PEAK(-0x0f);
        IF_PEAK(-0x0e);
        IF_PEAK(-0x0d);
        IF_PEAK(-0x0c);
        IF_PEAK(-0x0b);
        IF_PEAK(-0x0a);
        IF_PEAK(-0x09);
        IF_PEAK(-0x08);
        IF_PEAK(-0x07);
        IF_PEAK(-0x06);
        IF_PEAK(-0x05);
        IF_PEAK(-0x04);
        IF_PEAK(-0x03);
        IF_PEAK(-0x02);
        IF_PEAK(-0x01);
    }
#endif
    while(len)
    {
        if(*a > pk) { pk = *a; ix = (a - b); } a++; len--;
    }
    if(!ix) return (double)ix;

    x = (b[ix+1] - b[ix-1]) / (two * (b[ix-1] - two * b[ix] + b[ix+1]));
    DEB(printf("%f\n", (double)ix - x));
    return (double)ix - x;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//   Created 31-OCT-2002                   Richard B, Johnson
//
//   This returns the time (in samples) where the maximum slope has
//   occurred. This should happen at square and sine-wave zero crossings
//   as well as over-shoots, etc. Uses some loop-unrolling.
//
int SIG::TimeMaxSlope(double *array, int len)
{
    double  m, g, zero, *start, *where;
    g = zero = 0.0;
    start = where = array;
#ifdef UNROLL
    while (len > 0x10)     /* This is correct! Do NOT change. */
    {
        array += 0x10;
        len   -= 0x10;
        m = array[-0x10] - array[-0x0f]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x0f]; }
        m = array[-0x0f] - array[-0x0e]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x0e]; }
        m = array[-0x0e] - array[-0x0d]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x0d]; }
        m = array[-0x0d] - array[-0x0c]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x0c]; }
        m = array[-0x0c] - array[-0x0b]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x0b]; }
        m = array[-0x0b] - array[-0x0a]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x0a]; }
        m = array[-0x0a] - array[-0x09]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x09]; }
        m = array[-0x09] - array[-0x08]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x08]; }
        m = array[-0x08] - array[-0x07]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x07]; }
        m = array[-0x07] - array[-0x06]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x06]; }
        m = array[-0x06] - array[-0x05]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x05]; }
        m = array[-0x05] - array[-0x04]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x04]; }
        m = array[-0x04] - array[-0x03]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x03]; }
        m = array[-0x03] - array[-0x02]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x02]; }
        m = array[-0x02] - array[-0x01]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x01]; }
        m = array[-0x01] - array[-0x00]; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = &array[-0x00]; }
    }
#endif
    while(--len)        /* Correct, one-less than array elements */
    {
        m  = *array++; m -= *array; m = (m > zero) ? m : -m;
        if(m > g){g = m; where = array; }
    }
    return (where - start);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created      31-OCT-2002 RBJ            Richard B. Johnson
//
//  This returns the time (in samples) of the first positive reference
//  crossing. This returns the array length if the entire thing was
//  searched without finding a crossing. Uses some loop-unrolling.
//

#define IF_LESS(n) if(ref <= array[n]) return (&array[n] - start)
#define IF_MORE(n) if(ref >= array[n]) return (&array[n] - start)

int SIG::TimeToPosRef(double *array, double ref, int len)
{
    double *start = array;
#ifdef UNROLL
    while(len >= 0x10)
    {
        array += 0x10;
        len   -= 0x10;
        IF_LESS(-0x10);
        IF_LESS(-0x0f);
        IF_LESS(-0x0e);
        IF_LESS(-0x0d);
        IF_LESS(-0x0c);
        IF_LESS(-0x0b);
        IF_LESS(-0x0a);
        IF_LESS(-0x09);
        IF_LESS(-0x08);
        IF_LESS(-0x07);
        IF_LESS(-0x06);
        IF_LESS(-0x05);
        IF_LESS(-0x04);
        IF_LESS(-0x03);
        IF_LESS(-0x02);
        IF_LESS(-0x01);
    }
#endif
    while(len--)
        if(ref < *array)
            break;
        else
            array++;
    return (array - start);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created   31-OCT-2002            Richard B. Johnson
//
//  This returns the time (in samples) of the first negative reference
//  crossing. This returns the array length if the entire thing was
//  searched without finding a crossing. Uses some loop-unrolling.
//
int SIG::TimeToNegRef(double *array, double ref, int len)
{
    double *start = array;
#ifdef UNROLL
    while(len >= 0x10)
    {
        array += 0x10;
        len   -= 0x10;
        IF_MORE(-0x10);
        IF_MORE(-0x0f);
        IF_MORE(-0x0e);
        IF_MORE(-0x0d);
        IF_MORE(-0x0c);
        IF_MORE(-0x0b);
        IF_MORE(-0x0a);
        IF_MORE(-0x09);
        IF_MORE(-0x08);
        IF_MORE(-0x07);
        IF_MORE(-0x06);
        IF_MORE(-0x05);
        IF_MORE(-0x04);
        IF_MORE(-0x03);
        IF_MORE(-0x02);
        IF_MORE(-0x01);
    }
#endif
    while(len--)
        if(ref > *array)
            break;
        else
            array++;
    return (array - start);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 30-OCT-2002                        Richard B. Johnson
//
//  This returns the time (in samples) to the first reference crossing.
//  Note that if the reference is greater than the first sample, you
//  will have the time to the first positive-going crossing. If the
//  reference is less than the first sample, you will have the time to
//  the first  negative-going crossing. If no such crossing exists,
//  this returns the length of the array, i.e., it searched the entire
//  array and found no such crossing. Uses some loop-unrolling.
//

int SIG::TimeToReference(double *array, double ref, int len)
{
    double *start = array;
    if(ref >= array[0])
    {
#ifdef UNROLL
        while(len >= 0x10)
        {
            array += 0x10;
            len   -= 0x10;
            IF_LESS(-0x10);
            IF_LESS(-0x0f);
            IF_LESS(-0x0e);
            IF_LESS(-0x0d);
            IF_LESS(-0x0c);
            IF_LESS(-0x0b);
            IF_LESS(-0x0a);
            IF_LESS(-0x09);
            IF_LESS(-0x08);
            IF_LESS(-0x07);
            IF_LESS(-0x06);
            IF_LESS(-0x05);
            IF_LESS(-0x04);
            IF_LESS(-0x03);
            IF_LESS(-0x02);
            IF_LESS(-0x01);
        }
#endif
        while(len--)
            if(ref < *array)
                break;
            else
                array++;
    }
    else
    {
#ifdef UNROLL
        while(len >= 0x10)
        {
            array += 0x10;
            len   -= 0x10;
            IF_MORE(-0x10);
            IF_MORE(-0x0f);
            IF_MORE(-0x0e);
            IF_MORE(-0x0d);
            IF_MORE(-0x0c);
            IF_MORE(-0x0b);
            IF_MORE(-0x0a);
            IF_MORE(-0x09);
            IF_MORE(-0x08);
            IF_MORE(-0x07);
            IF_MORE(-0x06);
            IF_MORE(-0x05);
            IF_MORE(-0x04);
            IF_MORE(-0x03);
            IF_MORE(-0x02);
            IF_MORE(-0x01);
        }
#endif
        while(len--)
            if(ref > *array)
                break;
            else
                array++;
    }
    return (array - start);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created 30-OCT-2002                    Richard B. Johnson
//  This returns the number of times that a waveform crosses the
//  reference level.
//
int SIG::NrCrossRefLevel(double *array, double ref, int len)
{
    int times;
    int ret;
    times = 0;
    while((ret = TimeToReference(array, ref, len)) < len)
    {
       len -= ret;
       array += ret;
       times++;
    }
    return times;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created   23-OCT-2002                   Richard B. Johnson
//
//  Measures the mean of all the values in an array. Uses some
//  loop-unrolling.
//

#define DO_MEAN(n) mean += array[n]

double SIG::MeasMean(double *array, int len)
{
    double nr, mean;
    nr = (double) len;
    mean = 0.0;
#ifdef UNROLL
    while(len >= 0x100)
    {
        array += 0x100;
        len   -= 0x100;
ALIGN;
        DO_MEAN(-0x100);
        DO_MEAN(-0x0ff);
        DO_MEAN(-0x0fe);
        DO_MEAN(-0x0fd);
        DO_MEAN(-0x0fc);
        DO_MEAN(-0x0fb);
        DO_MEAN(-0x0fa);
        DO_MEAN(-0x0f9);
        DO_MEAN(-0x0f8);
        DO_MEAN(-0x0f7);
        DO_MEAN(-0x0f6);
        DO_MEAN(-0x0f5);
        DO_MEAN(-0x0f4);
        DO_MEAN(-0x0f3);
        DO_MEAN(-0x0f2);
        DO_MEAN(-0x0f1);
        DO_MEAN(-0x0f0);
        DO_MEAN(-0x0ef);
        DO_MEAN(-0x0ee);
        DO_MEAN(-0x0ed);
        DO_MEAN(-0x0ec);
        DO_MEAN(-0x0eb);
        DO_MEAN(-0x0ea);
        DO_MEAN(-0x0e9);
        DO_MEAN(-0x0e8);
        DO_MEAN(-0x0e7);
        DO_MEAN(-0x0e6);
        DO_MEAN(-0x0e5);
        DO_MEAN(-0x0e4);
        DO_MEAN(-0x0e3);
        DO_MEAN(-0x0e2);
        DO_MEAN(-0x0e1);
        DO_MEAN(-0x0e0);
        DO_MEAN(-0x0df);
        DO_MEAN(-0x0de);
        DO_MEAN(-0x0dd);
        DO_MEAN(-0x0dc);
        DO_MEAN(-0x0db);
        DO_MEAN(-0x0da);
        DO_MEAN(-0x0d9);
        DO_MEAN(-0x0d8);
        DO_MEAN(-0x0d7);
        DO_MEAN(-0x0d6);
        DO_MEAN(-0x0d5);
        DO_MEAN(-0x0d4);
        DO_MEAN(-0x0d3);
        DO_MEAN(-0x0d2);
        DO_MEAN(-0x0d1);
        DO_MEAN(-0x0d0);
        DO_MEAN(-0x0cf);
        DO_MEAN(-0x0ce);
        DO_MEAN(-0x0cd);
        DO_MEAN(-0x0cc);
        DO_MEAN(-0x0cb);
        DO_MEAN(-0x0ca);
        DO_MEAN(-0x0c9);
        DO_MEAN(-0x0c8);
        DO_MEAN(-0x0c7);
        DO_MEAN(-0x0c6);
        DO_MEAN(-0x0c5);
        DO_MEAN(-0x0c4);
        DO_MEAN(-0x0c3);
        DO_MEAN(-0x0c2);
        DO_MEAN(-0x0c1);
        DO_MEAN(-0x0c0);
        DO_MEAN(-0x0bf);
        DO_MEAN(-0x0be);
        DO_MEAN(-0x0bd);
        DO_MEAN(-0x0bc);
        DO_MEAN(-0x0bb);
        DO_MEAN(-0x0ba);
        DO_MEAN(-0x0b9);
        DO_MEAN(-0x0b8);
        DO_MEAN(-0x0b7);
        DO_MEAN(-0x0b6);
        DO_MEAN(-0x0b5);
        DO_MEAN(-0x0b4);
        DO_MEAN(-0x0b3);
        DO_MEAN(-0x0b2);
        DO_MEAN(-0x0b1);
        DO_MEAN(-0x0b0);
        DO_MEAN(-0x0af);
        DO_MEAN(-0x0ae);
        DO_MEAN(-0x0ad);
        DO_MEAN(-0x0ac);
        DO_MEAN(-0x0ab);
        DO_MEAN(-0x0aa);
        DO_MEAN(-0x0a9);
        DO_MEAN(-0x0a8);
        DO_MEAN(-0x0a7);
        DO_MEAN(-0x0a6);
        DO_MEAN(-0x0a5);
        DO_MEAN(-0x0a4);
        DO_MEAN(-0x0a3);
        DO_MEAN(-0x0a2);
        DO_MEAN(-0x0a1);
        DO_MEAN(-0x0a0);
        DO_MEAN(-0x09f);
        DO_MEAN(-0x09e);
        DO_MEAN(-0x09d);
        DO_MEAN(-0x09c);
        DO_MEAN(-0x09b);
        DO_MEAN(-0x09a);
        DO_MEAN(-0x099);
        DO_MEAN(-0x098);
        DO_MEAN(-0x097);
        DO_MEAN(-0x096);
        DO_MEAN(-0x095);
        DO_MEAN(-0x094);
        DO_MEAN(-0x093);
        DO_MEAN(-0x092);
        DO_MEAN(-0x091);
        DO_MEAN(-0x090);
        DO_MEAN(-0x08f);
        DO_MEAN(-0x08e);
        DO_MEAN(-0x08d);
        DO_MEAN(-0x08c);
        DO_MEAN(-0x08b);
        DO_MEAN(-0x08a);
        DO_MEAN(-0x089);
        DO_MEAN(-0x088);
        DO_MEAN(-0x087);
        DO_MEAN(-0x086);
        DO_MEAN(-0x085);
        DO_MEAN(-0x084);
        DO_MEAN(-0x083);
        DO_MEAN(-0x082);
        DO_MEAN(-0x081);
        DO_MEAN(-0x080);
        DO_MEAN(-0x07f);
        DO_MEAN(-0x07e);
        DO_MEAN(-0x07d);
        DO_MEAN(-0x07c);
        DO_MEAN(-0x07b);
        DO_MEAN(-0x07a);
        DO_MEAN(-0x079);
        DO_MEAN(-0x078);
        DO_MEAN(-0x077);
        DO_MEAN(-0x076);
        DO_MEAN(-0x075);
        DO_MEAN(-0x074);
        DO_MEAN(-0x073);
        DO_MEAN(-0x072);
        DO_MEAN(-0x071);
        DO_MEAN(-0x070);
        DO_MEAN(-0x06f);
        DO_MEAN(-0x06e);
        DO_MEAN(-0x06d);
        DO_MEAN(-0x06c);
        DO_MEAN(-0x06b);
        DO_MEAN(-0x06a);
        DO_MEAN(-0x069);
        DO_MEAN(-0x068);
        DO_MEAN(-0x067);
        DO_MEAN(-0x066);
        DO_MEAN(-0x065);
        DO_MEAN(-0x064);
        DO_MEAN(-0x063);
        DO_MEAN(-0x062);
        DO_MEAN(-0x061);
        DO_MEAN(-0x060);
        DO_MEAN(-0x05f);
        DO_MEAN(-0x05e);
        DO_MEAN(-0x05d);
        DO_MEAN(-0x05c);
        DO_MEAN(-0x05b);
        DO_MEAN(-0x05a);
        DO_MEAN(-0x059);
        DO_MEAN(-0x058);
        DO_MEAN(-0x057);
        DO_MEAN(-0x056);
        DO_MEAN(-0x055);
        DO_MEAN(-0x054);
        DO_MEAN(-0x053);
        DO_MEAN(-0x052);
        DO_MEAN(-0x051);
        DO_MEAN(-0x050);
        DO_MEAN(-0x04f);
        DO_MEAN(-0x04e);
        DO_MEAN(-0x04d);
        DO_MEAN(-0x04c);
        DO_MEAN(-0x04b);
        DO_MEAN(-0x04a);
        DO_MEAN(-0x049);
        DO_MEAN(-0x048);
        DO_MEAN(-0x047);
        DO_MEAN(-0x046);
        DO_MEAN(-0x045);
        DO_MEAN(-0x044);
        DO_MEAN(-0x043);
        DO_MEAN(-0x042);
        DO_MEAN(-0x041);
        DO_MEAN(-0x040);
        DO_MEAN(-0x03f);
        DO_MEAN(-0x03e);
        DO_MEAN(-0x03d);
        DO_MEAN(-0x03c);
        DO_MEAN(-0x03b);
        DO_MEAN(-0x03a);
        DO_MEAN(-0x039);
        DO_MEAN(-0x038);
        DO_MEAN(-0x037);
        DO_MEAN(-0x036);
        DO_MEAN(-0x035);
        DO_MEAN(-0x034);
        DO_MEAN(-0x033);
        DO_MEAN(-0x032);
        DO_MEAN(-0x031);
        DO_MEAN(-0x030);
        DO_MEAN(-0x02f);
        DO_MEAN(-0x02e);
        DO_MEAN(-0x02d);
        DO_MEAN(-0x02c);
        DO_MEAN(-0x02b);
        DO_MEAN(-0x02a);
        DO_MEAN(-0x029);
        DO_MEAN(-0x028);
        DO_MEAN(-0x027);
        DO_MEAN(-0x026);
        DO_MEAN(-0x025);
        DO_MEAN(-0x024);
        DO_MEAN(-0x023);
        DO_MEAN(-0x022);
        DO_MEAN(-0x021);
        DO_MEAN(-0x020);
        DO_MEAN(-0x01f);
        DO_MEAN(-0x01e);
        DO_MEAN(-0x01d);
        DO_MEAN(-0x01c);
        DO_MEAN(-0x01b);
        DO_MEAN(-0x01a);
        DO_MEAN(-0x019);
        DO_MEAN(-0x018);
        DO_MEAN(-0x017);
        DO_MEAN(-0x016);
        DO_MEAN(-0x015);
        DO_MEAN(-0x014);
        DO_MEAN(-0x013);
        DO_MEAN(-0x012);
        DO_MEAN(-0x011);
        DO_MEAN(-0x010);
        DO_MEAN(-0x00f);
        DO_MEAN(-0x00e);
        DO_MEAN(-0x00d);
        DO_MEAN(-0x00c);
        DO_MEAN(-0x00b);
        DO_MEAN(-0x00a);
        DO_MEAN(-0x009);
        DO_MEAN(-0x008);
        DO_MEAN(-0x007);
        DO_MEAN(-0x006);
        DO_MEAN(-0x005);
        DO_MEAN(-0x004);
        DO_MEAN(-0x003);
        DO_MEAN(-0x002);
        DO_MEAN(-0x001);
    }
    while(len >= 0x10)
    {
        array += 0x10;
        len   -= 0x10;
        DO_MEAN(-0x10);
        DO_MEAN(-0x0f);
        DO_MEAN(-0x0e);
        DO_MEAN(-0x0d);
        DO_MEAN(-0x0c);
        DO_MEAN(-0x0b);
        DO_MEAN(-0x0a);
        DO_MEAN(-0x09);
        DO_MEAN(-0x08);
        DO_MEAN(-0x07);
        DO_MEAN(-0x06);
        DO_MEAN(-0x05);
        DO_MEAN(-0x04);
        DO_MEAN(-0x03);
        DO_MEAN(-0x02);
        DO_MEAN(-0x01);
    }
#endif
    while(len--)
        mean += *array++;
    return mean/(nr+ZERO);
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
//  Created  23-OCT-2002             Richard B. Johnson
//  Measures the variance in all values of an array. Uses some
//  loop-unrolling.
//
double SIG::MeasVariance(double *array, int len)
{
    double ave, var, x, nr;
    var = 0.0;
    nr  = (double) len - one;
    ave = MeasMean(array, len);
#ifdef UNROLL
    while(len >= 0x100)
    {
        array += 0x100;
        len   -= 0x100;
ALIGN;
        x = array[-0x100] - ave; var += (x * x);
        x = array[-0x0ff] - ave; var += (x * x);
        x = array[-0x0fe] - ave; var += (x * x);
        x = array[-0x0fd] - ave; var += (x * x);
        x = array[-0x0fc] - ave; var += (x * x);
        x = array[-0x0fb] - ave; var += (x * x);
        x = array[-0x0fa] - ave; var += (x * x);
        x = array[-0x0f9] - ave; var += (x * x);
        x = array[-0x0f8] - ave; var += (x * x);
        x = array[-0x0f7] - ave; var += (x * x);
        x = array[-0x0f6] - ave; var += (x * x);
        x = array[-0x0f5] - ave; var += (x * x);
        x = array[-0x0f4] - ave; var += (x * x);
        x = array[-0x0f3] - ave; var += (x * x);
        x = array[-0x0f2] - ave; var += (x * x);
        x = array[-0x0f1] - ave; var += (x * x);
        x = array[-0x0f0] - ave; var += (x * x);
        x = array[-0x0ef] - ave; var += (x * x);
        x = array[-0x0ee] - ave; var += (x * x);
        x = array[-0x0ed] - ave; var += (x * x);
        x = array[-0x0ec] - ave; var += (x * x);
        x = array[-0x0eb] - ave; var += (x * x);
        x = array[-0x0ea] - ave; var += (x * x);
        x = array[-0x0e9] - ave; var += (x * x);
        x = array[-0x0e8] - ave; var += (x * x);
        x = array[-0x0e7] - ave; var += (x * x);
        x = array[-0x0e6] - ave; var += (x * x);
        x = array[-0x0e5] - ave; var += (x * x);
        x = array[-0x0e4] - ave; var += (x * x);
        x = array[-0x0e3] - ave; var += (x * x);
        x = array[-0x0e2] - ave; var += (x * x);
        x = array[-0x0e1] - ave; var += (x * x);
        x = array[-0x0e0] - ave; var += (x * x);
        x = array[-0x0df] - ave; var += (x * x);
        x = array[-0x0de] - ave; var += (x * x);
        x = array[-0x0dd] - ave; var += (x * x);
        x = array[-0x0dc] - ave; var += (x * x);
        x = array[-0x0db] - ave; var += (x * x);
        x = array[-0x0da] - ave; var += (x * x);
        x = array[-0x0d9] - ave; var += (x * x);
        x = array[-0x0d8] - ave; var += (x * x);
        x = array[-0x0d7] - ave; var += (x * x);
        x = array[-0x0d6] - ave; var += (x * x);
        x = array[-0x0d5] - ave; var += (x * x);
        x = array[-0x0d4] - ave; var += (x * x);
        x = array[-0x0d3] - ave; var += (x * x);
        x = array[-0x0d2] - ave; var += (x * x);
        x = array[-0x0d1] - ave; var += (x * x);
        x = array[-0x0d0] - ave; var += (x * x);
        x = array[-0x0cf] - ave; var += (x * x);
        x = array[-0x0ce] - ave; var += (x * x);
        x = array[-0x0cd] - ave; var += (x * x);
        x = array[-0x0cc] - ave; var += (x * x);
        x = array[-0x0cb] - ave; var += (x * x);
        x = array[-0x0ca] - ave; var += (x * x);
        x = array[-0x0c9] - ave; var += (x * x);
        x = array[-0x0c8] - ave; var += (x * x);
        x = array[-0x0c7] - ave; var += (x * x);
        x = array[-0x0c6] - ave; var += (x * x);
        x = array[-0x0c5] - ave; var += (x * x);
        x = array[-0x0c4] - ave; var += (x * x);
        x = array[-0x0c3] - ave; var += (x * x);
        x = array[-0x0c2] - ave; var += (x * x);
        x = array[-0x0c1] - ave; var += (x * x);
        x = array[-0x0c0] - ave; var += (x * x);
        x = array[-0x0bf] - ave; var += (x * x);
        x = array[-0x0be] - ave; var += (x * x);
        x = array[-0x0bd] - ave; var += (x * x);
        x = array[-0x0bc] - ave; var += (x * x);
        x = array[-0x0bb] - ave; var += (x * x);
        x = array[-0x0ba] - ave; var += (x * x);
        x = array[-0x0b9] - ave; var += (x * x);
        x = array[-0x0b8] - ave; var += (x * x);
        x = array[-0x0b7] - ave; var += (x * x);
        x = array[-0x0b6] - ave; var += (x * x);
        x = array[-0x0b5] - ave; var += (x * x);
        x = array[-0x0b4] - ave; var += (x * x);
        x = array[-0x0b3] - ave; var += (x * x);
        x = array[-0x0b2] - ave; var += (x * x);
        x = array[-0x0b1] - ave; var += (x * x);
        x = array[-0x0b0] - ave; var += (x * x);
        x = array[-0x0af] - ave; var += (x * x);
        x = array[-0x0ae] - ave; var += (x * x);
        x = array[-0x0ad] - ave; var += (x * x);
        x = array[-0x0ac] - ave; var += (x * x);
        x = array[-0x0ab] - ave; var += (x * x);
        x = array[-0x0aa] - ave; var += (x * x);
        x = array[-0x0a9] - ave; var += (x * x);
        x = array[-0x0a8] - ave; var += (x * x);
        x = array[-0x0a7] - ave; var += (x * x);
        x = array[-0x0a6] - ave; var += (x * x);
        x = array[-0x0a5] - ave; var += (x * x);
        x = array[-0x0a4] - ave; var += (x * x);
        x = array[-0x0a3] - ave; var += (x * x);
        x = array[-0x0a2] - ave; var += (x * x);
        x = array[-0x0a1] - ave; var += (x * x);
        x = array[-0x0a0] - ave; var += (x * x);
        x = array[-0x09f] - ave; var += (x * x);
        x = array[-0x09e] - ave; var += (x * x);
        x = array[-0x09d] - ave; var += (x * x);
        x = array[-0x09c] - ave; var += (x * x);
        x = array[-0x09b] - ave; var += (x * x);
        x = array[-0x09a] - ave; var += (x * x);
        x = array[-0x099] - ave; var += (x * x);
        x = array[-0x098] - ave; var += (x * x);
        x = array[-0x097] - ave; var += (x * x);
        x = array[-0x096] - ave; var += (x * x);
        x = array[-0x095] - ave; var += (x * x);
        x = array[-0x094] - ave; var += (x * x);
        x = array[-0x093] - ave; var += (x * x);
        x = array[-0x092] - ave; var += (x * x);
        x = array[-0x091] - ave; var += (x * x);
        x = array[-0x090] - ave; var += (x * x);
        x = array[-0x08f] - ave; var += (x * x);
        x = array[-0x08e] - ave; var += (x * x);
        x = array[-0x08d] - ave; var += (x * x);
        x = array[-0x08c] - ave; var += (x * x);
        x = array[-0x08b] - ave; var += (x * x);
        x = array[-0x08a] - ave; var += (x * x);
        x = array[-0x089] - ave; var += (x * x);
        x = array[-0x088] - ave; var += (x * x);
        x = array[-0x087] - ave; var += (x * x);
        x = array[-0x086] - ave; var += (x * x);
        x = array[-0x085] - ave; var += (x * x);
        x = array[-0x084] - ave; var += (x * x);
        x = array[-0x083] - ave; var += (x * x);
        x = array[-0x082] - ave; var += (x * x);
        x = array[-0x081] - ave; var += (x * x);
        x = array[-0x080] - ave; var += (x * x);
        x = array[-0x07f] - ave; var += (x * x);
        x = array[-0x07e] - ave; var += (x * x);
        x = array[-0x07d] - ave; var += (x * x);
        x = array[-0x07c] - ave; var += (x * x);
        x = array[-0x07b] - ave; var += (x * x);
        x = array[-0x07a] - ave; var += (x * x);
        x = array[-0x079] - ave; var += (x * x);
        x = array[-0x078] - ave; var += (x * x);
        x = array[-0x077] - ave; var += (x * x);
        x = array[-0x076] - ave; var += (x * x);
        x = array[-0x075] - ave; var += (x * x);
        x = array[-0x074] - ave; var += (x * x);
        x = array[-0x073] - ave; var += (x * x);
        x = array[-0x072] - ave; var += (x * x);
        x = array[-0x071] - ave; var += (x * x);
        x = array[-0x070] - ave; var += (x * x);
        x = array[-0x06f] - ave; var += (x * x);
        x = array[-0x06e] - ave; var += (x * x);
        x = array[-0x06d] - ave; var += (x * x);
        x = array[-0x06c] - ave; var += (x * x);
        x = array[-0x06b] - ave; var += (x * x);
        x = array[-0x06a] - ave; var += (x * x);
        x = array[-0x069] - ave; var += (x * x);
        x = array[-0x068] - ave; var += (x * x);
        x = array[-0x067] - ave; var += (x * x);
        x = array[-0x066] - ave; var += (x * x);
        x = array[-0x065] - ave; var += (x * x);
        x = array[-0x064] - ave; var += (x * x);
        x = array[-0x063] - ave; var += (x * x);
        x = array[-0x062] - ave; var += (x * x);
        x = array[-0x061] - ave; var += (x * x);
        x = array[-0x060] - ave; var += (x * x);
        x = array[-0x05f] - ave; var += (x * x);
        x = array[-0x05e] - ave; var += (x * x);
        x = array[-0x05d] - ave; var += (x * x);
        x = array[-0x05c] - ave; var += (x * x);
        x = array[-0x05b] - ave; var += (x * x);
        x = array[-0x05a] - ave; var += (x * x);
        x = array[-0x059] - ave; var += (x * x);
        x = array[-0x058] - ave; var += (x * x);
        x = array[-0x057] - ave; var += (x * x);
        x = array[-0x056] - ave; var += (x * x);
        x = array[-0x055] - ave; var += (x * x);
        x = array[-0x054] - ave; var += (x * x);
        x = array[-0x053] - ave; var += (x * x);
        x = array[-0x052] - ave; var += (x * x);
        x = array[-0x051] - ave; var += (x * x);
        x = array[-0x050] - ave; var += (x * x);
        x = array[-0x04f] - ave; var += (x * x);
        x = array[-0x04e] - ave; var += (x * x);
        x = array[-0x04d] - ave; var += (x * x);
        x = array[-0x04c] - ave; var += (x * x);
        x = array[-0x04b] - ave; var += (x * x);
        x = array[-0x04a] - ave; var += (x * x);
        x = array[-0x049] - ave; var += (x * x);
        x = array[-0x048] - ave; var += (x * x);
        x = array[-0x047] - ave; var += (x * x);
        x = array[-0x046] - ave; var += (x * x);
        x = array[-0x045] - ave; var += (x * x);
        x = array[-0x044] - ave; var += (x * x);
        x = array[-0x043] - ave; var += (x * x);
        x = array[-0x042] - ave; var += (x * x);
        x = array[-0x041] - ave; var += (x * x);
        x = array[-0x040] - ave; var += (x * x);
        x = array[-0x03f] - ave; var += (x * x);
        x = array[-0x03e] - ave; var += (x * x);
        x = array[-0x03d] - ave; var += (x * x);
        x = array[-0x03c] - ave; var += (x * x);
        x = array[-0x03b] - ave; var += (x * x);
        x = array[-0x03a] - ave; var += (x * x);
        x = array[-0x039] - ave; var += (x * x);
        x = array[-0x038] - ave; var += (x * x);
        x = array[-0x037] - ave; var += (x * x);
        x = array[-0x036] - ave; var += (x * x);
        x = array[-0x035] - ave; var += (x * x);
        x = array[-0x034] - ave; var += (x * x);
        x = array[-0x033] - ave; var += (x * x);
        x = array[-0x032] - ave; var += (x * x);
        x = array[-0x031] - ave; var += (x * x);
        x = array[-0x030] - ave; var += (x * x);
        x = array[-0x02f] - ave; var += (x * x);
        x = array[-0x02e] - ave; var += (x * x);
        x = array[-0x02d] - ave; var += (x * x);
        x = array[-0x02c] - ave; var += (x * x);
        x = array[-0x02b] - ave; var += (x * x);
        x = array[-0x02a] - ave; var += (x * x);
        x = array[-0x029] - ave; var += (x * x);
        x = array[-0x028] - ave; var += (x * x);
        x = array[-0x027] - ave; var += (x * x);
        x = array[-0x026] - ave; var += (x * x);
        x = array[-0x025] - ave; var += (x * x);
        x = array[-0x024] - ave; var += (x * x);
        x = array[-0x023] - ave; var += (x * x);
        x = array[-0x022] - ave; var += (x * x);
        x = array[-0x021] - ave; var += (x * x);
        x = array[-0x020] - ave; var += (x * x);
        x = array[-0x01f] - ave; var += (x * x);
        x = array[-0x01e] - ave; var += (x * x);
        x = array[-0x01d] - ave; var += (x * x);
        x = array[-0x01c] - ave; var += (x * x);
        x = array[-0x01b] - ave; var += (x * x);
        x = array[-0x01a] - ave; var += (x * x);
        x = array[-0x019] - ave; var += (x * x);
        x = array[-0x018] - ave; var += (x * x);
        x = array[-0x017] - ave; var += (x * x);
        x = array[-0x016] - ave; var += (x * x);
        x = array[-0x015] - ave; var += (x * x);
        x = array[-0x014] - ave; var += (x * x);
        x = array[-0x013] - ave; var += (x * x);
        x = array[-0x012] - ave; var += (x * x);
        x = array[-0x011] - ave; var += (x * x);
        x = array[-0x010] - ave; var += (x * x);
        x = array[-0x00f] - ave; var += (x * x);
        x = array[-0x00e] - ave; var += (x * x);
        x = array[-0x00d] - ave; var += (x * x);
        x = array[-0x00c] - ave; var += (x * x);
        x = array[-0x00b] - ave; var += (x * x);
        x = array[-0x00a] - ave; var += (x * x);
        x = array[-0x009] - ave; var += (x * x);
        x = array[-0x008] - ave; var += (x * x);
        x = array[-0x007] - ave; var += (x * x);
        x = array[-0x006] - ave; var += (x * x);
        x = array[-0x005] - ave; var += (x * x);
        x = array[-0x004] - ave; var += (x * x);
        x = array[-0x003] - ave; var += (x * x);
        x = array[-0x002] - ave; var += (x * x);
        x = array[-0x001] - ave; var += (x * x);
    }
    while(len >= 0x10)
    {
        array += 0x10;
        len   -= 0x10;
        x = array[-0x10] - ave; var += (x * x);
        x = array[-0x0f] - ave; var += (x * x);
        x = array[-0x0e] - ave; var += (x * x);
        x = array[-0x0d] - ave; var += (x * x);
        x = array[-0x0c] - ave; var += (x * x);
        x = array[-0x0b] - ave; var += (x * x);
        x = array[-0x0a] - ave; var += (x * x);
        x = array[-0x09] - ave; var += (x * x);
        x = array[-0x08] - ave; var += (x * x);
        x = array[-0x07] - ave; var += (x * x);
        x = array[-0x06] - ave; var += (x * x);
        x = array[-0x05] - ave; var += (x * x);
        x = array[-0x04] - ave; var += (x * x);
        x = array[-0x03] - ave; var += (x * x);
        x = array[-0x02] - ave; var += (x * x);
        x = array[-0x01] - ave; var += (x * x);
    }
#endif
    while(len--)
    {
        x = *array++ - ave;
        var += (x * x);
    }
    return var/nr;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*
//
//  Created  23-OCT-2002              Richard B. Johnson
//
//  Measures the standard deviation of all values of an array.
//
double SIG::MeasStdDev(double *array, int len)
{
    return sqrt(MeasVariance(array, len));
}


//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*
//
//
//   File: parse_fft.c    Created 12-MAY-2007     Richard B. Johnson
//                                                RichardBJohnson@comcast.net
//
//   The data, text, and source-code within these files are presumed to
//   be accurate and free of encumbrances. Use at your own risk.
//
//   parse_fft - calculate one-dimensional fast fourier transforms
//
//   Originally created 23-AUG-2002 by Carl Crawford
//
//   Modified:   30-JAN-2003    Richard B. Johnson
//   Changed "float" types to FLOAT so they can be double.
//   Got constant PI from 'C' runtime library.
//   Reformatted and simplified a bit.
//


#include <math.h>
#if !defined(PI)
# define PI 3.1415926535897932384626433832795029  /* pi */
#endif
#define FLOAT double
void SIG::parse_fft (
    FLOAT *a,   // real part of data
    FLOAT *b,   // imaginary part of data
    int m,      // size of data = 2**m 
    int iopt    // 0=dft, 1=idft

)
{
        int     nv2,nm1,n,le,le1,ip;
        FLOAT   ua,ub,wa,wb,ta,tb,*ap,*bp;
        FLOAT   pi,pile1,tmp;
        register int i,j,l;
        pi = PI;
        n = 1<<m;
        if(iopt)
        {
                for(i=0,ap=a,bp=b;i<n;i++)
                {
                        *ap++ /= n;
                        *bp++ /= -n;
                }
        }
        nv2 = n>>1;
        nm1 = n - 1;
        for(i=j=0;i<nm1;i++)
        {
                if(i<j)
                {
                        ta = a[j];
                        tb = b[j];
                        a[j] = a[i];
                        b[j] = b[i];
                        a[i] = ta;
                        b[i] = tb;
                }
                l = nv2;
                while(l < (j+1))
                {
                        j -= l;
                        l = l >> 1;
                }
                j += l;
        }
        for(l=1;l<=m;l++)
        {
                le = 1<<l;
                le1 = le>>1;
                ua = 1.0;
                ub = 0.0;
                pile1 = pi / le1;
                wa = cos(pile1);
                wb = -sin(pile1);
                for(j=0;j<le1;j++)
                {
                        for(i=j;i<n;i += le)
                        {
                                ip = i + le1;
                                ta = a[ip] * ua - b[ip] * ub;
                                tb = a[ip] * ub + b[ip] * ua;
                                a[ip] = a[i] - ta;
                                b[ip] = b[i] - tb;
                                a[i] += ta;
                                b[i] += tb;
                        }
                        ua = (tmp = ua) * wa - ub * wb;
                        ub = tmp * wb + ub * wa;
                }
        }
        if(iopt)
        {
                for(i=0;i<n;i++)b[i] = -b[i];
        }
}

//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-
//
// METHOD NAME
//
//   MultArray
//
//  Author:                      20-JUL-2008      Richard B. Johnson
//
// DESCRIPTION
//
//  This routine with multiply the values in two input arrays and leave the
//  result in the output array.
//
// INPUTS
//
//   Pointer to start of data out
//   Pointer to start of data in1
//   Pointer to start of data in2
//   Length of array len
//
//
// OUTPUTS
//
//   Result value in out
//

#define MULT_ARRAY(a) out[a] = in1[a] * in2[a]


void SIG::MultpArray(double *out, double *in1, double *in2, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        out   += 0x100;
        in1   += 0x100;
        len   -= 0x100;
ALIGN;
        MULT_ARRAY(-0x100);
        MULT_ARRAY(-0x0ff);
        MULT_ARRAY(-0x0fe);
        MULT_ARRAY(-0x0fd);
        MULT_ARRAY(-0x0fc);
        MULT_ARRAY(-0x0fb);
        MULT_ARRAY(-0x0fa);
        MULT_ARRAY(-0x0f9);
        MULT_ARRAY(-0x0f8);
        MULT_ARRAY(-0x0f7);
        MULT_ARRAY(-0x0f6);
        MULT_ARRAY(-0x0f5);
        MULT_ARRAY(-0x0f4);
        MULT_ARRAY(-0x0f3);
        MULT_ARRAY(-0x0f2);
        MULT_ARRAY(-0x0f1);
        MULT_ARRAY(-0x0f0);
        MULT_ARRAY(-0x0ef);
        MULT_ARRAY(-0x0ee);
        MULT_ARRAY(-0x0ed);
        MULT_ARRAY(-0x0ec);
        MULT_ARRAY(-0x0eb);
        MULT_ARRAY(-0x0ea);
        MULT_ARRAY(-0x0e9);
        MULT_ARRAY(-0x0e8);
        MULT_ARRAY(-0x0e7);
        MULT_ARRAY(-0x0e6);
        MULT_ARRAY(-0x0e5);
        MULT_ARRAY(-0x0e4);
        MULT_ARRAY(-0x0e3);
        MULT_ARRAY(-0x0e2);
        MULT_ARRAY(-0x0e1);
        MULT_ARRAY(-0x0e0);
        MULT_ARRAY(-0x0df);
        MULT_ARRAY(-0x0de);
        MULT_ARRAY(-0x0dd);
        MULT_ARRAY(-0x0dc);
        MULT_ARRAY(-0x0db);
        MULT_ARRAY(-0x0da);
        MULT_ARRAY(-0x0d9);
        MULT_ARRAY(-0x0d8);
        MULT_ARRAY(-0x0d7);
        MULT_ARRAY(-0x0d6);
        MULT_ARRAY(-0x0d5);
        MULT_ARRAY(-0x0d4);
        MULT_ARRAY(-0x0d3);
        MULT_ARRAY(-0x0d2);
        MULT_ARRAY(-0x0d1);
        MULT_ARRAY(-0x0d0);
        MULT_ARRAY(-0x0cf);
        MULT_ARRAY(-0x0ce);
        MULT_ARRAY(-0x0cd);
        MULT_ARRAY(-0x0cc);
        MULT_ARRAY(-0x0cb);
        MULT_ARRAY(-0x0ca);
        MULT_ARRAY(-0x0c9);
        MULT_ARRAY(-0x0c8);
        MULT_ARRAY(-0x0c7);
        MULT_ARRAY(-0x0c6);
        MULT_ARRAY(-0x0c5);
        MULT_ARRAY(-0x0c4);
        MULT_ARRAY(-0x0c3);
        MULT_ARRAY(-0x0c2);
        MULT_ARRAY(-0x0c1);
        MULT_ARRAY(-0x0c0);
        MULT_ARRAY(-0x0bf);
        MULT_ARRAY(-0x0be);
        MULT_ARRAY(-0x0bd);
        MULT_ARRAY(-0x0bc);
        MULT_ARRAY(-0x0bb);
        MULT_ARRAY(-0x0ba);
        MULT_ARRAY(-0x0b9);
        MULT_ARRAY(-0x0b8);
        MULT_ARRAY(-0x0b7);
        MULT_ARRAY(-0x0b6);
        MULT_ARRAY(-0x0b5);
        MULT_ARRAY(-0x0b4);
        MULT_ARRAY(-0x0b3);
        MULT_ARRAY(-0x0b2);
        MULT_ARRAY(-0x0b1);
        MULT_ARRAY(-0x0b0);
        MULT_ARRAY(-0x0af);
        MULT_ARRAY(-0x0ae);
        MULT_ARRAY(-0x0ad);
        MULT_ARRAY(-0x0ac);
        MULT_ARRAY(-0x0ab);
        MULT_ARRAY(-0x0aa);
        MULT_ARRAY(-0x0a9);
        MULT_ARRAY(-0x0a8);
        MULT_ARRAY(-0x0a7);
        MULT_ARRAY(-0x0a6);
        MULT_ARRAY(-0x0a5);
        MULT_ARRAY(-0x0a4);
        MULT_ARRAY(-0x0a3);
        MULT_ARRAY(-0x0a2);
        MULT_ARRAY(-0x0a1);
        MULT_ARRAY(-0x0a0);
        MULT_ARRAY(-0x09f);
        MULT_ARRAY(-0x09e);
        MULT_ARRAY(-0x09d);
        MULT_ARRAY(-0x09c);
        MULT_ARRAY(-0x09b);
        MULT_ARRAY(-0x09a);
        MULT_ARRAY(-0x099);
        MULT_ARRAY(-0x098);
        MULT_ARRAY(-0x097);
        MULT_ARRAY(-0x096);
        MULT_ARRAY(-0x095);
        MULT_ARRAY(-0x094);
        MULT_ARRAY(-0x093);
        MULT_ARRAY(-0x092);
        MULT_ARRAY(-0x091);
        MULT_ARRAY(-0x090);
        MULT_ARRAY(-0x08f);
        MULT_ARRAY(-0x08e);
        MULT_ARRAY(-0x08d);
        MULT_ARRAY(-0x08c);
        MULT_ARRAY(-0x08b);
        MULT_ARRAY(-0x08a);
        MULT_ARRAY(-0x089);
        MULT_ARRAY(-0x088);
        MULT_ARRAY(-0x087);
        MULT_ARRAY(-0x086);
        MULT_ARRAY(-0x085);
        MULT_ARRAY(-0x084);
        MULT_ARRAY(-0x083);
        MULT_ARRAY(-0x082);
        MULT_ARRAY(-0x081);
        MULT_ARRAY(-0x080);
        MULT_ARRAY(-0x07f);
        MULT_ARRAY(-0x07e);
        MULT_ARRAY(-0x07d);
        MULT_ARRAY(-0x07c);
        MULT_ARRAY(-0x07b);
        MULT_ARRAY(-0x07a);
        MULT_ARRAY(-0x079);
        MULT_ARRAY(-0x078);
        MULT_ARRAY(-0x077);
        MULT_ARRAY(-0x076);
        MULT_ARRAY(-0x075);
        MULT_ARRAY(-0x074);
        MULT_ARRAY(-0x073);
        MULT_ARRAY(-0x072);
        MULT_ARRAY(-0x071);
        MULT_ARRAY(-0x070);
        MULT_ARRAY(-0x06f);
        MULT_ARRAY(-0x06e);
        MULT_ARRAY(-0x06d);
        MULT_ARRAY(-0x06c);
        MULT_ARRAY(-0x06b);
        MULT_ARRAY(-0x06a);
        MULT_ARRAY(-0x069);
        MULT_ARRAY(-0x068);
        MULT_ARRAY(-0x067);
        MULT_ARRAY(-0x066);
        MULT_ARRAY(-0x065);
        MULT_ARRAY(-0x064);
        MULT_ARRAY(-0x063);
        MULT_ARRAY(-0x062);
        MULT_ARRAY(-0x061);
        MULT_ARRAY(-0x060);
        MULT_ARRAY(-0x05f);
        MULT_ARRAY(-0x05e);
        MULT_ARRAY(-0x05d);
        MULT_ARRAY(-0x05c);
        MULT_ARRAY(-0x05b);
        MULT_ARRAY(-0x05a);
        MULT_ARRAY(-0x059);
        MULT_ARRAY(-0x058);
        MULT_ARRAY(-0x057);
        MULT_ARRAY(-0x056);
        MULT_ARRAY(-0x055);
        MULT_ARRAY(-0x054);
        MULT_ARRAY(-0x053);
        MULT_ARRAY(-0x052);
        MULT_ARRAY(-0x051);
        MULT_ARRAY(-0x050);
        MULT_ARRAY(-0x04f);
        MULT_ARRAY(-0x04e);
        MULT_ARRAY(-0x04d);
        MULT_ARRAY(-0x04c);
        MULT_ARRAY(-0x04b);
        MULT_ARRAY(-0x04a);
        MULT_ARRAY(-0x049);
        MULT_ARRAY(-0x048);
        MULT_ARRAY(-0x047);
        MULT_ARRAY(-0x046);
        MULT_ARRAY(-0x045);
        MULT_ARRAY(-0x044);
        MULT_ARRAY(-0x043);
        MULT_ARRAY(-0x042);
        MULT_ARRAY(-0x041);
        MULT_ARRAY(-0x040);
        MULT_ARRAY(-0x03f);
        MULT_ARRAY(-0x03e);
        MULT_ARRAY(-0x03d);
        MULT_ARRAY(-0x03c);
        MULT_ARRAY(-0x03b);
        MULT_ARRAY(-0x03a);
        MULT_ARRAY(-0x039);
        MULT_ARRAY(-0x038);
        MULT_ARRAY(-0x037);
        MULT_ARRAY(-0x036);
        MULT_ARRAY(-0x035);
        MULT_ARRAY(-0x034);
        MULT_ARRAY(-0x033);
        MULT_ARRAY(-0x032);
        MULT_ARRAY(-0x031);
        MULT_ARRAY(-0x030);
        MULT_ARRAY(-0x02f);
        MULT_ARRAY(-0x02e);
        MULT_ARRAY(-0x02d);
        MULT_ARRAY(-0x02c);
        MULT_ARRAY(-0x02b);
        MULT_ARRAY(-0x02a);
        MULT_ARRAY(-0x029);
        MULT_ARRAY(-0x028);
        MULT_ARRAY(-0x027);
        MULT_ARRAY(-0x026);
        MULT_ARRAY(-0x025);
        MULT_ARRAY(-0x024);
        MULT_ARRAY(-0x023);
        MULT_ARRAY(-0x022);
        MULT_ARRAY(-0x021);
        MULT_ARRAY(-0x020);
        MULT_ARRAY(-0x01f);
        MULT_ARRAY(-0x01e);
        MULT_ARRAY(-0x01d);
        MULT_ARRAY(-0x01c);
        MULT_ARRAY(-0x01b);
        MULT_ARRAY(-0x01a);
        MULT_ARRAY(-0x019);
        MULT_ARRAY(-0x018);
        MULT_ARRAY(-0x017);
        MULT_ARRAY(-0x016);
        MULT_ARRAY(-0x015);
        MULT_ARRAY(-0x014);
        MULT_ARRAY(-0x013);
        MULT_ARRAY(-0x012);
        MULT_ARRAY(-0x011);
        MULT_ARRAY(-0x010);
        MULT_ARRAY(-0x00f);
        MULT_ARRAY(-0x00e);
        MULT_ARRAY(-0x00d);
        MULT_ARRAY(-0x00c);
        MULT_ARRAY(-0x00b);
        MULT_ARRAY(-0x00a);
        MULT_ARRAY(-0x009);
        MULT_ARRAY(-0x008);
        MULT_ARRAY(-0x007);
        MULT_ARRAY(-0x006);
        MULT_ARRAY(-0x005);
        MULT_ARRAY(-0x004);
        MULT_ARRAY(-0x003);
        MULT_ARRAY(-0x002);
        MULT_ARRAY(-0x001);
    }
    while(len >= 0x10)
    {
        out += 0x10;
        in1 += 0x10;
        len -= 0x10;
        MULT_ARRAY(-0x10);
        MULT_ARRAY(-0x0f);
        MULT_ARRAY(-0x0e);
        MULT_ARRAY(-0x0d);
        MULT_ARRAY(-0x0c);
        MULT_ARRAY(-0x0b);
        MULT_ARRAY(-0x0a);
        MULT_ARRAY(-0x09);
        MULT_ARRAY(-0x08);
        MULT_ARRAY(-0x07);
        MULT_ARRAY(-0x06);
        MULT_ARRAY(-0x05);
        MULT_ARRAY(-0x04);
        MULT_ARRAY(-0x03);
        MULT_ARRAY(-0x02);
        MULT_ARRAY(-0x01);
    }
#endif

    while(len--)
	    *out++ = *in1++ * *in2++;

}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-
//
// METHOD NAME
//
//   AddArray
//
//  Author:                      20-JUL-2008      Richard B. Johnson
//
// DESCRIPTION
//
//  This routine with add the values in two input arrays and leave the
//  result in the output array.
//
// INPUTS
//
//   Pointer to start of data out
//   Pointer to start of data in1
//   Pointer to start of data in2
//   Length of array len
//
//
// OUTPUTS
//
//   Result value in out
//

#define ADD_ARRAY(a) out[a] = in1[a] + in2[a]

void SIG::AddArray(double *out, double *in1, double *in2, int len)
{
#ifdef UNROLL
    while(len >= 0x100)
    {
        out   += 0x100;
        in1   += 0x100;
		in2   += 0x100;
        len   -= 0x100;
ALIGN;
        ADD_ARRAY(-0x100);
        ADD_ARRAY(-0x0ff);
        ADD_ARRAY(-0x0fe);
        ADD_ARRAY(-0x0fd);
        ADD_ARRAY(-0x0fc);
        ADD_ARRAY(-0x0fb);
        ADD_ARRAY(-0x0fa);
        ADD_ARRAY(-0x0f9);
        ADD_ARRAY(-0x0f8);
        ADD_ARRAY(-0x0f7);
        ADD_ARRAY(-0x0f6);
        ADD_ARRAY(-0x0f5);
        ADD_ARRAY(-0x0f4);
        ADD_ARRAY(-0x0f3);
        ADD_ARRAY(-0x0f2);
        ADD_ARRAY(-0x0f1);
        ADD_ARRAY(-0x0f0);
        ADD_ARRAY(-0x0ef);
        ADD_ARRAY(-0x0ee);
        ADD_ARRAY(-0x0ed);
        ADD_ARRAY(-0x0ec);
        ADD_ARRAY(-0x0eb);
        ADD_ARRAY(-0x0ea);
        ADD_ARRAY(-0x0e9);
        ADD_ARRAY(-0x0e8);
        ADD_ARRAY(-0x0e7);
        ADD_ARRAY(-0x0e6);
        ADD_ARRAY(-0x0e5);
        ADD_ARRAY(-0x0e4);
        ADD_ARRAY(-0x0e3);
        ADD_ARRAY(-0x0e2);
        ADD_ARRAY(-0x0e1);
        ADD_ARRAY(-0x0e0);
        ADD_ARRAY(-0x0df);
        ADD_ARRAY(-0x0de);
        ADD_ARRAY(-0x0dd);
        ADD_ARRAY(-0x0dc);
        ADD_ARRAY(-0x0db);
        ADD_ARRAY(-0x0da);
        ADD_ARRAY(-0x0d9);
        ADD_ARRAY(-0x0d8);
        ADD_ARRAY(-0x0d7);
        ADD_ARRAY(-0x0d6);
        ADD_ARRAY(-0x0d5);
        ADD_ARRAY(-0x0d4);
        ADD_ARRAY(-0x0d3);
        ADD_ARRAY(-0x0d2);
        ADD_ARRAY(-0x0d1);
        ADD_ARRAY(-0x0d0);
        ADD_ARRAY(-0x0cf);
        ADD_ARRAY(-0x0ce);
        ADD_ARRAY(-0x0cd);
        ADD_ARRAY(-0x0cc);
        ADD_ARRAY(-0x0cb);
        ADD_ARRAY(-0x0ca);
        ADD_ARRAY(-0x0c9);
        ADD_ARRAY(-0x0c8);
        ADD_ARRAY(-0x0c7);
        ADD_ARRAY(-0x0c6);
        ADD_ARRAY(-0x0c5);
        ADD_ARRAY(-0x0c4);
        ADD_ARRAY(-0x0c3);
        ADD_ARRAY(-0x0c2);
        ADD_ARRAY(-0x0c1);
        ADD_ARRAY(-0x0c0);
        ADD_ARRAY(-0x0bf);
        ADD_ARRAY(-0x0be);
        ADD_ARRAY(-0x0bd);
        ADD_ARRAY(-0x0bc);
        ADD_ARRAY(-0x0bb);
        ADD_ARRAY(-0x0ba);
        ADD_ARRAY(-0x0b9);
        ADD_ARRAY(-0x0b8);
        ADD_ARRAY(-0x0b7);
        ADD_ARRAY(-0x0b6);
        ADD_ARRAY(-0x0b5);
        ADD_ARRAY(-0x0b4);
        ADD_ARRAY(-0x0b3);
        ADD_ARRAY(-0x0b2);
        ADD_ARRAY(-0x0b1);
        ADD_ARRAY(-0x0b0);
        ADD_ARRAY(-0x0af);
        ADD_ARRAY(-0x0ae);
        ADD_ARRAY(-0x0ad);
        ADD_ARRAY(-0x0ac);
        ADD_ARRAY(-0x0ab);
        ADD_ARRAY(-0x0aa);
        ADD_ARRAY(-0x0a9);
        ADD_ARRAY(-0x0a8);
        ADD_ARRAY(-0x0a7);
        ADD_ARRAY(-0x0a6);
        ADD_ARRAY(-0x0a5);
        ADD_ARRAY(-0x0a4);
        ADD_ARRAY(-0x0a3);
        ADD_ARRAY(-0x0a2);
        ADD_ARRAY(-0x0a1);
        ADD_ARRAY(-0x0a0);
        ADD_ARRAY(-0x09f);
        ADD_ARRAY(-0x09e);
        ADD_ARRAY(-0x09d);
        ADD_ARRAY(-0x09c);
        ADD_ARRAY(-0x09b);
        ADD_ARRAY(-0x09a);
        ADD_ARRAY(-0x099);
        ADD_ARRAY(-0x098);
        ADD_ARRAY(-0x097);
        ADD_ARRAY(-0x096);
        ADD_ARRAY(-0x095);
        ADD_ARRAY(-0x094);
        ADD_ARRAY(-0x093);
        ADD_ARRAY(-0x092);
        ADD_ARRAY(-0x091);
        ADD_ARRAY(-0x090);
        ADD_ARRAY(-0x08f);
        ADD_ARRAY(-0x08e);
        ADD_ARRAY(-0x08d);
        ADD_ARRAY(-0x08c);
        ADD_ARRAY(-0x08b);
        ADD_ARRAY(-0x08a);
        ADD_ARRAY(-0x089);
        ADD_ARRAY(-0x088);
        ADD_ARRAY(-0x087);
        ADD_ARRAY(-0x086);
        ADD_ARRAY(-0x085);
        ADD_ARRAY(-0x084);
        ADD_ARRAY(-0x083);
        ADD_ARRAY(-0x082);
        ADD_ARRAY(-0x081);
        ADD_ARRAY(-0x080);
        ADD_ARRAY(-0x07f);
        ADD_ARRAY(-0x07e);
        ADD_ARRAY(-0x07d);
        ADD_ARRAY(-0x07c);
        ADD_ARRAY(-0x07b);
        ADD_ARRAY(-0x07a);
        ADD_ARRAY(-0x079);
        ADD_ARRAY(-0x078);
        ADD_ARRAY(-0x077);
        ADD_ARRAY(-0x076);
        ADD_ARRAY(-0x075);
        ADD_ARRAY(-0x074);
        ADD_ARRAY(-0x073);
        ADD_ARRAY(-0x072);
        ADD_ARRAY(-0x071);
        ADD_ARRAY(-0x070);
        ADD_ARRAY(-0x06f);
        ADD_ARRAY(-0x06e);
        ADD_ARRAY(-0x06d);
        ADD_ARRAY(-0x06c);
        ADD_ARRAY(-0x06b);
        ADD_ARRAY(-0x06a);
        ADD_ARRAY(-0x069);
        ADD_ARRAY(-0x068);
        ADD_ARRAY(-0x067);
        ADD_ARRAY(-0x066);
        ADD_ARRAY(-0x065);
        ADD_ARRAY(-0x064);
        ADD_ARRAY(-0x063);
        ADD_ARRAY(-0x062);
        ADD_ARRAY(-0x061);
        ADD_ARRAY(-0x060);
        ADD_ARRAY(-0x05f);
        ADD_ARRAY(-0x05e);
        ADD_ARRAY(-0x05d);
        ADD_ARRAY(-0x05c);
        ADD_ARRAY(-0x05b);
        ADD_ARRAY(-0x05a);
        ADD_ARRAY(-0x059);
        ADD_ARRAY(-0x058);
        ADD_ARRAY(-0x057);
        ADD_ARRAY(-0x056);
        ADD_ARRAY(-0x055);
        ADD_ARRAY(-0x054);
        ADD_ARRAY(-0x053);
        ADD_ARRAY(-0x052);
        ADD_ARRAY(-0x051);
        ADD_ARRAY(-0x050);
        ADD_ARRAY(-0x04f);
        ADD_ARRAY(-0x04e);
        ADD_ARRAY(-0x04d);
        ADD_ARRAY(-0x04c);
        ADD_ARRAY(-0x04b);
        ADD_ARRAY(-0x04a);
        ADD_ARRAY(-0x049);
        ADD_ARRAY(-0x048);
        ADD_ARRAY(-0x047);
        ADD_ARRAY(-0x046);
        ADD_ARRAY(-0x045);
        ADD_ARRAY(-0x044);
        ADD_ARRAY(-0x043);
        ADD_ARRAY(-0x042);
        ADD_ARRAY(-0x041);
        ADD_ARRAY(-0x040);
        ADD_ARRAY(-0x03f);
        ADD_ARRAY(-0x03e);
        ADD_ARRAY(-0x03d);
        ADD_ARRAY(-0x03c);
        ADD_ARRAY(-0x03b);
        ADD_ARRAY(-0x03a);
        ADD_ARRAY(-0x039);
        ADD_ARRAY(-0x038);
        ADD_ARRAY(-0x037);
        ADD_ARRAY(-0x036);
        ADD_ARRAY(-0x035);
        ADD_ARRAY(-0x034);
        ADD_ARRAY(-0x033);
        ADD_ARRAY(-0x032);
        ADD_ARRAY(-0x031);
        ADD_ARRAY(-0x030);
        ADD_ARRAY(-0x02f);
        ADD_ARRAY(-0x02e);
        ADD_ARRAY(-0x02d);
        ADD_ARRAY(-0x02c);
        ADD_ARRAY(-0x02b);
        ADD_ARRAY(-0x02a);
        ADD_ARRAY(-0x029);
        ADD_ARRAY(-0x028);
        ADD_ARRAY(-0x027);
        ADD_ARRAY(-0x026);
        ADD_ARRAY(-0x025);
        ADD_ARRAY(-0x024);
        ADD_ARRAY(-0x023);
        ADD_ARRAY(-0x022);
        ADD_ARRAY(-0x021);
        ADD_ARRAY(-0x020);
        ADD_ARRAY(-0x01f);
        ADD_ARRAY(-0x01e);
        ADD_ARRAY(-0x01d);
        ADD_ARRAY(-0x01c);
        ADD_ARRAY(-0x01b);
        ADD_ARRAY(-0x01a);
        ADD_ARRAY(-0x019);
        ADD_ARRAY(-0x018);
        ADD_ARRAY(-0x017);
        ADD_ARRAY(-0x016);
        ADD_ARRAY(-0x015);
        ADD_ARRAY(-0x014);
        ADD_ARRAY(-0x013);
        ADD_ARRAY(-0x012);
        ADD_ARRAY(-0x011);
        ADD_ARRAY(-0x010);
        ADD_ARRAY(-0x00f);
        ADD_ARRAY(-0x00e);
        ADD_ARRAY(-0x00d);
        ADD_ARRAY(-0x00c);
        ADD_ARRAY(-0x00b);
        ADD_ARRAY(-0x00a);
        ADD_ARRAY(-0x009);
        ADD_ARRAY(-0x008);
        ADD_ARRAY(-0x007);
        ADD_ARRAY(-0x006);
        ADD_ARRAY(-0x005);
        ADD_ARRAY(-0x004);
        ADD_ARRAY(-0x003);
        ADD_ARRAY(-0x002);
        ADD_ARRAY(-0x001);
    }
    while(len >= 0x10)
    {
        out += 0x10;
        in1 += 0x10;
        len -= 0x10;
        ADD_ARRAY(-0x10);
        ADD_ARRAY(-0x0f);
        ADD_ARRAY(-0x0e);
        ADD_ARRAY(-0x0d);
        ADD_ARRAY(-0x0c);
        ADD_ARRAY(-0x0b);
        ADD_ARRAY(-0x0a);
        ADD_ARRAY(-0x09);
        ADD_ARRAY(-0x08);
        ADD_ARRAY(-0x07);
        ADD_ARRAY(-0x06);
        ADD_ARRAY(-0x05);
        ADD_ARRAY(-0x04);
        ADD_ARRAY(-0x03);
        ADD_ARRAY(-0x02);
        ADD_ARRAY(-0x01);
    }
#endif

    while(len--)
	    *out++ = *in1++ + *in2++;

}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-
//
// METHOD NAME
//
//   SubArray
//
//  Author:                      20-JUL-2008      Richard B. Johnson
//
// DESCRIPTION
//
//  This routine with subtract the value in in2 array from in1 array and leave the
//  result in the output array.
//
// INPUTS
//
//   Pointer to start of data out
//   Pointer to start of data in1
//   Pointer to start of data in2
//   Length of array len
//
//
// OUTPUTS
//
//   Result value in out
//

#define SUBT_ARRAY(a) out[a] = in1[a] - in2[a]

		
void SIG::SubArray(double *out, double *in1, double *in2, int len)
{

#ifdef UNROLL
    while(len >= 0x100)
    {
        out   += 0x100;
        in1   += 0x100;
        len   -= 0x100;
ALIGN;
        SUBT_ARRAY(-0x100);
        SUBT_ARRAY(-0x0ff);
        SUBT_ARRAY(-0x0fe);
        SUBT_ARRAY(-0x0fd);
        SUBT_ARRAY(-0x0fc);
        SUBT_ARRAY(-0x0fb);
        SUBT_ARRAY(-0x0fa);
        SUBT_ARRAY(-0x0f9);
        SUBT_ARRAY(-0x0f8);
        SUBT_ARRAY(-0x0f7);
        SUBT_ARRAY(-0x0f6);
        SUBT_ARRAY(-0x0f5);
        SUBT_ARRAY(-0x0f4);
        SUBT_ARRAY(-0x0f3);
        SUBT_ARRAY(-0x0f2);
        SUBT_ARRAY(-0x0f1);
        SUBT_ARRAY(-0x0f0);
        SUBT_ARRAY(-0x0ef);
        SUBT_ARRAY(-0x0ee);
        SUBT_ARRAY(-0x0ed);
        SUBT_ARRAY(-0x0ec);
        SUBT_ARRAY(-0x0eb);
        SUBT_ARRAY(-0x0ea);
        SUBT_ARRAY(-0x0e9);
        SUBT_ARRAY(-0x0e8);
        SUBT_ARRAY(-0x0e7);
        SUBT_ARRAY(-0x0e6);
        SUBT_ARRAY(-0x0e5);
        SUBT_ARRAY(-0x0e4);
        SUBT_ARRAY(-0x0e3);
        SUBT_ARRAY(-0x0e2);
        SUBT_ARRAY(-0x0e1);
        SUBT_ARRAY(-0x0e0);
        SUBT_ARRAY(-0x0df);
        SUBT_ARRAY(-0x0de);
        SUBT_ARRAY(-0x0dd);
        SUBT_ARRAY(-0x0dc);
        SUBT_ARRAY(-0x0db);
        SUBT_ARRAY(-0x0da);
        SUBT_ARRAY(-0x0d9);
        SUBT_ARRAY(-0x0d8);
        SUBT_ARRAY(-0x0d7);
        SUBT_ARRAY(-0x0d6);
        SUBT_ARRAY(-0x0d5);
        SUBT_ARRAY(-0x0d4);
        SUBT_ARRAY(-0x0d3);
        SUBT_ARRAY(-0x0d2);
        SUBT_ARRAY(-0x0d1);
        SUBT_ARRAY(-0x0d0);
        SUBT_ARRAY(-0x0cf);
        SUBT_ARRAY(-0x0ce);
        SUBT_ARRAY(-0x0cd);
        SUBT_ARRAY(-0x0cc);
        SUBT_ARRAY(-0x0cb);
        SUBT_ARRAY(-0x0ca);
        SUBT_ARRAY(-0x0c9);
        SUBT_ARRAY(-0x0c8);
        SUBT_ARRAY(-0x0c7);
        SUBT_ARRAY(-0x0c6);
        SUBT_ARRAY(-0x0c5);
        SUBT_ARRAY(-0x0c4);
        SUBT_ARRAY(-0x0c3);
        SUBT_ARRAY(-0x0c2);
        SUBT_ARRAY(-0x0c1);
        SUBT_ARRAY(-0x0c0);
        SUBT_ARRAY(-0x0bf);
        SUBT_ARRAY(-0x0be);
        SUBT_ARRAY(-0x0bd);
        SUBT_ARRAY(-0x0bc);
        SUBT_ARRAY(-0x0bb);
        SUBT_ARRAY(-0x0ba);
        SUBT_ARRAY(-0x0b9);
        SUBT_ARRAY(-0x0b8);
        SUBT_ARRAY(-0x0b7);
        SUBT_ARRAY(-0x0b6);
        SUBT_ARRAY(-0x0b5);
        SUBT_ARRAY(-0x0b4);
        SUBT_ARRAY(-0x0b3);
        SUBT_ARRAY(-0x0b2);
        SUBT_ARRAY(-0x0b1);
        SUBT_ARRAY(-0x0b0);
        SUBT_ARRAY(-0x0af);
        SUBT_ARRAY(-0x0ae);
        SUBT_ARRAY(-0x0ad);
        SUBT_ARRAY(-0x0ac);
        SUBT_ARRAY(-0x0ab);
        SUBT_ARRAY(-0x0aa);
        SUBT_ARRAY(-0x0a9);
        SUBT_ARRAY(-0x0a8);
        SUBT_ARRAY(-0x0a7);
        SUBT_ARRAY(-0x0a6);
        SUBT_ARRAY(-0x0a5);
        SUBT_ARRAY(-0x0a4);
        SUBT_ARRAY(-0x0a3);
        SUBT_ARRAY(-0x0a2);
        SUBT_ARRAY(-0x0a1);
        SUBT_ARRAY(-0x0a0);
        SUBT_ARRAY(-0x09f);
        SUBT_ARRAY(-0x09e);
        SUBT_ARRAY(-0x09d);
        SUBT_ARRAY(-0x09c);
        SUBT_ARRAY(-0x09b);
        SUBT_ARRAY(-0x09a);
        SUBT_ARRAY(-0x099);
        SUBT_ARRAY(-0x098);
        SUBT_ARRAY(-0x097);
        SUBT_ARRAY(-0x096);
        SUBT_ARRAY(-0x095);
        SUBT_ARRAY(-0x094);
        SUBT_ARRAY(-0x093);
        SUBT_ARRAY(-0x092);
        SUBT_ARRAY(-0x091);
        SUBT_ARRAY(-0x090);
        SUBT_ARRAY(-0x08f);
        SUBT_ARRAY(-0x08e);
        SUBT_ARRAY(-0x08d);
        SUBT_ARRAY(-0x08c);
        SUBT_ARRAY(-0x08b);
        SUBT_ARRAY(-0x08a);
        SUBT_ARRAY(-0x089);
        SUBT_ARRAY(-0x088);
        SUBT_ARRAY(-0x087);
        SUBT_ARRAY(-0x086);
        SUBT_ARRAY(-0x085);
        SUBT_ARRAY(-0x084);
        SUBT_ARRAY(-0x083);
        SUBT_ARRAY(-0x082);
        SUBT_ARRAY(-0x081);
        SUBT_ARRAY(-0x080);
        SUBT_ARRAY(-0x07f);
        SUBT_ARRAY(-0x07e);
        SUBT_ARRAY(-0x07d);
        SUBT_ARRAY(-0x07c);
        SUBT_ARRAY(-0x07b);
        SUBT_ARRAY(-0x07a);
        SUBT_ARRAY(-0x079);
        SUBT_ARRAY(-0x078);
        SUBT_ARRAY(-0x077);
        SUBT_ARRAY(-0x076);
        SUBT_ARRAY(-0x075);
        SUBT_ARRAY(-0x074);
        SUBT_ARRAY(-0x073);
        SUBT_ARRAY(-0x072);
        SUBT_ARRAY(-0x071);
        SUBT_ARRAY(-0x070);
        SUBT_ARRAY(-0x06f);
        SUBT_ARRAY(-0x06e);
        SUBT_ARRAY(-0x06d);
        SUBT_ARRAY(-0x06c);
        SUBT_ARRAY(-0x06b);
        SUBT_ARRAY(-0x06a);
        SUBT_ARRAY(-0x069);
        SUBT_ARRAY(-0x068);
        SUBT_ARRAY(-0x067);
        SUBT_ARRAY(-0x066);
        SUBT_ARRAY(-0x065);
        SUBT_ARRAY(-0x064);
        SUBT_ARRAY(-0x063);
        SUBT_ARRAY(-0x062);
        SUBT_ARRAY(-0x061);
        SUBT_ARRAY(-0x060);
        SUBT_ARRAY(-0x05f);
        SUBT_ARRAY(-0x05e);
        SUBT_ARRAY(-0x05d);
        SUBT_ARRAY(-0x05c);
        SUBT_ARRAY(-0x05b);
        SUBT_ARRAY(-0x05a);
        SUBT_ARRAY(-0x059);
        SUBT_ARRAY(-0x058);
        SUBT_ARRAY(-0x057);
        SUBT_ARRAY(-0x056);
        SUBT_ARRAY(-0x055);
        SUBT_ARRAY(-0x054);
        SUBT_ARRAY(-0x053);
        SUBT_ARRAY(-0x052);
        SUBT_ARRAY(-0x051);
        SUBT_ARRAY(-0x050);
        SUBT_ARRAY(-0x04f);
        SUBT_ARRAY(-0x04e);
        SUBT_ARRAY(-0x04d);
        SUBT_ARRAY(-0x04c);
        SUBT_ARRAY(-0x04b);
        SUBT_ARRAY(-0x04a);
        SUBT_ARRAY(-0x049);
        SUBT_ARRAY(-0x048);
        SUBT_ARRAY(-0x047);
        SUBT_ARRAY(-0x046);
        SUBT_ARRAY(-0x045);
        SUBT_ARRAY(-0x044);
        SUBT_ARRAY(-0x043);
        SUBT_ARRAY(-0x042);
        SUBT_ARRAY(-0x041);
        SUBT_ARRAY(-0x040);
        SUBT_ARRAY(-0x03f);
        SUBT_ARRAY(-0x03e);
        SUBT_ARRAY(-0x03d);
        SUBT_ARRAY(-0x03c);
        SUBT_ARRAY(-0x03b);
        SUBT_ARRAY(-0x03a);
        SUBT_ARRAY(-0x039);
        SUBT_ARRAY(-0x038);
        SUBT_ARRAY(-0x037);
        SUBT_ARRAY(-0x036);
        SUBT_ARRAY(-0x035);
        SUBT_ARRAY(-0x034);
        SUBT_ARRAY(-0x033);
        SUBT_ARRAY(-0x032);
        SUBT_ARRAY(-0x031);
        SUBT_ARRAY(-0x030);
        SUBT_ARRAY(-0x02f);
        SUBT_ARRAY(-0x02e);
        SUBT_ARRAY(-0x02d);
        SUBT_ARRAY(-0x02c);
        SUBT_ARRAY(-0x02b);
        SUBT_ARRAY(-0x02a);
        SUBT_ARRAY(-0x029);
        SUBT_ARRAY(-0x028);
        SUBT_ARRAY(-0x027);
        SUBT_ARRAY(-0x026);
        SUBT_ARRAY(-0x025);
        SUBT_ARRAY(-0x024);
        SUBT_ARRAY(-0x023);
        SUBT_ARRAY(-0x022);
        SUBT_ARRAY(-0x021);
        SUBT_ARRAY(-0x020);
        SUBT_ARRAY(-0x01f);
        SUBT_ARRAY(-0x01e);
        SUBT_ARRAY(-0x01d);
        SUBT_ARRAY(-0x01c);
        SUBT_ARRAY(-0x01b);
        SUBT_ARRAY(-0x01a);
        SUBT_ARRAY(-0x019);
        SUBT_ARRAY(-0x018);
        SUBT_ARRAY(-0x017);
        SUBT_ARRAY(-0x016);
        SUBT_ARRAY(-0x015);
        SUBT_ARRAY(-0x014);
        SUBT_ARRAY(-0x013);
        SUBT_ARRAY(-0x012);
        SUBT_ARRAY(-0x011);
        SUBT_ARRAY(-0x010);
        SUBT_ARRAY(-0x00f);
        SUBT_ARRAY(-0x00e);
        SUBT_ARRAY(-0x00d);
        SUBT_ARRAY(-0x00c);
        SUBT_ARRAY(-0x00b);
        SUBT_ARRAY(-0x00a);
        SUBT_ARRAY(-0x009);
        SUBT_ARRAY(-0x008);
        SUBT_ARRAY(-0x007);
        SUBT_ARRAY(-0x006);
        SUBT_ARRAY(-0x005);
        SUBT_ARRAY(-0x004);
        SUBT_ARRAY(-0x003);
        SUBT_ARRAY(-0x002);
        SUBT_ARRAY(-0x001);
    }
    while(len >= 0x10)
    {
        out += 0x10;
        in1 += 0x10;
        len -= 0x10;
        SUBT_ARRAY(-0x10);
        SUBT_ARRAY(-0x0f);
        SUBT_ARRAY(-0x0e);
        SUBT_ARRAY(-0x0d);
        SUBT_ARRAY(-0x0c);
        SUBT_ARRAY(-0x0b);
        SUBT_ARRAY(-0x0a);
        SUBT_ARRAY(-0x09);
        SUBT_ARRAY(-0x08);
        SUBT_ARRAY(-0x07);
        SUBT_ARRAY(-0x06);
        SUBT_ARRAY(-0x05);
        SUBT_ARRAY(-0x04);
        SUBT_ARRAY(-0x03);
        SUBT_ARRAY(-0x02);
        SUBT_ARRAY(-0x01);
    }
#endif

	   while(len--)
	    *out++ = *in1++ - *in2++;
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-
//
// METHOD NAME
//
//   SubArray
//
//  Author:                      20-JUL-2008      Richard B. Johnson
//
// DESCRIPTION
//
//  This routine will square the value from in1 array and leave the
//  result in the output array.
//
// INPUTS
//
//   Pointer to start of data out
//   Pointer to start of data in1
//   Pointer to start of data in2
//   Length of array len
//
//
// OUTPUTS
//
//   Result value in out
//
#define SQR_ARRAY(a) x = in1[a] ; x *= x; out[a] = x

void SIG::SqurArray(double *out, double *in1, int len)
{
	double x;

#ifdef UNROLL
    while(len >= 0x100)
    {
        out   += 0x100;
        in1   += 0x100;
        len   -= 0x100;
ALIGN;
        SQR_ARRAY(-0x100);
        SQR_ARRAY(-0x0ff);
        SQR_ARRAY(-0x0fe);
        SQR_ARRAY(-0x0fd);
        SQR_ARRAY(-0x0fc);
        SQR_ARRAY(-0x0fb);
        SQR_ARRAY(-0x0fa);
        SQR_ARRAY(-0x0f9);
        SQR_ARRAY(-0x0f8);
        SQR_ARRAY(-0x0f7);
        SQR_ARRAY(-0x0f6);
        SQR_ARRAY(-0x0f5);
        SQR_ARRAY(-0x0f4);
        SQR_ARRAY(-0x0f3);
        SQR_ARRAY(-0x0f2);
        SQR_ARRAY(-0x0f1);
        SQR_ARRAY(-0x0f0);
        SQR_ARRAY(-0x0ef);
        SQR_ARRAY(-0x0ee);
        SQR_ARRAY(-0x0ed);
        SQR_ARRAY(-0x0ec);
        SQR_ARRAY(-0x0eb);
        SQR_ARRAY(-0x0ea);
        SQR_ARRAY(-0x0e9);
        SQR_ARRAY(-0x0e8);
        SQR_ARRAY(-0x0e7);
        SQR_ARRAY(-0x0e6);
        SQR_ARRAY(-0x0e5);
        SQR_ARRAY(-0x0e4);
        SQR_ARRAY(-0x0e3);
        SQR_ARRAY(-0x0e2);
        SQR_ARRAY(-0x0e1);
        SQR_ARRAY(-0x0e0);
        SQR_ARRAY(-0x0df);
        SQR_ARRAY(-0x0de);
        SQR_ARRAY(-0x0dd);
        SQR_ARRAY(-0x0dc);
        SQR_ARRAY(-0x0db);
        SQR_ARRAY(-0x0da);
        SQR_ARRAY(-0x0d9);
        SQR_ARRAY(-0x0d8);
        SQR_ARRAY(-0x0d7);
        SQR_ARRAY(-0x0d6);
        SQR_ARRAY(-0x0d5);
        SQR_ARRAY(-0x0d4);
        SQR_ARRAY(-0x0d3);
        SQR_ARRAY(-0x0d2);
        SQR_ARRAY(-0x0d1);
        SQR_ARRAY(-0x0d0);
        SQR_ARRAY(-0x0cf);
        SQR_ARRAY(-0x0ce);
        SQR_ARRAY(-0x0cd);
        SQR_ARRAY(-0x0cc);
        SQR_ARRAY(-0x0cb);
        SQR_ARRAY(-0x0ca);
        SQR_ARRAY(-0x0c9);
        SQR_ARRAY(-0x0c8);
        SQR_ARRAY(-0x0c7);
        SQR_ARRAY(-0x0c6);
        SQR_ARRAY(-0x0c5);
        SQR_ARRAY(-0x0c4);
        SQR_ARRAY(-0x0c3);
        SQR_ARRAY(-0x0c2);
        SQR_ARRAY(-0x0c1);
        SQR_ARRAY(-0x0c0);
        SQR_ARRAY(-0x0bf);
        SQR_ARRAY(-0x0be);
        SQR_ARRAY(-0x0bd);
        SQR_ARRAY(-0x0bc);
        SQR_ARRAY(-0x0bb);
        SQR_ARRAY(-0x0ba);
        SQR_ARRAY(-0x0b9);
        SQR_ARRAY(-0x0b8);
        SQR_ARRAY(-0x0b7);
        SQR_ARRAY(-0x0b6);
        SQR_ARRAY(-0x0b5);
        SQR_ARRAY(-0x0b4);
        SQR_ARRAY(-0x0b3);
        SQR_ARRAY(-0x0b2);
        SQR_ARRAY(-0x0b1);
        SQR_ARRAY(-0x0b0);
        SQR_ARRAY(-0x0af);
        SQR_ARRAY(-0x0ae);
        SQR_ARRAY(-0x0ad);
        SQR_ARRAY(-0x0ac);
        SQR_ARRAY(-0x0ab);
        SQR_ARRAY(-0x0aa);
        SQR_ARRAY(-0x0a9);
        SQR_ARRAY(-0x0a8);
        SQR_ARRAY(-0x0a7);
        SQR_ARRAY(-0x0a6);
        SQR_ARRAY(-0x0a5);
        SQR_ARRAY(-0x0a4);
        SQR_ARRAY(-0x0a3);
        SQR_ARRAY(-0x0a2);
        SQR_ARRAY(-0x0a1);
        SQR_ARRAY(-0x0a0);
        SQR_ARRAY(-0x09f);
        SQR_ARRAY(-0x09e);
        SQR_ARRAY(-0x09d);
        SQR_ARRAY(-0x09c);
        SQR_ARRAY(-0x09b);
        SQR_ARRAY(-0x09a);
        SQR_ARRAY(-0x099);
        SQR_ARRAY(-0x098);
        SQR_ARRAY(-0x097);
        SQR_ARRAY(-0x096);
        SQR_ARRAY(-0x095);
        SQR_ARRAY(-0x094);
        SQR_ARRAY(-0x093);
        SQR_ARRAY(-0x092);
        SQR_ARRAY(-0x091);
        SQR_ARRAY(-0x090);
        SQR_ARRAY(-0x08f);
        SQR_ARRAY(-0x08e);
        SQR_ARRAY(-0x08d);
        SQR_ARRAY(-0x08c);
        SQR_ARRAY(-0x08b);
        SQR_ARRAY(-0x08a);
        SQR_ARRAY(-0x089);
        SQR_ARRAY(-0x088);
        SQR_ARRAY(-0x087);
        SQR_ARRAY(-0x086);
        SQR_ARRAY(-0x085);
        SQR_ARRAY(-0x084);
        SQR_ARRAY(-0x083);
        SQR_ARRAY(-0x082);
        SQR_ARRAY(-0x081);
        SQR_ARRAY(-0x080);
        SQR_ARRAY(-0x07f);
        SQR_ARRAY(-0x07e);
        SQR_ARRAY(-0x07d);
        SQR_ARRAY(-0x07c);
        SQR_ARRAY(-0x07b);
        SQR_ARRAY(-0x07a);
        SQR_ARRAY(-0x079);
        SQR_ARRAY(-0x078);
        SQR_ARRAY(-0x077);
        SQR_ARRAY(-0x076);
        SQR_ARRAY(-0x075);
        SQR_ARRAY(-0x074);
        SQR_ARRAY(-0x073);
        SQR_ARRAY(-0x072);
        SQR_ARRAY(-0x071);
        SQR_ARRAY(-0x070);
        SQR_ARRAY(-0x06f);
        SQR_ARRAY(-0x06e);
        SQR_ARRAY(-0x06d);
        SQR_ARRAY(-0x06c);
        SQR_ARRAY(-0x06b);
        SQR_ARRAY(-0x06a);
        SQR_ARRAY(-0x069);
        SQR_ARRAY(-0x068);
        SQR_ARRAY(-0x067);
        SQR_ARRAY(-0x066);
        SQR_ARRAY(-0x065);
        SQR_ARRAY(-0x064);
        SQR_ARRAY(-0x063);
        SQR_ARRAY(-0x062);
        SQR_ARRAY(-0x061);
        SQR_ARRAY(-0x060);
        SQR_ARRAY(-0x05f);
        SQR_ARRAY(-0x05e);
        SQR_ARRAY(-0x05d);
        SQR_ARRAY(-0x05c);
        SQR_ARRAY(-0x05b);
        SQR_ARRAY(-0x05a);
        SQR_ARRAY(-0x059);
        SQR_ARRAY(-0x058);
        SQR_ARRAY(-0x057);
        SQR_ARRAY(-0x056);
        SQR_ARRAY(-0x055);
        SQR_ARRAY(-0x054);
        SQR_ARRAY(-0x053);
        SQR_ARRAY(-0x052);
        SQR_ARRAY(-0x051);
        SQR_ARRAY(-0x050);
        SQR_ARRAY(-0x04f);
        SQR_ARRAY(-0x04e);
        SQR_ARRAY(-0x04d);
        SQR_ARRAY(-0x04c);
        SQR_ARRAY(-0x04b);
        SQR_ARRAY(-0x04a);
        SQR_ARRAY(-0x049);
        SQR_ARRAY(-0x048);
        SQR_ARRAY(-0x047);
        SQR_ARRAY(-0x046);
        SQR_ARRAY(-0x045);
        SQR_ARRAY(-0x044);
        SQR_ARRAY(-0x043);
        SQR_ARRAY(-0x042);
        SQR_ARRAY(-0x041);
        SQR_ARRAY(-0x040);
        SQR_ARRAY(-0x03f);
        SQR_ARRAY(-0x03e);
        SQR_ARRAY(-0x03d);
        SQR_ARRAY(-0x03c);
        SQR_ARRAY(-0x03b);
        SQR_ARRAY(-0x03a);
        SQR_ARRAY(-0x039);
        SQR_ARRAY(-0x038);
        SQR_ARRAY(-0x037);
        SQR_ARRAY(-0x036);
        SQR_ARRAY(-0x035);
        SQR_ARRAY(-0x034);
        SQR_ARRAY(-0x033);
        SQR_ARRAY(-0x032);
        SQR_ARRAY(-0x031);
        SQR_ARRAY(-0x030);
        SQR_ARRAY(-0x02f);
        SQR_ARRAY(-0x02e);
        SQR_ARRAY(-0x02d);
        SQR_ARRAY(-0x02c);
        SQR_ARRAY(-0x02b);
        SQR_ARRAY(-0x02a);
        SQR_ARRAY(-0x029);
        SQR_ARRAY(-0x028);
        SQR_ARRAY(-0x027);
        SQR_ARRAY(-0x026);
        SQR_ARRAY(-0x025);
        SQR_ARRAY(-0x024);
        SQR_ARRAY(-0x023);
        SQR_ARRAY(-0x022);
        SQR_ARRAY(-0x021);
        SQR_ARRAY(-0x020);
        SQR_ARRAY(-0x01f);
        SQR_ARRAY(-0x01e);
        SQR_ARRAY(-0x01d);
        SQR_ARRAY(-0x01c);
        SQR_ARRAY(-0x01b);
        SQR_ARRAY(-0x01a);
        SQR_ARRAY(-0x019);
        SQR_ARRAY(-0x018);
        SQR_ARRAY(-0x017);
        SQR_ARRAY(-0x016);
        SQR_ARRAY(-0x015);
        SQR_ARRAY(-0x014);
        SQR_ARRAY(-0x013);
        SQR_ARRAY(-0x012);
        SQR_ARRAY(-0x011);
        SQR_ARRAY(-0x010);
        SQR_ARRAY(-0x00f);
        SQR_ARRAY(-0x00e);
        SQR_ARRAY(-0x00d);
        SQR_ARRAY(-0x00c);
        SQR_ARRAY(-0x00b);
        SQR_ARRAY(-0x00a);
        SQR_ARRAY(-0x009);
        SQR_ARRAY(-0x008);
        SQR_ARRAY(-0x007);
        SQR_ARRAY(-0x006);
        SQR_ARRAY(-0x005);
        SQR_ARRAY(-0x004);
        SQR_ARRAY(-0x003);
        SQR_ARRAY(-0x002);
        SQR_ARRAY(-0x001);
    }
    while(len >= 0x10)
    {
        out += 0x10;
        in1 += 0x10;
        len -= 0x10;
        SQR_ARRAY(-0x10);
        SQR_ARRAY(-0x0f);
        SQR_ARRAY(-0x0e);
        SQR_ARRAY(-0x0d);
        SQR_ARRAY(-0x0c);
        SQR_ARRAY(-0x0b);
        SQR_ARRAY(-0x0a);
        SQR_ARRAY(-0x09);
        SQR_ARRAY(-0x08);
        SQR_ARRAY(-0x07);
        SQR_ARRAY(-0x06);
        SQR_ARRAY(-0x05);
        SQR_ARRAY(-0x04);
        SQR_ARRAY(-0x03);
        SQR_ARRAY(-0x02);
        SQR_ARRAY(-0x01);
    }
#endif

	while(len--)
	{
		x = *in1++;
		*out++ = x * x;
	}
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=--=-=-
//
// METHOD NAME
//
//   SqrtArray
//
//  Author:                      20-JUL-2008      Richard B. Johnson
//
// DESCRIPTION
//
//  This routine with find the square-root of the value from in1 array and leave the
//  result in the output array.
//
// INPUTS
//
//   Pointer to start of data out
//   Pointer to start of data in1
//   Pointer to start of data in2
//   Length of array len
//
//
// OUTPUTS
//
//   Result value in out
//


#define SQRT_ARRAY(a) out[a] = sqrt(in1[a])


void SIG::SqrtArray(double *out, double *in1, int len)
{

#ifdef UNROLL
    while(len >= 0x100)
    {
        out   += 0x100;
        in1   += 0x100;
        len   -= 0x100;
ALIGN;
        SQRT_ARRAY(-0x100);
        SQRT_ARRAY(-0x0ff);
        SQRT_ARRAY(-0x0fe);
        SQRT_ARRAY(-0x0fd);
        SQRT_ARRAY(-0x0fc);
        SQRT_ARRAY(-0x0fb);
        SQRT_ARRAY(-0x0fa);
        SQRT_ARRAY(-0x0f9);
        SQRT_ARRAY(-0x0f8);
        SQRT_ARRAY(-0x0f7);
        SQRT_ARRAY(-0x0f6);
        SQRT_ARRAY(-0x0f5);
        SQRT_ARRAY(-0x0f4);
        SQRT_ARRAY(-0x0f3);
        SQRT_ARRAY(-0x0f2);
        SQRT_ARRAY(-0x0f1);
        SQRT_ARRAY(-0x0f0);
        SQRT_ARRAY(-0x0ef);
        SQRT_ARRAY(-0x0ee);
        SQRT_ARRAY(-0x0ed);
        SQRT_ARRAY(-0x0ec);
        SQRT_ARRAY(-0x0eb);
        SQRT_ARRAY(-0x0ea);
        SQRT_ARRAY(-0x0e9);
        SQRT_ARRAY(-0x0e8);
        SQRT_ARRAY(-0x0e7);
        SQRT_ARRAY(-0x0e6);
        SQRT_ARRAY(-0x0e5);
        SQRT_ARRAY(-0x0e4);
        SQRT_ARRAY(-0x0e3);
        SQRT_ARRAY(-0x0e2);
        SQRT_ARRAY(-0x0e1);
        SQRT_ARRAY(-0x0e0);
        SQRT_ARRAY(-0x0df);
        SQRT_ARRAY(-0x0de);
        SQRT_ARRAY(-0x0dd);
        SQRT_ARRAY(-0x0dc);
        SQRT_ARRAY(-0x0db);
        SQRT_ARRAY(-0x0da);
        SQRT_ARRAY(-0x0d9);
        SQRT_ARRAY(-0x0d8);
        SQRT_ARRAY(-0x0d7);
        SQRT_ARRAY(-0x0d6);
        SQRT_ARRAY(-0x0d5);
        SQRT_ARRAY(-0x0d4);
        SQRT_ARRAY(-0x0d3);
        SQRT_ARRAY(-0x0d2);
        SQRT_ARRAY(-0x0d1);
        SQRT_ARRAY(-0x0d0);
        SQRT_ARRAY(-0x0cf);
        SQRT_ARRAY(-0x0ce);
        SQRT_ARRAY(-0x0cd);
        SQRT_ARRAY(-0x0cc);
        SQRT_ARRAY(-0x0cb);
        SQRT_ARRAY(-0x0ca);
        SQRT_ARRAY(-0x0c9);
        SQRT_ARRAY(-0x0c8);
        SQRT_ARRAY(-0x0c7);
        SQRT_ARRAY(-0x0c6);
        SQRT_ARRAY(-0x0c5);
        SQRT_ARRAY(-0x0c4);
        SQRT_ARRAY(-0x0c3);
        SQRT_ARRAY(-0x0c2);
        SQRT_ARRAY(-0x0c1);
        SQRT_ARRAY(-0x0c0);
        SQRT_ARRAY(-0x0bf);
        SQRT_ARRAY(-0x0be);
        SQRT_ARRAY(-0x0bd);
        SQRT_ARRAY(-0x0bc);
        SQRT_ARRAY(-0x0bb);
        SQRT_ARRAY(-0x0ba);
        SQRT_ARRAY(-0x0b9);
        SQRT_ARRAY(-0x0b8);
        SQRT_ARRAY(-0x0b7);
        SQRT_ARRAY(-0x0b6);
        SQRT_ARRAY(-0x0b5);
        SQRT_ARRAY(-0x0b4);
        SQRT_ARRAY(-0x0b3);
        SQRT_ARRAY(-0x0b2);
        SQRT_ARRAY(-0x0b1);
        SQRT_ARRAY(-0x0b0);
        SQRT_ARRAY(-0x0af);
        SQRT_ARRAY(-0x0ae);
        SQRT_ARRAY(-0x0ad);
        SQRT_ARRAY(-0x0ac);
        SQRT_ARRAY(-0x0ab);
        SQRT_ARRAY(-0x0aa);
        SQRT_ARRAY(-0x0a9);
        SQRT_ARRAY(-0x0a8);
        SQRT_ARRAY(-0x0a7);
        SQRT_ARRAY(-0x0a6);
        SQRT_ARRAY(-0x0a5);
        SQRT_ARRAY(-0x0a4);
        SQRT_ARRAY(-0x0a3);
        SQRT_ARRAY(-0x0a2);
        SQRT_ARRAY(-0x0a1);
        SQRT_ARRAY(-0x0a0);
        SQRT_ARRAY(-0x09f);
        SQRT_ARRAY(-0x09e);
        SQRT_ARRAY(-0x09d);
        SQRT_ARRAY(-0x09c);
        SQRT_ARRAY(-0x09b);
        SQRT_ARRAY(-0x09a);
        SQRT_ARRAY(-0x099);
        SQRT_ARRAY(-0x098);
        SQRT_ARRAY(-0x097);
        SQRT_ARRAY(-0x096);
        SQRT_ARRAY(-0x095);
        SQRT_ARRAY(-0x094);
        SQRT_ARRAY(-0x093);
        SQRT_ARRAY(-0x092);
        SQRT_ARRAY(-0x091);
        SQRT_ARRAY(-0x090);
        SQRT_ARRAY(-0x08f);
        SQRT_ARRAY(-0x08e);
        SQRT_ARRAY(-0x08d);
        SQRT_ARRAY(-0x08c);
        SQRT_ARRAY(-0x08b);
        SQRT_ARRAY(-0x08a);
        SQRT_ARRAY(-0x089);
        SQRT_ARRAY(-0x088);
        SQRT_ARRAY(-0x087);
        SQRT_ARRAY(-0x086);
        SQRT_ARRAY(-0x085);
        SQRT_ARRAY(-0x084);
        SQRT_ARRAY(-0x083);
        SQRT_ARRAY(-0x082);
        SQRT_ARRAY(-0x081);
        SQRT_ARRAY(-0x080);
        SQRT_ARRAY(-0x07f);
        SQRT_ARRAY(-0x07e);
        SQRT_ARRAY(-0x07d);
        SQRT_ARRAY(-0x07c);
        SQRT_ARRAY(-0x07b);
        SQRT_ARRAY(-0x07a);
        SQRT_ARRAY(-0x079);
        SQRT_ARRAY(-0x078);
        SQRT_ARRAY(-0x077);
        SQRT_ARRAY(-0x076);
        SQRT_ARRAY(-0x075);
        SQRT_ARRAY(-0x074);
        SQRT_ARRAY(-0x073);
        SQRT_ARRAY(-0x072);
        SQRT_ARRAY(-0x071);
        SQRT_ARRAY(-0x070);
        SQRT_ARRAY(-0x06f);
        SQRT_ARRAY(-0x06e);
        SQRT_ARRAY(-0x06d);
        SQRT_ARRAY(-0x06c);
        SQRT_ARRAY(-0x06b);
        SQRT_ARRAY(-0x06a);
        SQRT_ARRAY(-0x069);
        SQRT_ARRAY(-0x068);
        SQRT_ARRAY(-0x067);
        SQRT_ARRAY(-0x066);
        SQRT_ARRAY(-0x065);
        SQRT_ARRAY(-0x064);
        SQRT_ARRAY(-0x063);
        SQRT_ARRAY(-0x062);
        SQRT_ARRAY(-0x061);
        SQRT_ARRAY(-0x060);
        SQRT_ARRAY(-0x05f);
        SQRT_ARRAY(-0x05e);
        SQRT_ARRAY(-0x05d);
        SQRT_ARRAY(-0x05c);
        SQRT_ARRAY(-0x05b);
        SQRT_ARRAY(-0x05a);
        SQRT_ARRAY(-0x059);
        SQRT_ARRAY(-0x058);
        SQRT_ARRAY(-0x057);
        SQRT_ARRAY(-0x056);
        SQRT_ARRAY(-0x055);
        SQRT_ARRAY(-0x054);
        SQRT_ARRAY(-0x053);
        SQRT_ARRAY(-0x052);
        SQRT_ARRAY(-0x051);
        SQRT_ARRAY(-0x050);
        SQRT_ARRAY(-0x04f);
        SQRT_ARRAY(-0x04e);
        SQRT_ARRAY(-0x04d);
        SQRT_ARRAY(-0x04c);
        SQRT_ARRAY(-0x04b);
        SQRT_ARRAY(-0x04a);
        SQRT_ARRAY(-0x049);
        SQRT_ARRAY(-0x048);
        SQRT_ARRAY(-0x047);
        SQRT_ARRAY(-0x046);
        SQRT_ARRAY(-0x045);
        SQRT_ARRAY(-0x044);
        SQRT_ARRAY(-0x043);
        SQRT_ARRAY(-0x042);
        SQRT_ARRAY(-0x041);
        SQRT_ARRAY(-0x040);
        SQRT_ARRAY(-0x03f);
        SQRT_ARRAY(-0x03e);
        SQRT_ARRAY(-0x03d);
        SQRT_ARRAY(-0x03c);
        SQRT_ARRAY(-0x03b);
        SQRT_ARRAY(-0x03a);
        SQRT_ARRAY(-0x039);
        SQRT_ARRAY(-0x038);
        SQRT_ARRAY(-0x037);
        SQRT_ARRAY(-0x036);
        SQRT_ARRAY(-0x035);
        SQRT_ARRAY(-0x034);
        SQRT_ARRAY(-0x033);
        SQRT_ARRAY(-0x032);
        SQRT_ARRAY(-0x031);
        SQRT_ARRAY(-0x030);
        SQRT_ARRAY(-0x02f);
        SQRT_ARRAY(-0x02e);
        SQRT_ARRAY(-0x02d);
        SQRT_ARRAY(-0x02c);
        SQRT_ARRAY(-0x02b);
        SQRT_ARRAY(-0x02a);
        SQRT_ARRAY(-0x029);
        SQRT_ARRAY(-0x028);
        SQRT_ARRAY(-0x027);
        SQRT_ARRAY(-0x026);
        SQRT_ARRAY(-0x025);
        SQRT_ARRAY(-0x024);
        SQRT_ARRAY(-0x023);
        SQRT_ARRAY(-0x022);
        SQRT_ARRAY(-0x021);
        SQRT_ARRAY(-0x020);
        SQRT_ARRAY(-0x01f);
        SQRT_ARRAY(-0x01e);
        SQRT_ARRAY(-0x01d);
        SQRT_ARRAY(-0x01c);
        SQRT_ARRAY(-0x01b);
        SQRT_ARRAY(-0x01a);
        SQRT_ARRAY(-0x019);
        SQRT_ARRAY(-0x018);
        SQRT_ARRAY(-0x017);
        SQRT_ARRAY(-0x016);
        SQRT_ARRAY(-0x015);
        SQRT_ARRAY(-0x014);
        SQRT_ARRAY(-0x013);
        SQRT_ARRAY(-0x012);
        SQRT_ARRAY(-0x011);
        SQRT_ARRAY(-0x010);
        SQRT_ARRAY(-0x00f);
        SQRT_ARRAY(-0x00e);
        SQRT_ARRAY(-0x00d);
        SQRT_ARRAY(-0x00c);
        SQRT_ARRAY(-0x00b);
        SQRT_ARRAY(-0x00a);
        SQRT_ARRAY(-0x009);
        SQRT_ARRAY(-0x008);
        SQRT_ARRAY(-0x007);
        SQRT_ARRAY(-0x006);
        SQRT_ARRAY(-0x005);
        SQRT_ARRAY(-0x004);
        SQRT_ARRAY(-0x003);
        SQRT_ARRAY(-0x002);
        SQRT_ARRAY(-0x001);
    }
    while(len >= 0x10)
    {
        out += 0x10;
        in1 += 0x10;
        len -= 0x10;
        SQRT_ARRAY(-0x10);
        SQRT_ARRAY(-0x0f);
        SQRT_ARRAY(-0x0e);
        SQRT_ARRAY(-0x0d);
        SQRT_ARRAY(-0x0c);
        SQRT_ARRAY(-0x0b);
        SQRT_ARRAY(-0x0a);
        SQRT_ARRAY(-0x09);
        SQRT_ARRAY(-0x08);
        SQRT_ARRAY(-0x07);
        SQRT_ARRAY(-0x06);
        SQRT_ARRAY(-0x05);
        SQRT_ARRAY(-0x04);
        SQRT_ARRAY(-0x03);
        SQRT_ARRAY(-0x02);
        SQRT_ARRAY(-0x01);
    }
#endif
	
	while(len)
		*out++ = sqrt(*in1++);
}



//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//-=-=-=-=-=-=-=-=-=-=-=-=-=-= E N D =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=


