Category : C++ Source Code
Archive   : OOPSVEC.ZIP
Filename : DBLV.CXX

/* m4Vec.h -- M4 code templates for OOPS Vector classes

THIS SOFTWARE FITS THE DESCRIPTION IN THE U.S. COPYRIGHT ACT OF A
"UNITED STATES GOVERNMENT WORK". IT WAS WRITTEN AS A PART OF THE
AUTHOR'S OFFICIAL DUTIES AS A GOVERNMENT EMPLOYEE. THIS MEANS IT
CANNOT BE COPYRIGHTED. THIS SOFTWARE IS FREELY AVAILABLE TO THE
PUBLIC FOR USE WITHOUT A COPYRIGHT NOTICE, AND THERE ARE NO
RESTRICTIONS ON ITS USE, NOW OR SUBSEQUENTLY.

Author:
K. E. Gorlen
Bg. 12A, Rm. 2017
Computer Systems Laboratory
Division of Computer Research and Technology
National Institutes of Health
Bethesda, Maryland 20892
Phone: (301) 496-5363
uucp: {decvax!}seismo!elsie!cecil!keith
May, 1986

Function:

This file contains M4 macro definitions for almost all of the functions
needed to implement the OOPS vector classes.

Modification History:

$Log: Vec.m4,v $
Revision 1.1 88/01/17 09:47:23 keith
Initial revision


*/
// WARNING: Modify the M4 macros, not the C++ code they generate!
// WARNING: Assumes 8 bits per character.

#include "oopserrs.h"
#include "bitvecma.h"
#include "DblVe.hxx"
#include "oopsIO.hxx"

DEFINE_CLASS(DblVec,Vector,1,"$Header: Vec.m4,v 1.1 88/01/17 09:47:23 keith Exp $",NULL,NULL);
/*
typedef float Float;
typedef double Dbl;
typedef unsigned char Byte;
typedef short Short;
typedef int Int;
typedef long Long;
*/
#define Float float
#define Dbl double
#define Byte unsigned char
#define Short short
#define Int int
#define Long long

inline void DblCopy(const Dbl* src, Dbl* dst, unsigned n)
// Copy n Dbl elements from src to dst.
{
register const Dbl* sp = src;
register Dbl* dp = dst;
register unsigned i = n;
while (i--) *dp++ = *sp++;
}

void TempDblVec::free() { delete this; }

bool DblVec::isEqual(const Object& u)
// Test DblVecs equal.
{
register DblVec& U = *(DblVec*)&u;
if (!u.isSpecies(class_DblVec) || n!=U.n) return NO;
register unsigned i = n;
register Dbl* vp = v;
register Dbl* up = U.v;
while (i--) if (*vp++ != *up++) return NO;
return YES;
}

const Class* DblVec::species() { return &class_DblVec; }

Object* DblVec::shallowCopy()
{
shouldNotImplement("shallowCopy");
return 0;
}

void DblVec::deepenShallowCopy()
// Make a deep copy of this DblVec.
{
if (n != 0) {
Dbl* src = v;
v = new Dbl[n];
DblCopy(src,v,n);
}
}

DblVec::DblVec(fileDescTy& fd, DblVec& where) : (fd,where)
{
this = &where;
v = new Dbl[n];
readBin(fd,v,n);
}

void DblVec::storer(fileDescTy& fd)
{
Vector::storer(fd);
storeBin(fd,v,n);
}

//extern const int OOPS_INDEXRANGE;
//extern const int OOPS_SLICERANGE;
//extern const int OOPS_VECTORLENGTH;
//extern const int OOPS_VECTORSELECT;

void DblVec::indexRangeErr()
{
setOOPSerror(OOPS_INDEXRANGE,DEFAULT,this,className());
}

void DblVec::selectErr(const BitVec& V)
{
setOOPSerror(OOPS_VECTORSELECT,DEFAULT,this,"DblVec",length(),sum(V),&V,V.length());
}

void DblSlice::selectErr(const BitVec& V)
{
setOOPSerror(OOPS_VECTORSELECT,DEFAULT,this,"DblSlice",length(),sum(V),&V,V.length());
}

