---

SIScmplx.cc

Go to the documentation of this file.

// SIScmplx.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/16/99: Got rid of "+i-0" nonsense
// 9/27/99:  Added the db io_mode, and function dtoz()
// 11/10/98: added inverse trig and hypb fcns

#include "SIScmplx.h"
#include "global.h"
#include <iostream.h>
#include <iomanip.h>
#include <string>
#include <strstream.h>
#include <math.h>


//---------------------------------------------------------------------
// i/o formatting static variables

static Complex::io_mode _out_mode, _in_mode;

static int _in_form;

static string _out_prefix, _out_suffix, _out_separator;


//---------------------------------------------------------------------
// set output formatting

Complex::io_mode Complex::out_mode()
{ return _out_mode; } 

Complex::io_mode Complex::out_mode(Complex::io_mode m)
{ io_mode temp = _out_mode; _out_mode = m; return temp; } 

string Complex::out_prefix()
{ return _out_prefix; }

string Complex::out_prefix(const string & s)
{ string temp = _out_prefix; _out_prefix = s; return temp; }

string Complex::out_prefix(const char * const s)
{ string temp = _out_prefix; _out_prefix = s; return temp; }

string Complex::out_prefix(const char s)
{ string temp = _out_prefix; _out_prefix = s; return temp; }

string Complex::out_separator()
{ return _out_separator; }

string Complex::out_separator(const string & s)
{ string temp = _out_separator; _out_separator = s; return temp; }

string Complex::out_separator(const char * const s)
{ string temp = _out_separator; _out_separator = s; return temp; }

string Complex::out_separator(const char s)
{ string temp = _out_separator; _out_separator = s; return temp; }

string Complex::out_suffix()
{ return _out_suffix; }

string Complex::out_suffix(const string & s)
{ string temp = _out_suffix; _out_suffix = s; return temp; }

string Complex::out_suffix(const char * const s)
{ string temp = _out_suffix; _out_suffix = s; return temp; }

string Complex::out_suffix(const char s)
{ string temp = _out_suffix; _out_suffix = s; return temp; }

void Complex::out_default()
{ _out_prefix = _out_separator = _out_suffix = ""; }

void Complex::out_space()
{ _out_prefix = _out_suffix = ""; _out_separator = " "; }

void Complex::out_delimited()
{ _out_prefix = "("; _out_separator = ","; _out_suffix = ")"; }


//---------------------------------------------------------------------
// set input formatting

Complex::io_mode Complex::in_mode()
{ return _in_mode; } 

Complex::io_mode Complex::in_mode(Complex::io_mode m)
{ io_mode temp = _in_mode; _in_mode = m; return temp; } 

int Complex::in_form()
{ return _in_form; }

int Complex::in_form(int f)
{ int temp = _in_form; _in_form = (f != 0); return temp; }


//---------------------------------------------------------------------
// i/o functions

ostream & operator <<(ostream & out_file, Complex z)
{
  ostrstream zout;
  zout.setf(out_file.flags());
  zout.precision(out_file.precision());
  zout.fill(out_file.fill());

  string separator(_out_separator);

  if (z.imaginary == 0.0) z.imaginary = 0.0;  // get rid of "-0" outputs

  switch ( _out_mode) {

  default:
  case Complex::cartesian: {
    if (separator == "") {
      if (z.imaginary < 0.0) {
        separator = "-i";
        z.imaginary = -z.imaginary;
      }
      else
        separator = "+i";
    }

    zout << _out_prefix << z.real << separator
         << z.imaginary << _out_suffix << '\000';
    break;
  }

  case Complex::polar: {
    if (separator == "") separator = " ";

    zout << _out_prefix << abs(z) << separator
         << arg(z) << _out_suffix << '\000';
    break;
  }

  case Complex::degree: {
    if (separator == "") separator = " ";

    zout << _out_prefix << abs(z) << separator
         << arg(z)/Degree << _out_suffix << '\000';
    break;
  }

  case Complex::db: {
    if (separator == "") separator = " ";

    zout << _out_prefix << 20*log10(abs(z)) << separator
         << arg(z)/Degree << _out_suffix << '\000';
    break;
  }

  } // switch


  return out_file << zout.str();
}


