---

Amath.cc

Go to the documentation of this file.

// Amath.cc
// SuperMix version 1.0  C++ source file
//
// Copyright (c) 1999 California Institute of Technology.
// All rights reserved.
//
// Redistribution and use in source and binary forms for noncommercial
// purposes are permitted provided that the above copyright notice and
// this paragraph are duplicated in all such forms and that any
// documentation and other materials related to such distribution and
// use acknowledge that the software was developed by California
// Institute of Technology. Redistribution and/or use in source or
// binary forms is not permitted for any commercial purpose. Use of
// this software does not include a permitted use of the Institute's
// name or trademark for any purpose.
//
// DISCLAIMER:
// THIS SOFTWARE AND/OR RELATED MATERIALS ARE PROVIDED "AS-IS" WITHOUT
// WARRANTY OF ANY KIND INCLUDING ANY WARRANTIES OF PERFORMANCE OR
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE OR PURPOSE (AS SET
// FORTH IN UCC 23212-2313) OR FOR ANY PURPOSE WHATSOEVER, FOR THE
// LICENSED PRODUCT, HOWEVER USED.  IN NO EVENT SHALL CALTECH/JPL BE
// LIABLE FOR ANY DAMAGES AND/OR COSTS, INCLUDING BUT NOT LIMITED TO
// INCIDENTAL OR CONSEQUENTIAL DAMAGES OF ANY KIND, INCLUDING ECONOMIC
// DAMAGE OR INJURY TO PROPERTY AND LOST PROFITS, REGARDLESS OF
// WHETHER CALTECH/JPL SHALL BE ADVISED, HAVE REASON TO KNOW, OR IN
// FACT SHALL KNOW OF THE POSSIBILITY.  THE USER BEARS ALL RISK
// RELATING TO QUALITY AND PERFORMANCE OF THE SOFTWARE AND/OR RELATED
// MATERIALS.
//
// Change history:
// 11/11/98: Changed appropriate arguments to const
// 9/19/97:  Added Aapply()

#include "Amath.h"

void Aset( Complex dest[], Complex s, int len )
{
  register Complex * d = dest + len;
  while (d != dest) *(--d) = s;
}

void Aset( double dest[], double s, int len )
{
  register double * d = dest + len;
  while (d != dest) *(--d) = s;
}

void Ascale( Complex dest[], double s, int len )
{
  register Complex * d = dest + len;
  while (d != dest) *(--d) *= s;
}

void Ascale( Complex dest[], Complex s, int len )
{
  register Complex * d = dest + len;
  while (d != dest) *(--d) *= s;
}

void Ascale( double dest[], double s, int len )
{
  register double * d = dest + len;
  while (d != dest) *(--d) *= s;
}

void Aadd( Complex *dest, const Complex *source, int len )
{
  register Complex * d = dest + len;
  register const Complex * s = source + len;

  while (d != dest) *(--d) += *(--s);
}

void Aadd( double *dest, const double *source, int len )
{
  register double * d = dest + len;
  register const double * s = source + len;

  while (d != dest) *(--d) += *(--s);
}

void Aadd( Complex *dest, const double *source, int len )
{
  register Complex * d = dest + len;
  register const double * s = source + len;

  while (d != dest) *(--d) += *(--s);
}

void Asub( Complex *dest, const Complex *source, int len )
{
  register Complex * d = dest + len;
  register const Complex * s = source + len;

  while (d != dest) *(--d) -= *(--s);
}

void Asub( double *dest, const double *source, int len )
{
  register double * d = dest + len;
  register const double * s = source + len;

  while (d != dest) *(--d) -= *(--s);
}

void Asub( Complex *dest, const double *source, int len )
{
  register Complex * d = dest + len;
  register const double * s = source + len;

  while (d != dest) *(--d) -= *(--s);
}

void Ascalesub( Complex *dest, const Complex *source, Complex scale, int len )
{
  register Complex * d = dest + len;
  register const Complex * s = source + len;

  while (d != dest) *(--d) -= ((*(--s)) * scale);
}

void Ascalesub( double *dest, const double *source, double scale, int len )
{
  register double * d = dest + len;
  register const double * s = source + len;
  register double rs = scale;

  while (d != dest) *(--d) -= ((*(--s)) * rs);
}

Complex Adot( const Complex *a1, const Complex *a2, int len )
{
  register const Complex * ra1 = a1 + len;
  register const Complex * ra2 = a2 + len;
  Complex sum(0.0);

  while (ra1 != a1) sum += (conj(*(--ra1)) * (*(--ra2)));
  return sum;
}

double Adot( const double *a1, const double *a2, int len )
{
  register const double * ra1 = a1 + len;
  register const double * ra2 = a2 + len;
  register double sum = 0.0;;

  while (ra1 != a1) sum += (*(--ra1)) * (*(--ra2));
  return sum;
}

void Aapply( Complex a[], Complex (* f)(Complex), int len)
{
  register Complex * d = a + len;
  while (d-- != a) *d = f(*d);
}

void Aapply( Complex a[], Complex (* f)(Complex &), int len)
{
  register Complex * d = a + len;
  while (d-- != a) *d = f(*d);
}

void Aapply( Complex a[], Complex (* f)(const Complex &), int len)
{
  register Complex * d = a + len;
  while (d-- != a) *d = f(*d);
}

void Aapply( double a[], double (* f)(double), int len)
{
  register double * d = a + len;
  while (d-- != a) *d = f(*d);
}

void Aapply( double a[], double (* f)(double &), int len)
{
  register double * d = a + len;
  while (d-- != a) *d = f(*d);
}

void Aapply( double a[], double (* f)(const double &), int len)
{
  register double * d = a + len;
  while (d-- != a) *d = f(*d);
}

---

Please direct comments and corrections to supermix@submm.caltech.edu
Go to the supermix home page
Generated by 1.2.7