void DblSlice::lengthErr(const DblSlice& V)
{
setOOPSerror(OOPS_VECTORLENGTH,DEFAULT,this,"DblSlice",length(),&V,"DblSlice",V.length());
}

void DblSlice::lengthErr(const IntVec& V)
{
setOOPSerror(OOPS_VECTORLENGTH,DEFAULT,this,"DblSlice",length(),&V,"IntVec",V.length());
}

void DblSlice::lengthErr(const DblVec& V)
{
setOOPSerror(OOPS_VECTORLENGTH,DEFAULT,this,"DblSlice",length(),&V,"DblVec",V.length());
}

DblVec::DblVec(register unsigned lngth) : (lngth)
// Construct an uninitialized DblVec of the length specified.
{
v = NULL;
if (lngth != 0) v = new Dbl[lngth];
}

DblVec::DblVec(register unsigned lngth, Dbl from, Dbl by) : (lngth)
// Construct a DblVec of the length specified and initialize it to
// (v[0] = from, v[i] = v[i-1]+by for i = 1...n-1)
{
v = NULL;
if (lngth != 0) {
v = new Dbl[lngth];
register Dbl* vp =v;
for (register Dbl x =from; lngth-- >0; x += by) *vp++ = x;
}
}

DblVec::DblVec(const Dbl* src, unsigned lngth) : (lngth)
// Construct a DblVec and initialize it from the specified Dbl vector.
{
v = NULL;
if (lngth != 0) {
v = new Dbl[lngth];
DblCopy(src,v,lngth);
}
}

DblVec::DblVec(const DblVec& U) : (U.n)
// Construct a DblVec and initialize it from the specified DblVec U.
{
v = NULL;
if (n != 0) {
v = new Dbl[n];
DblCopy(U.v,v,n);
}
}

DblVec::DblVec(const DblSlice& s) : (s.length())
// Construct a DblVec from a slice of another DblVec.
{
v = NULL;
if (n != 0) {
v = new Dbl[n];
register Dbl* sp = s;
register Dbl* dp = v;
register i = s.length();
register j = s.stride();
while (i--) { *dp++ = *sp; sp += j; }
}
}

DblSlice::DblSlice(DblVec& v, int pos, unsigned lgt, int stride)
// Construct a DblSlice from a DblVec.
{
if ((unsigned)(pos + (lgt-1)*stride) > v.length())
setOOPSerror(OOPS_SLICERANGE,DEFAULT,&v,v.className(),v.length(),pos,lgt,stride);
V = &v; p = &v[pos]; l = lgt; k = stride;
}

DblSlice::DblSlice(const DblPick& s)
// Construct a DblVec slice from IntVec-subscripted elements of DblVec.
{
DblVec& T = *new TempDblVec();
T = (*s.V)[*s.X];
V = &T; p = T; l = T.length(); k = 1;
}

DblSlice::DblSlice(const DblSlct& s)
// Construct a DblVec slice from DblVec-selected elements of DblVec.
{
DblVec& T = *new TempDblVec();
T = (*s.V)[*s.B];
V = &T; p = T; l = T.length(); k = 1;
}

void DblVec::operator=(const DblVec& U)
// Assign the argument DblVec U to this DblVec.
{
if (v != U.v) {
delete v;
v = NULL;
if ((n = U.n) != 0) {
v = new Dbl[n];
DblCopy(U.v,v,n);
}
}
}

void DblVec::operator=(const DblSlice& s)
// Assign a slice of a DblVec to this DblVec.
{
register i = s.length(); // slice length
if ((n = i) == 0) { // empty slice
delete v;
v = NULL;
return;
}
register Dbl* sp = s;
register j = s.stride();
if (this == s.V) { // V = V(i,j,k)
Dbl* t = v;
register Dbl* dp = new Dbl[i];
v = dp;
while (i--) { *dp++ = *sp; sp += j; }
delete t;
}
else {
delete v;
register Dbl* dp = new Dbl[i];
v = dp;
while (i--) { *dp++ = *sp; sp += j; }
}
}