istream & operator >>(istream & in_file, Complex & z)
{
  double re = 0, im = 0;

  if (_in_form == 0) {  // the default behavior
    in_file >> re >> im;
  }
  else {  // delimited input form
    char c = 0;
    in_file >> c;
    if (c == '(') {
      in_file >> re >> c;
      if (c == ',')
        in_file >> im >> c;
      if (c != ')')
        in_file.clear(ios::badbit);  // invalid - set state
    }
    else {
      in_file.putback(c);
      in_file >> re;
    }
  }

  if (in_file) z = dtoz(re,im);  // everything went well
  return in_file;
}

Complex dtoz(double re, double im)
{
  Complex z;

  switch (_in_mode) {

  default:
  case Complex::cartesian: {
    z = Complex(re,im);
    break;
  }

  case Complex::db: {
    re = pow(10.0, re/20.0); // convert decibel magnitude
    // fall through to case Complex::degree
  }

  case Complex::degree: {
    im *= Degree;  // convert phase to radians
    // fall through to case Complex::polar
  }

  case Complex::polar: {
    if (im == 0.0)
      z = re;
    else
      z = polar(re,im);
    break;
  }

  } // switch

  return z;
}


//---------------------------------------------------------------------
// functions which use <math.h>:

// absolute value (magnitude):

double zabs( const Complex & z )
{
  return sqrt( z.real*z.real + z.imaginary*z.imaginary );
}

double zarg( const Complex & z )
{
  return atan2( z.imaginary, z.real );
}

Complex log( const Complex & z )
{
  return Complex (log(abs(z)), arg(z));
}

Complex exp( const Complex & z )
{
  return polar(exp(z.real), z.imaginary);
}

Complex log10( const Complex & z )
{
  return log(z)/log(10.0);
}

Complex pow( const Complex & z, const double d )
{
  return polar(pow(abs(z),d), d * arg(z));
}

Complex pow( Complex z1, const Complex & z2 )
{
  z1 = Complex( log(abs(z1)), arg(z1) ); // use z1 as temp variable
  return polar( exp(z1.real * z2.real - z1.imaginary * z2.imaginary),
                z1.real * z2.imaginary + z1.imaginary * z2.real );
}

Complex cos( const Complex & z )
{
  return Complex( cos(z.real)*cosh(z.imaginary), 
                  -sin(z.real)*sinh(z.imaginary) );
}

Complex sin( const Complex & z )
{
  return Complex( sin(z.real)*cosh(z.imaginary),
                  cos(z.real)*sinh(z.imaginary) );
}

Complex tan( Complex z )
{
  z *= 2;  // use z as a temp variable
  return Complex( sin(z.real), sinh(z.imaginary) )/
    ( cos(z.real) + cosh(z.imaginary) );
}

Complex cosh( const Complex & z )
{
  return Complex( cosh(z.real)*cos(z.imaginary), 
                  +sinh(z.real)*sin(z.imaginary) );
}

Complex sinh( const Complex & z )
{
  return Complex( sinh(z.real)*cos(z.imaginary),
                  cosh(z.real)*sin(z.imaginary) );
}

Complex tanh( Complex z )
{
  z *= 2;  // use z as a temp variable
  return Complex( sinh(z.real), sin(z.imaginary) )/
    ( cosh(z.real) + cos(z.imaginary) );
}

Complex asin( const Complex & z )
{
  return -I*log(I*z+sqrt(1-z*z));
}

Complex acos( const Complex & z )
{
  return -I*log(z+I*sqrt(1-z*z));
}

Complex atan( Complex z )
{
  z *= I;
  return log((1+z)/(1-z))/(2*I);
}

Complex asinh( const Complex & z )
{
  return log(z+sqrt(z*z+1));
}

Complex acosh( const Complex & z )
{
  return log(z+sqrt(z*z-1));
}

Complex atanh( Complex z )
{
  return 0.5*log((1+z)/(1-z));
}

---

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