190 lines
7.5 KiB
Plaintext
190 lines
7.5 KiB
Plaintext
//Embedded C++ Library
|
|
//Copyright (c) Hitachi,Ltd. 1997
|
|
//Licensed material of Hitachi,Ltd
|
|
|
|
//====================================================================
|
|
// File: complex
|
|
// Purpose: Numerics library / Complex numbers
|
|
// Header <complex>
|
|
// Create: 1997.09.20 Rev. 1.0
|
|
//====================================================================
|
|
|
|
#ifndef _COMPLEX_
|
|
#define _COMPLEX_
|
|
|
|
#include <istream>
|
|
#include <ostream>
|
|
|
|
class float_complex; // based on float
|
|
class double_complex; // based on double
|
|
|
|
// complex specialization
|
|
class float_complex {
|
|
public:
|
|
typedef float value_type;
|
|
|
|
float_complex(float re = 0.0f, float im = 0.0f){
|
|
_re = re; _im = im; return; }
|
|
float_complex(const double_complex&);
|
|
float real() const{ return (_re);}
|
|
float imag() const{ return (_im);}
|
|
|
|
float_complex& operator= (float rhs){
|
|
_re = rhs; _im = 0.0; return *this; }
|
|
float_complex& operator+=(float rhs){ _re += rhs; return *this; }
|
|
float_complex& operator-=(float rhs){ _re -= rhs; return *this; }
|
|
float_complex& operator*=(float rhs){
|
|
_re *= rhs; _im *= rhs; return *this; }
|
|
float_complex& operator/=(float rhs){
|
|
_re /= rhs; _im /= rhs; return *this; }
|
|
|
|
float_complex& operator=(const float_complex&rhs){
|
|
_re = rhs.real(); _im = rhs.imag(); return *this; }
|
|
float_complex& operator+=(const float_complex&rhs){
|
|
_re += rhs.real(); _im += rhs.imag(); return *this; }
|
|
float_complex& operator-=(const float_complex&rhs){
|
|
_re -= rhs.real(); _im -= rhs.imag(); return *this; }
|
|
float_complex& operator*=(const float_complex&);
|
|
float_complex& operator/=(const float_complex&);
|
|
private:
|
|
float _re, _im;
|
|
};
|
|
|
|
class double_complex {
|
|
public:
|
|
typedef double value_type;
|
|
|
|
double_complex(double re = 0.0, double im = 0.0){
|
|
_re = re; _im = im; return; }
|
|
double_complex(const float_complex&rhs){
|
|
_re = (double)rhs.real(); _im = (double)rhs.imag(); return; }
|
|
double real() const{ return (_re);}
|
|
double imag() const{ return (_im);}
|
|
|
|
double_complex& operator= (double rhs){
|
|
_re = rhs; _im = 0.0; return *this; }
|
|
double_complex& operator+=(double rhs){ _re += rhs; return *this; }
|
|
double_complex& operator-=(double rhs){ _re -= rhs; return *this; }
|
|
double_complex& operator*=(double rhs){
|
|
_re *= rhs; _im *= rhs; return *this; }
|
|
double_complex& operator/=(double rhs){
|
|
_re /= rhs; _im /= rhs; return *this; }
|
|
|
|
double_complex& operator=(const double_complex&rhs){
|
|
_re = rhs.real(); _im = rhs.imag(); return *this; }
|
|
double_complex& operator+=(const double_complex&rhs){
|
|
_re += rhs.real(); _im += rhs.imag(); return *this; }
|
|
double_complex& operator-=(const double_complex&rhs){
|
|
_re -= rhs.real(); _im -= rhs.imag(); return *this; }
|
|
double_complex& operator*=(const double_complex&);
|
|
double_complex& operator/=(const double_complex&);
|
|
private:
|
|
double _re, _im;
|
|
};
|
|
|
|
|
|
// complex non-member functions
|
|
float_complex operator+(const float_complex&);
|
|
float_complex operator-(const float_complex&);
|
|
float_complex operator+(const float_complex&, const float_complex&);
|
|
float_complex operator+(const float_complex&, const float&);
|
|
float_complex operator+(const float&, const float_complex&);
|
|
float_complex operator-(const float_complex&, const float_complex&);
|
|
float_complex operator-(const float_complex&, const float&);
|
|
float_complex operator-(const float&, const float_complex&);
|
|
float_complex operator*(const float_complex&, const float_complex&);
|
|
float_complex operator*(const float_complex&, const float&);
|
|
float_complex operator*(const float&, const float_complex&);
|
|
float_complex operator/(const float_complex&, const float_complex&);
|
|
float_complex operator/(const float_complex&, const float&);
|
|
float_complex operator/(const float&, const float_complex&);
|
|
bool operator==(const float_complex&, const float_complex&);
|
|
bool operator==(const float_complex&, const float&);
|
|
bool operator==(const float&, const float_complex&);
|
|
bool operator!=(const float_complex&, const float_complex&);
|
|
bool operator!=(const float_complex&, const float&);
|
|
bool operator!=(const float&, const float_complex&);
|
|
istream& operator>>(istream&, float_complex&);
|
|
ostream& operator<<(ostream&, const float_complex&);
|
|
|
|
double_complex operator+(const double_complex&);
|
|
double_complex operator-(const double_complex&);
|
|
double_complex operator+(const double_complex&, const double_complex&);
|
|
double_complex operator+(const double_complex&, const double&);
|
|
double_complex operator+(const double&, const double_complex&);
|
|
double_complex operator-(const double_complex&, const double_complex&);
|
|
double_complex operator-(const double_complex&, const double&);
|
|
double_complex operator-(const double&, const double_complex&);
|
|
double_complex operator*(const double_complex&, const double_complex&);
|
|
double_complex operator*(const double_complex&, const double&);
|
|
double_complex operator*(const double&, const double_complex&);
|
|
double_complex operator/(const double_complex&, const double_complex&);
|
|
double_complex operator/(const double_complex&, const double&);
|
|
double_complex operator/(const double&, const double_complex&);
|
|
bool operator==(const double_complex&, const double_complex&);
|
|
bool operator==(const double_complex&, const double&);
|
|
bool operator==(const double&, const double_complex&);
|
|
bool operator!=(const double_complex&, const double_complex&);
|
|
bool operator!=(const double_complex&, const double&);
|
|
bool operator!=(const double&, const double_complex&);
|
|
istream& operator>>(istream&, double_complex&);
|
|
ostream& operator<<(ostream&, const double_complex&);
|
|
|
|
// complex value operations
|
|
float real(const float_complex&);
|
|
float imag(const float_complex&);
|
|
float abs(const float_complex&);
|
|
float arg(const float_complex&);
|
|
float norm(const float_complex&);
|
|
float_complex conj(const float_complex&);
|
|
float_complex polar(const float&, const float&);
|
|
|
|
double real(const double_complex&);
|
|
double imag(const double_complex&);
|
|
double abs(const double_complex&);
|
|
double arg(const double_complex&);
|
|
double norm(const double_complex&);
|
|
double_complex conj(const double_complex&);
|
|
double_complex polar(const double&, const double&);
|
|
|
|
// complex transcendentals
|
|
|
|
#ifdef sqrt
|
|
#undef sqrt
|
|
extern "C" double sqrt(double);
|
|
#endif
|
|
|
|
float_complex cos (const float_complex&);
|
|
float_complex cosh (const float_complex&);
|
|
float_complex exp (const float_complex&);
|
|
float_complex log (const float_complex&);
|
|
float_complex log10(const float_complex&);
|
|
|
|
float_complex pow(const float_complex&, int);
|
|
float_complex pow(const float_complex&, const float&);
|
|
float_complex pow(const float_complex&, const float_complex&);
|
|
float_complex pow(const float&, const float_complex&);
|
|
float_complex sin (const float_complex&);
|
|
float_complex sinh (const float_complex&);
|
|
float_complex sqrt (const float_complex&);
|
|
float_complex tan (const float_complex&);
|
|
float_complex tanh (const float_complex&);
|
|
|
|
double_complex cos (const double_complex&);
|
|
double_complex cosh (const double_complex&);
|
|
double_complex exp (const double_complex&);
|
|
double_complex log (const double_complex&);
|
|
double_complex log10(const double_complex&);
|
|
|
|
double_complex pow(const double_complex&, int);
|
|
double_complex pow(const double_complex&, const double&);
|
|
double_complex pow(const double_complex&, const double_complex&);
|
|
double_complex pow(const double&, const double_complex&);
|
|
double_complex sin (const double_complex&);
|
|
double_complex sinh (const double_complex&);
|
|
double_complex sqrt (const double_complex&);
|
|
double_complex tan (const double_complex&);
|
|
double_complex tanh (const double_complex&);
|
|
|
|
#endif
|