void DblVec::operator=(const DblSlct& s)
// Assign the BitVec-selected elements of a DblVec to this DblVec.
{
if ((n = sum(*s.B)) == 0) { // return zero length result
delete v;
v = NULL;
return;
}
register Dbl* sp = *s.V;
Dbl* t = v;
if (this != s.V) delete t; // not V = V[BitVec&]
register Dbl* dp = new Dbl[n];
v = dp;
BITVECSCAN(*s.B, s.length(), *dp++ = *sp; sp++)
if (this == s.V) delete t; // case V = V[BitVec&]
}

void DblVec::operator=(const DblPick& s)
// Assign the IntVec-subscripted elements of a DblVec to this DblVec.
{
register unsigned i = s.length();
unsigned l;
if ((l = i) == 0) { // return zero length result
delete v;
v = NULL; n = 0;
return;
}
Dbl* t = v;
if (this != s.V) delete t; // not V = V[IntVec&]
register Dbl* dp = new Dbl[l];
Dbl* u = dp;
register int* xp = *s.X;
register DblVec& S = *s.V;
while (i--) { *dp++ = S[*xp++]; }
v = u; n = l;
if (this == s.V) delete t; // case V = V[IntVec&]
}

void DblVec::operator=(Dbl scalar)
// Assign a scalar to all elements of this DblVec.
{
register unsigned i = n;
register Dbl* dp = v;
register Dbl c = scalar;
while (i--) *dp++ = c;
}

void DblSlice::operator=(const DblVec& U)
// Assign a DblVec to this DblVec slice.
{
register i = l;
if (i != U.length()) lengthErr(U);
register Dbl* dp = p;
register Dbl* sp = U;
register j = k;
while (i--) { *dp = *sp++; dp += j; }
}

void DblSlice::operator=(const DblSlice& s)
// Assign a DblVec slice to this DblVec slice.
{
register i = l;
if (i != s.l) lengthErr(s);
register Dbl* dp = p;
register Dbl* sp = s.p;
register dj = k;
register sj = s.k;
while (i--) { *dp = *sp; dp += dj; sp += sj; }
}

void DblSlice::operator=(const DblPick& s)
// Assign the IntVec-subscripted elements of a DblVec to this DblVec slice.
{
register i = l;
if (i != s.length()) lengthErr(*s.X);
register Dbl* dp = p;
register int* xp = *s.X;
register j = k;
register DblVec& S = *s.V;
while (i--) { *dp = S[*xp++]; dp += j; }
}

void DblSlice::operator=(const DblSlct& s)
// Assign the BitVec-selected elements of a DblVec to this DblVec slice.
{
if (l != sum(*s.B)) lengthErr(s);
register Dbl* sp = *s.V;
register Dbl* dp = p;
register j = k;
BITVECSCAN(*s.B, s.length(), { *dp = *sp; dp += j; }; sp++)
}

void DblSlice::operator=(Dbl scalar)
// Assign a scalar to all elements of this DblVec slice.
{
register i = l;
register j = k;
register Dbl* dp = p;
register Dbl c = scalar;
while (i--) { *dp = c; dp += j; }
}

DblVec operator-(const DblSlice& s)
// Unary operator on DblVec slice.
{
register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
while (i--) { *dp++ = -(*sp); sp += j; }
return T;
}

DblVec operator++(DblSlice& s)
// Unary inc/dec operator on DblVec slice.
{
register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
while (i--) { *dp++ = ++(*sp); sp += j; }
return T;
}

DblVec operator--(DblSlice& s)
// Unary inc/dec operator on DblVec slice.
{
register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
while (i--) { *dp++ = --(*sp); sp += j; }
return T;
}

DblVec operator+(const DblSlice& u, const DblSlice& v)
// Binary arithmetic operator on two DblVec slices
{
register i = u.length();
if (i != v.length()) u.lengthErr(v);
DblVec T(i);
register Dbl* up = u;
register Dbl* vp = v;
register Dbl* dp = T;
register uj = u.stride();
register vj = v.stride();
while (i--) { *dp++ = *up + *vp; up += uj; vp += vj; }
return T;
}

