Cubic Class Reference

#include <cubic.h>

Public Types
typedef std::complex< double >	double_complex

Public Member Functions
double	a (void) const
double	b (void) const
double	c (void) const
double	d (void) const
double	s_xzero (void) const
void	put_a (double fa)
void	put_b (double fb)
void	put_c (double fc)
void	put_d (double fd)
	Cubic (void)
	Cubic (double fa, double fb, double fc, double fd)
double	y (double x) const
void	find_zero (double_complex &z1, double_complex &z2, double_complex &z3) const
int	find_real_zero (double z[3]) const
int	find_maxmin (double xmm[2], double ymm[2], int s_mm[2]) const

Detailed Description

Definition at line 18 of file cubic.h.

Member Typedef Documentation

double_complex

typedef std::complex<double> Cubic::double_complex

Definition at line 20 of file cubic.h.

Constructor & Destructor Documentation

Cubic() [1/2]

Cubic::Cubic ( void  )

inline

Definition at line 45 of file cubic.h.

: da(0.0), db(0.0), dc(0.0), dd(0.0), s_dxzero(0) {}

Cubic() [2/2]

Cubic::Cubic ( double  fa, double  fb, double  fc, double  fd  )

inline

Definition at line 46 of file cubic.h.

      : da(fa), db(fb), dc(fc), dd(fd), s_dxzero(0) {}

Member Function Documentation

a()

double Cubic::a ( void  ) const

inline

Definition at line 21 of file cubic.h.

{ return da; }

Referenced by find_maxmin(), and operator<<().

b()

double Cubic::b ( void  ) const

inline

Definition at line 22 of file cubic.h.

{ return db; }

Referenced by operator<<().

c()

double Cubic::c ( void  ) const

inline

Definition at line 23 of file cubic.h.

{ return dc; }

Referenced by operator<<().

d()

double Cubic::d ( void  ) const

inline

Definition at line 24 of file cubic.h.

{ return dd; }

Referenced by operator<<().

find_maxmin()

int Cubic::find_maxmin	(	double	xmm[2],
		double	ymm[2],
		int	s_mm[2]
	)		const

Definition at line 122 of file cubic.cpp.

                                                                      {
  mfunname("int Cubic::find_maxmin(double xmm[2], double ymm[2], int s_mm[2]) "
           "const");
  double ap = 3 * da;
  double bp = 2 * db;
  double cp = dc;
  Parabol par(ap, bp, cp);
  s_mm[0] = 0;
  s_mm[1] = 0;
  int qz = par.find_zero(xmm);
  if (qz == 1) {
    s_mm[0] = 0;
  }
  if (qz == 2) {
    if (a() > 0) {
      s_mm[0] = 1;
      s_mm[1] = -1;
    } else {
      s_mm[0] = -1;
      s_mm[1] = 1;
    }
  }
  for (int n = 0; n < qz; ++n) {
    ymm[n] = y(xmm[n]);
  }
  return qz;
}

Referenced by operator<<().

find_real_zero()

int Cubic::find_real_zero

(

double

z[3]

)

const

Definition at line 76 of file cubic.cpp.

                                           {
  mfunname("int Cubic::find_real_zero(double z[3]) const");
  double_complex zc1;
  double_complex zc2;
  double_complex zc3;
  find_zero(zc1, zc2, zc3);
  double thresh = 10.0 * DBL_MIN;
  int q = 0;
  if (fabs(zc1.imag()) < thresh ||
      (zc1.real() != 0.0 && fabs(zc1.imag() / zc1.real()) < thresh)) {
    z[q] = zc1.real();
    q++;
  }
  if (fabs(zc2.imag()) < thresh ||
      (zc2.real() != 0.0 && fabs(zc2.imag() / zc2.real()) < thresh)) {
    z[q] = zc2.real();
    q++;
  }
  if (fabs(zc3.imag()) < thresh ||
      (zc3.real() != 0.0 && fabs(zc3.imag() / zc3.real()) < thresh)) {
    z[q] = zc3.real();
    q++;
  }
  int n1 = 0, n2 = 0;
  for (n1 = 0; n1 < q - 1; n1++) {
    for (n2 = n1; n2 < q; n2++) {
      if (z[n1] > z[n2]) {
        double t = z[n1];
        z[n1] = z[n2];
        z[n2] = t;
      }
    }
  }
  for (n1 = 0; n1 < q - 1; n1++) {
    if ((fabs(z[n1]) < thresh && fabs(z[n2]) < thresh) ||
        fabs((z[n1] - z[n1 + 1]) / (z[n1] + z[n1 + 1])) < thresh) {
      for (n2 = n1 + 1; n2 < q - 1; n2++) {
        z[n2] = z[n2 + 1];
      }
      q--;
      n1--;
    }
  }
  return q;
}