DblVec operator-(const DblSlice& u, const DblSlice& v)
// Binary arithmetic operator on two DblVec slices
{
register i = u.length();
if (i != v.length()) u.lengthErr(v);
DblVec T(i);
register Dbl* up = u;
register Dbl* vp = v;
register Dbl* dp = T;
register uj = u.stride();
register vj = v.stride();
while (i--) { *dp++ = *up - *vp; up += uj; vp += vj; }
return T;
}

DblVec operator*(const DblSlice& u, const DblSlice& v)
// Binary arithmetic operator on two DblVec slices
{
register i = u.length();
if (i != v.length()) u.lengthErr(v);
DblVec T(i);
register Dbl* up = u;
register Dbl* vp = v;
register Dbl* dp = T;
register uj = u.stride();
register vj = v.stride();
while (i--) { *dp++ = *up * *vp; up += uj; vp += vj; }
return T;
}

DblVec operator/(const DblSlice& u, const DblSlice& v)
// Binary arithmetic operator on two DblVec slices
{
register i = u.length();
if (i != v.length()) u.lengthErr(v);
DblVec T(i);
register Dbl* up = u;
register Dbl* vp = v;
register Dbl* dp = T;
register uj = u.stride();
register vj = v.stride();
while (i--) { *dp++ = *up / *vp; up += uj; vp += vj; }
return T;
}

DblVec operator*(const DblSlice& s, Dbl scalar)
// Binary arithmetic operator on DblVec slice and scalar.
{
register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp++ = *sp * c; sp += j; }
return T;
}

DblVec operator/(const DblSlice& s, Dbl scalar)
// Binary arithmetic operator on DblVec slice and scalar.
{
register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp++ = *sp / c; sp += j; }
return T;
}

DblVec operator+(const DblSlice& s, Dbl scalar)
// Binary arithmetic operator on DblVec slice and scalar.
{
register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp++ = *sp + c; sp += j; }
return T;
}

DblVec operator-(const DblSlice& s, Dbl scalar)
// Binary arithmetic operator on DblVec slice and scalar.
{

register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp++ = *sp - c; sp += j; }
return T;
}

DblVec operator/(Dbl scalar, const DblSlice& s)
// Binary arithmetic operator on scalar and DblVec slice.
{
register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp++ = c / *sp; sp += j; }
return T;
}

DblVec operator-(Dbl scalar, const DblSlice& s)
// Binary arithmetic operator on scalar and DblVec slice.
{
register i = s.length();
DblVec T(i);
register Dbl* sp = s;
register Dbl* dp = T;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp++ = c - *sp; sp += j; }
return T;
}

BitVec operator<(const DblSlice& u, const DblSlice& v)
// Relational operator on two DblVec slices.
{
if (u.length() != v.length()) u.lengthErr(v);
BitVec B(u.length());
register Dbl* up = u;
register Dbl* vp = v;
register uj = u.stride();
register vj = v.stride();
BITVECGEN(B, u.length(), *up < *vp, up += uj; vp += vj)
return B;
}

BitVec operator<=(const DblSlice& u, const DblSlice& v)
// Relational operator on two DblVec slices.
{
if (u.length() != v.length()) u.lengthErr(v);
BitVec B(u.length());
register Dbl* up = u;
register Dbl* vp = v;
register uj = u.stride();
register vj = v.stride();
BITVECGEN(B, u.length(), *up <= *vp, up += uj; vp += vj)
return B;
}

BitVec operator==(const DblSlice& u, const DblSlice& v)
// Relational operator on two DblVec slices.
{
if (u.length() != v.length()) u.lengthErr(v);
BitVec B(u.length());
register Dbl* up = u;
register Dbl* vp = v;
register uj = u.stride();
register vj = v.stride();
BITVECGEN(B, u.length(), *up == *vp, up += uj; vp += vj)
return B;
}

BitVec operator!=(const DblSlice& u, const DblSlice& v)
// Relational operator on two DblVec slices.
{
if (u.length() != v.length()) u.lengthErr(v);
BitVec B(u.length());
register Dbl* up = u;
register Dbl* vp = v;
register uj = u.stride();
register vj = v.stride();
BITVECGEN(B, u.length(), *up != *vp, up += uj; vp += vj)
return B;
}

BitVec operator<(const DblSlice& s, Dbl scalar)
// Relational operator on DblVec slice and scalar.
{
BitVec B(s.length());
register Dbl* vp = s;
register vj = s.stride();
register Dbl c = scalar;
BITVECGEN(B, s.length(), *vp < c, vp += vj)
return B;
}

BitVec operator>(const DblSlice& s, Dbl scalar)
// Relational operator on DblVec slice and scalar.
{
BitVec B(s.length());
register Dbl* vp = s;
register vj = s.stride();
register Dbl c = scalar;
BITVECGEN(B, s.length(), *vp > c, vp += vj)
return B;
}

BitVec operator<=(const DblSlice& s, Dbl scalar)
// Relational operator on DblVec slice and scalar.
{
BitVec B(s.length());
register Dbl* vp = s;
register vj = s.stride();
register Dbl c = scalar;
BITVECGEN(B, s.length(), *vp <= c, vp += vj)
return B;
}

BitVec operator>=(const DblSlice& s, Dbl scalar)
// Relational operator on DblVec slice and scalar.
{
BitVec B(s.length());
register Dbl* vp = s;
register vj = s.stride();
register Dbl c = scalar;
BITVECGEN(B, s.length(), *vp >= c, vp += vj)
return B;
}

BitVec operator==(const DblSlice& s, Dbl scalar)
// Relational operator on DblVec slice and scalar.
{
BitVec B(s.length());
register Dbl* vp = s;
register vj = s.stride();
register Dbl c = scalar;
BITVECGEN(B, s.length(), *vp == c, vp += vj)
return B;
}

BitVec operator!=(const DblSlice& s, Dbl scalar)
// Relational operator on DblVec slice and scalar.
{
BitVec B(s.length());
register Dbl* vp = s;
register vj = s.stride();
register Dbl c = scalar;
BITVECGEN(B, s.length(), *vp != c, vp += vj)
return B;
}

void operator+=(DblSlice& u, const DblSlice& v)
// Assignment arithmetic operator on two DblVec slices.
{
register i = u.length();
if (i != v.length()) u.lengthErr(v);
register Dbl* up = u;
register Dbl* vp = v;
register uj = u.stride();
register vj = v.stride();
while (i--) { *up += *vp; up += uj; vp += vj; }
}

void operator-=(DblSlice& u, const DblSlice& v)
// Assignment arithmetic operator on two DblVec slices.
{
register i = u.length();
if (i != v.length()) u.lengthErr(v);
register Dbl* up = u;
register Dbl* vp = v;
register uj = u.stride();
register vj = v.stride();
while (i--) { *up -= *vp; up += uj; vp += vj; }
}

void operator*=(DblSlice& u, const DblSlice& v)
// Assignment arithmetic operator on two DblVec slices.
{
register i = u.length();
if (i != v.length()) u.lengthErr(v);
register Dbl* up = u;
register Dbl* vp = v;
register uj = u.stride();
register vj = v.stride();
while (i--) { *up *= *vp; up += uj; vp += vj; }
}

void operator/=(DblSlice& u, const DblSlice& v)
// Assignment arithmetic operator on two DblVec slices.
{
register i = u.length();
if (i != v.length()) u.lengthErr(v);
register Dbl* up = u;
register Dbl* vp = v;

register uj = u.stride();
register vj = v.stride();
while (i--) { *up /= *vp; up += uj; vp += vj; }
}

void operator+=(DblSlice& s, Dbl scalar)
// Assignment arithmetic operator on scalar and DblVec slice.
{
register i = s.length();
register Dbl* dp = s;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp += c; dp += j; }
}