Referenced by operator<<().

find_zero()

void Cubic::find_zero	(	double_complex &	z1,
		double_complex &	z2,
		double_complex &	z3
	)		const

Definition at line 25 of file cubic.cpp.

                                                {
  mfunname("void  Cubic::find_zero(double_complex &z1, double_complex &z2, "
           "double_complex &z3) const");
  convmut(Cubic);
  if (s_dxzero == 0) {
    check_econd11a(da, == 0.0, "this is not cubic polynomial!", mcerr);
    double a2 = db / da;
    double a1 = dc / da;
    double a0 = dd / da;
    double Q = (3.0 * a1 - a2 * a2) / 9.0;
    double R = (9.0 * a2 * a1 - 27.0 * a0 - 2.0 * a2 * a2 * a2) / 54.0;
    double D = Q * Q * Q + R * R;
    double sD = sqrt(fabs(D));
    double_complex S;
    double_complex T;
    if (D >= 0.0) {
      double t = R + sD;
      if (t > 0.0) {
        S = pow(t, 1 / 3.0);
      } else if (t < 0.0) {
        S = -pow(-t, 1 / 3.0);
      } else {
        S = 0.0;
      }
      t = R - sD;
      if (t > 0.0) {
        T = pow(t, 1 / 3.0);
      } else if (t < 0.0) {
        T = -pow(-t, 1 / 3.0);
      } else {
        T = 0.0;
      }
    } else {
      S = pow(R + iu * sD, 1 / 3.0);
      T = pow(R - iu * sD, 1 / 3.0);
    }
    z1 = -a2 / 3.0 + (S + T);
    z2 = -a2 / 3.0 - (S + T) / 2.0 + 0.5 * iu * sqrt(3.0) * (S - T);
    z3 = -a2 / 3.0 - (S + T) / 2.0 - 0.5 * iu * sqrt(3.0) * (S - T);
    t.dz1 = z1;
    t.dz2 = z2;
    t.dz3 = z3;
    t.s_dxzero = 3;
  } else {
    z1 = dz1;
    z2 = dz2;
    z3 = dz3;
  }
}

Referenced by find_real_zero(), and operator<<().

put_a()

void Cubic::put_a ( double  fa )

inline

Definition at line 28 of file cubic.h.

                               {
    da = fa;
    s_dxzero = 0;
  }

put_b()

void Cubic::put_b ( double  fb )

inline

Definition at line 32 of file cubic.h.

                               {
    db = fb;
    s_dxzero = 0;
  }

put_c()

void Cubic::put_c ( double  fc )

inline

Definition at line 36 of file cubic.h.

                               {
    dc = fc;
    s_dxzero = 0;
  }

put_d()

void Cubic::put_d ( double  fd )

inline

Definition at line 40 of file cubic.h.

                               {
    dd = fd;
    s_dxzero = 0;
  }

s_xzero()

double Cubic::s_xzero ( void  ) const

inline

Definition at line 25 of file cubic.h.

                                    {
    return s_dxzero;
  }  // for debug

Referenced by operator<<().

y()

double Cubic::y ( double  x ) const

inline

Definition at line 49 of file cubic.h.

                                  {
    return da * x * x * x + db * x * x + dc * x + dd;
  }

Referenced by find_maxmin().

---

The documentation for this class was generated from the following files:

• cubic.h
• cubic.cpp