void operator-=(DblSlice& s, Dbl scalar)
// Assignment arithmetic operator on scalar and DblVec slice.
{
register i = s.length();
register Dbl* dp = s;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp -= c; dp += j; }
}

void operator*=(DblSlice& s, Dbl scalar)
// Assignment arithmetic operator on scalar and DblVec slice.
{
register i = s.length();
register Dbl* dp = s;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp *= c; dp += j; }
}

void operator/=(DblSlice& s, Dbl scalar)
// Assignment arithmetic operator on scalar and DblVec slice.
{
register i = s.length();
register Dbl* dp = s;
register j = s.stride();
register Dbl c = scalar;
while (i--) { *dp /= c; dp += j; }
}

void DblPick::operator=(const DblVec& U)
// Assign DblVec to IntVec-subscripted elements of DblVec.
{
register i = length();
if (i != U.length()) lengthErr(*X,U);
register int* xp = *X;
register Dbl* up = U;
register DblVec& D = *V;
while (i--) { D[*xp++] = *up++; }
}

void DblPick::operator=(const DblPick& s)
// Assign IntVec-subscripted elements of DblVec to IntVec-subscripted elements of DblVec.
{
register i = length();
if (i != s.length()) lengthErr(*X,*s.X);
register int* xp = *X;
register int* yp = *s.X;
register DblVec& D = *V;
register DblVec& S = *s.V;
while (i--) { D[*xp++] = S[*yp++]; }
}

void DblPick::operator=(const DblSlct& s)
// Assign BitVec-selected elements of DblVec to IntVec-subscripted elements of DblVec.
{
if (length() != sum(*s.B)) X->selectErr(*s.B);
register int* xp = *X;
register Dbl* sp = *s.V;
register DblVec& D = *V;
BITVECSCAN(*s.B, length(), D[*xp++] = *sp; sp++)
}

void DblPick::operator=(const DblSlice& s)
// Assign DblVec slice to IntVec-subscripted elements of DblVec.
{
register i = length();
if (i != s.length()) s.lengthErr(*X);
register int* xp = *X;
register Dbl* sp = s;
register int j = s.stride();
register DblVec& D = *V;
while (i--) { D[*xp++] = *sp; sp += j; }
}

void DblPick::operator=(Dbl scalar)
// Assign scalar to all IntVec-subscripted elements of DblVec.
{
register i = length();
register int* xp = *X;
register Dbl c = scalar;
register DblVec& D = *V;
while (i--) { D[*xp++] = c; }
}

void DblSlct::operator=(const DblVec& U)
// Assign a DblVec to BitVec-selected elements of DblVec.
{
if (U.length() != sum(*B)) U.selectErr(*B);
register Dbl* dp = *V;
register Dbl* sp = U;
BITVECSCAN(*B, U.length(), *dp = *sp++; dp++)
}

void DblSlct::operator=(const DblPick& s)
// Assign IntVec-subscripted elements of DblVec to BitVec-selected elements of DblVec.
{
if (s.length() != sum(*B)) s.X->selectErr(*B);
register Dbl* dp = *V;
register int* xp = *s.X;
register DblVec& W = *s.V;
BITVECSCAN(*B, length(), *dp = W[*xp++]; dp++)
}

void DblSlct::operator=(const DblSlct& s)
// Assign BitVec-selected elements of DblVec to BitVec-selected elements of DblVec.
{
DblVec T;
T = (*s.V)[*s.B];
(*V)[*B] = T;
}

void DblSlct::operator=(const DblSlice& s)
// Assign DblVec slice to BitVec-selected elements of DblVec.
{
if (s.length() != sum(*B)) s.selectErr(*B);
register Dbl* dp = *V;
register Dbl* sp = s;
register int j = s.stride();
BITVECSCAN(*B, length(), { *dp = *sp; sp += j; }; dp++)
}

void DblSlct::operator=(Dbl scalar)
// Assign scalar to all BitVec-selected elements of DblVec.
{
register Dbl* dp = *V;
register Dbl c = scalar;
BITVECSCAN(*B, length(), *dp = c; dp++)
}