tline.h File Reference

#include "wcpplib/safetl/AbsArr.h"

Go to the source code of this file.

Classes
class	EqualStepCoorMesh< T >
class	PointCoorMesh< T, D >
class	CopiedPointCoorMesh< T >
class	AbsCoorMesh< T >
class	VirtEqualStepCoorMesh< T >
class	VirtCopiedPointCoorMesh< T >

Functions
template<class T >
std::ostream &	operator<< (std::ostream &file, const EqualStepCoorMesh< T > &f)
template<class T >
std::istream &	operator>> (std::istream &file, EqualStepCoorMesh< T > &f)
template<class T >
int	operator== (const EqualStepCoorMesh< T > &f1, const EqualStepCoorMesh< T > &f2)
template<class T >
int	apeq_mant (const EqualStepCoorMesh< T > &f1, const EqualStepCoorMesh< T > &f2, T prec)
template<class T >
int	operator!= (const EqualStepCoorMesh< T > &f1, const EqualStepCoorMesh< T > &f2)
template<class T , class D >
long	t_find_interval (double x, long q, const D &coor)
template<class T , class D >
long	t_find_interval_end (double x, long q, const D &coor, long n_start)
template<class T , class D >
std::ostream &	operator<< (std::ostream &file, const PointCoorMesh< T, D > &f)
template<class T >
std::ostream &	operator<< (std::ostream &file, CopiedPointCoorMesh< T > &f)
template<class T >
std::istream &	operator>> (std::istream &file, CopiedPointCoorMesh< T > &f)
template<class T >
int	operator== (const CopiedPointCoorMesh< T > &f1, const CopiedPointCoorMesh< T > &f2)
template<class T >
int	apeq_mant (const CopiedPointCoorMesh< T > &f1, const CopiedPointCoorMesh< T > &f2, T prec)
template<class T >
int	operator!= (const CopiedPointCoorMesh< T > &f1, const CopiedPointCoorMesh< T > &f2)
template<class T , class B >
int	verify_types (const T *ths, const B *b2, const T **tb2)
template<class T >
std::ostream &	operator<< (std::ostream &file, AbsCoorMesh< T > &f)
template<class T >
std::ostream &	operator<< (std::ostream &file, VirtEqualStepCoorMesh< T > &f)
template<class T >
std::istream &	operator>> (std::istream &file, VirtEqualStepCoorMesh< T > &f)
template<class T >
std::ostream &	operator<< (std::ostream &file, VirtCopiedPointCoorMesh< T > &f)
template<class T >
std::istream &	operator>> (std::istream &file, VirtCopiedPointCoorMesh< T > &f)
template<class T >
ActivePtr< AbsCoorMesh< T > >	read_AbsCoorMesh (std::istream &file)
template<class T , class D , class M >
T	t_value_step_ar (const M &mesh, const D &y, T x, int s_include_last_point=0)
template<class T , class D , class M1 , class M2 >
T	t_value_step_ar (const M1 &mesh1, const M2 &mesh2, const D &y, T x1, T x2, int s_include_last_point=0)
template<class T , class D , class M >
void	t_hfill_step_ar (const M &mesh, const D &y, T x, T val=1, int s_include_last_point=0)
template<class T , class D , class M >
void	t_hfill_step_ar_ac (const M &mesh, const D &y, T x, T val=1, int s_include_last_point=0)
template<class T , class D , class M1 , class M2 >
void	t_hfill_step_ar_ac (const M1 &mesh1, const M2 &mesh2, const D &y, T x1, T x2, T val=1, int s_include_last_point=0)
template<class T , class D , class M >
T	t_integ_step_ar (const M &mesh, const D &y, T x1, T x2, int xpower)
template<class T , class D , class M >
T	t_integ_generic_step_ar (const M &mesh, const D &y, T(*fun)(long np, T xp1, T xp2, T yp, T xmin, T xmax, T x1, T x2), T x1, T x2)
template<class T , class D , class M >
T	t_total_integ_step_ar (const M &mesh, const D &y)
template<class T , class D , class M1 , class M2 >
T	t_total_integ_step_ar (const M1 &mesh1, const M2 &mesh2, const D &y)
template<class T , class M1 , class M2 >
T	t_total_integ_step_ar (const M1 &mesh1, const M2 &mesh2, const DynArr< T > &y)
template<class T , class D , class M >
T	t_find_x_for_integ_step_ar (const M &mesh, const D &y, T integ, int *s_err)
template<class T , class D , class M >
T	t_find_x_for_already_integ_step_ar (const M &mesh, const D &y, T integ, int *s_err)
template<class T , class D , class M >
long	t_find_entire_x_for_already_integ_step_ar (const M &mesh, const D &y, T integ, int *s_err)
template<class T , class D , class M >
T	t_hispre_step_ar (const M &mesh, const D &y, D &integ_y)
template<class T , class D , class M >
T	t_hisran_step_ar (const M &mesh, const D &integ_y, T rannum)
template<class T , class D , class M >
T	t_opposite_hisran_step_ar (const M &mesh, const D &integ_y, T x)
template<class T , class D , class M >
long	t_entire_hisran_step_ar (const M &mesh, const D &integ_y, T rannum)
template<class T , class D , class M >
T	t_mean_step_ar (const M &mesh, const D &y, T x1, T x2, int &s_err)
template<class T >
T	t_value_straight_2point (T x1, T y1, T x2, T y2, T x, int s_ban_neg)
template<class T >
T	t_integ_straight_2point (T x1, T y1, T x2, T y2, T xl, T xr, int xpower, int s_ban_neg)
template<class T , class D , class M >
T	t_value_straight_point_ar (const M &mesh, const D &y, T x, int s_ban_neg, int s_extrap_left, T left_bond, int s_extrap_right, T right_bond)
template<class T , class D , class M >
T	t_value_generic_point_ar (const M &mesh, const D &y, T(*funval)(T xp1, T yp1, T xp2, T yp2, T xmin, T xmax, T x), T x, int s_extrap_left, T left_bond, int s_extrap_right, T right_bond)
template<class T >
T	t_value_power_2point (T x1, T y1, T x2, T y2, T x)
template<class T >
T	t_value_power_extended_2point (T x1, T y1, T x2, T y2, T x)
template<class T >
T	t_value_exp_2point (T x1, T y1, T x2, T y2, T x)
template<class T >
T	t_integ_power_2point (T x1, T y1, T x2, T y2, T xl, T xr)
template<class T , class D , class M >
T	t_integ_straight_point_ar (const M &mesh, const D &y, T x1, T x2, int xpower, int s_ban_neg, int s_extrap_left, T left_bond, int s_extrap_right, T right_bond)
template<class T , class D , class M >
T	t_mean_straight_point_ar (const M &mesh, const D &y, T x1, T x2, int s_extrap_left, T left_bond, int s_extrap_right, T right_bond, int &s_err)
template<class T , class D , class M >
T	t_integ_generic_point_ar (const M &mesh, const D &y, T(*fun)(T xp1, T yp1, T xp2, T yp2, T xmin, T xmax, T x1, T x2), T x1, T x2, int s_extrap_left, T left_bond, int s_extrap_right, T right_bond)
template<class T , class D , class M >
T	t_width_at_hheight_step_ar (const M &mesh, const D &y)

Function Documentation

apeq_mant() [1/2]

template<class T >

int apeq_mant	(	const CopiedPointCoorMesh< T > &	f1,
		const CopiedPointCoorMesh< T > &	f2,
		T	prec
	)

Definition at line 1150 of file tline.h.

                                                        {
  if (f1.get_qi() != f2.get_qi() ||
      !apeq_mant(f1.get_xmin(), f2.get_xmin(), prec) ||
      !apeq_mant(f1.get_xmax(), f2.get_xmax(), prec))
    return 0;
  if (!apeq_mant(f1.get_mesh(), f2.get_mesh(), prec))
    return 0;
  else
    return 1;
}

apeq_mant() [2/2]

template<class T >

int apeq_mant	(	const EqualStepCoorMesh< T > &	f1,
		const EqualStepCoorMesh< T > &	f2,
		T	prec
	)

Definition at line 290 of file tline.h.

                      {
  if (f1.get_qi() != f2.get_qi() ||
      !apeq_mant(f1.get_xmin(), f2.get_xmin(), prec) ||
      !apeq_mant(f1.get_xmax(), f2.get_xmax(), prec)) {
    Iprintn(mcout, !apeq_mant(f1.get_xmin(), f2.get_xmin(), prec));
    Iprintn(mcout, !apeq_mant(f1.get_xmax(), f2.get_xmax(), prec));
    return 0;
  } else
    return 1;
}

Referenced by apeq_mant(), t_entire_hisran_step_ar(), t_hisran_step_ar(), and t_opposite_hisran_step_ar().

operator!=() [1/2]

template<class T >

int operator!=	(	const CopiedPointCoorMesh< T > &	f1,
		const CopiedPointCoorMesh< T > &	f2
	)

Definition at line 1163 of file tline.h.

                                                     {
  if (f1.get_qi() != f2.get_qi() || f1.get_xmin() != f2.get_xmin() ||
      f1.get_xmax() != f2.get_xmax())
    return 1;
  if (f1.get_mesh() != f2.get_mesh())
    return 1;
  else
    return 0;
}

operator!=() [2/2]

template<class T >

int operator!=	(	const EqualStepCoorMesh< T > &	f1,
		const EqualStepCoorMesh< T > &	f2
	)

Definition at line 303 of file tline.h.

                                                   {
  if (f1.get_qi() != f2.get_qi() || f1.get_xmin() != f2.get_xmin() ||
      f1.get_xmax() != f2.get_xmax())
    return 1;
  else
    return 0;
}

operator<<() [1/6]

template<class T >

std::ostream & operator<<	(	std::ostream &	file,
		AbsCoorMesh< T > &	f
	)

Definition at line 1273 of file tline.h.

                                                                {
  f.print(file);
  return file;
}

operator<<() [2/6]

template<class T >

std::ostream & operator<<	(	std::ostream &	file,
		const EqualStepCoorMesh< T > &	f
	)

Definition at line 257 of file tline.h.

                                                            {
  f.print(file);
  return file;
}

operator<<() [3/6]

template<class T , class D >

std::ostream & operator<<	(	std::ostream &	file,
		const PointCoorMesh< T, D > &	f
	)

Definition at line 739 of file tline.h.

                                                                           {
  f.print(file);
  return file;
}

operator<<() [4/6]

template<class T >

std::ostream & operator<<	(	std::ostream &	file,
		CopiedPointCoorMesh< T > &	f
	)

Definition at line 1121 of file tline.h.

                                                                        {
  f.print(file);
  return file;
}

operator<<() [5/6]

template<class T >

std::ostream & operator<<	(	std::ostream &	file,
		VirtCopiedPointCoorMesh< T > &	f
	)

Definition at line 1501 of file tline.h.

                                                            {
  f.print(file);
  return file;
}

operator<<() [6/6]

template<class T >

std::ostream & operator<<	(	std::ostream &	file,
		VirtEqualStepCoorMesh< T > &	f
	)

Definition at line 1368 of file tline.h.

                                                                          {
  f.print(file);
  return file;
}

operator==() [1/2]

template<class T >

int operator==	(	const CopiedPointCoorMesh< T > &	f1,
		const CopiedPointCoorMesh< T > &	f2
	)

Definition at line 1138 of file tline.h.

                                                     {
  if (f1.get_qi() != f2.get_qi() || f1.get_xmin() != f2.get_xmin() ||
      f1.get_xmax() != f2.get_xmax())
    return 0;
  if (f1.get_mesh() != f2.get_mesh())
    return 0;
  else
    return 1;
}

operator==() [2/2]

template<class T >

int operator==	(	const EqualStepCoorMesh< T > &	f1,
		const EqualStepCoorMesh< T > &	f2
	)

Definition at line 280 of file tline.h.

                                                   {
  if (f1.get_qi() != f2.get_qi() || f1.get_xmin() != f2.get_xmin() ||
      f1.get_xmax() != f2.get_xmax())
    return 0;
  else
    return 1;
}

operator>>() [1/4]

template<class T >

std::istream & operator>>	(	std::istream &	file,
		CopiedPointCoorMesh< T > &	f
	)

Definition at line 1127 of file tline.h.

                                                                        {
  mfunname("istream& operator>>(istream& file, CopiedPointCoorMesh<T>& f)");
  definp_endpar dep(&file, 0, 1, 0);
  set_position("Type of T is (in internal notations)", *dep.istrm, dep.s_rewind,
               dep.s_req_sep);
  DynLinArr<T> mesh;
  f = CopiedPointCoorMesh<T>(mesh);
  return file;
}

operator>>() [2/4]

template<class T >

std::istream & operator>>	(	std::istream &	file,
		EqualStepCoorMesh< T > &	f
	)

Definition at line 264 of file tline.h.

                                                                      {
  mfunname("istream& operator>>(istream& file, EqualStepCoorMesh<T>& f)");
  definp_endpar dep(&file, 0, 1, 0);
  set_position("Type of T is (in internal notations)", *dep.istrm, dep.s_rewind,
               dep.s_req_sep);
  long q;
  T xmin;
  T xmax;
  DEFINPAP(q);
  DEFINPAP(xmin);
  DEFINPAP(xmax);
  f = EqualStepCoorMesh<T>(q, xmin, xmax);
  return file;
}

operator>>() [3/4]

template<class T >

std::istream & operator>>	(	std::istream &	file,
		VirtCopiedPointCoorMesh< T > &	f
	)

Definition at line 1508 of file tline.h.

                                                            {
  mfunname("istream& operator>>(istream& file, VirtCopiedPointCoorMesh<T>& f)");
  definp_endpar dep(&file, 0, 1, 0);
  set_position("CopiedPointCoorMesh<T>:", *dep.istrm, dep.s_rewind,
               dep.s_req_sep);
  // file>>f;  // this would lead to loop
  //file>>(static_cast< CopiedPointCoorMesh<T> >(f));
  CopiedPointCoorMesh<T>& ft = f;
  file >> ft;
  return file;
}

operator>>() [4/4]

template<class T >

std::istream & operator>>	(	std::istream &	file,
		VirtEqualStepCoorMesh< T > &	f
	)

Definition at line 1374 of file tline.h.

                                                                          {
  mfunname("istream& operator>>(istream& file, VirtEqualStepCoorMesh<T>& f)");
  definp_endpar dep(&file, 0, 1, 0);
  set_position("EqualStepCoorMesh<T>:", *dep.istrm, dep.s_rewind,
               dep.s_req_sep);
  //file>>f;
  //file>>(static_cast< EqualStepCoorMesh<T> >(f));
  EqualStepCoorMesh<T>& ft = f;
  file >> ft;
 
  return file;
}

read_AbsCoorMesh()

template<class T >

ActivePtr< AbsCoorMesh< T > > read_AbsCoorMesh

(

std::istream &

file

)

Definition at line 1604 of file tline.h.

                                                              {
  mfunnamep("ActivePtr< AbsCoorMesh<T> > read_AbsCoorMesh(istream& file)");
  const long q = 28;
  long n;
  char keyline[q];
  for (n = 0; n < q - 1; n++) {
    //file.get(keyline[n]);
    keyline[n] = file.get();
  }
  keyline[n] = '\0';
  if (!strcmp(&(keyline[0]), "AbsCoorMesh: no content.")) {
    funnw.ehdr(mcerr);
    mcout << "attempt to read AbsCoorMesh\n";
    spexit(mcerr);
  }
  if (!strcmp(&(keyline[0]), "VirtEqualStepCoorMesh<T>:  ")) {
    VirtEqualStepCoorMesh<T>* amesh = new VirtEqualStepCoorMesh<T>;
    file >> (*amesh);
    return ActivePtr<AbsCoorMesh<T> >(amesh, dont_clone);
  }
  if (!strcmp(&(keyline[0]), "VirtCopiedPointCoorMesh<T>:")) {
    VirtCopiedPointCoorMesh<T>* amesh = new VirtCopiedPointCoorMesh<T>;
    file >> (*amesh);
    return ActivePtr<AbsCoorMesh<T> >(amesh, dont_clone);
  }
  funnw.ehdr(mcerr);
  mcout << "cannot identifiy the type of derived AbsCoorMesh\n";
  Iprintn(mcout, keyline);
  spexit(mcerr);
#ifdef INS_CRETURN
  return ActivePtr<AbsCoorMesh<T> >();
#endif
}

t_entire_hisran_step_ar()

template<class T , class D , class M >

long t_entire_hisran_step_ar	(	const M &	mesh,
		const D &	integ_y,
		T	rannum
	)

Definition at line 2394 of file tline.h.

                                                                        {
  mfunname("double t_entire_hisran_step_ar(...)");
 
  //mcout<<"start t_step_integ_ar\n";
  //check_econd11(xpower , != 0 , mcerr);
  long qi = mesh.get_qi();
  long s_same = apeq_mant(integ_y[qi - 1], 1.0, 1.0e-12);
  check_econd11a(s_same, != 1.0, "integ_y[qi-1]=" << integ_y[qi - 1] << '\n',
                 mcerr);
  //check_econd11(integ_y[qi-1] , != 1.0 , mcerr);
  int s_err;
 
  long ret =
      t_find_entire_x_for_already_integ_step_ar(mesh,     // dimension q
                                                integ_y,  // dimension q-1
                                                rannum, &s_err);
  check_econd11a(s_err, != 0, "mesh=" << mesh << " integ_y=" << integ_y
                                      << " rannum=" << rannum << '\n',
                 mcerr);
  return ret;
  //return  t_find_entire_x_for_already_integ_step_ar
  //   (mesh,               // dimension q
  //   integ_y,                  // dimension q-1
  //   rannum,
  //   &s_err);
}

t_find_entire_x_for_already_integ_step_ar()

template<class T , class D , class M >

long t_find_entire_x_for_already_integ_step_ar	(	const M &	mesh,
		const D &	y,
		T	integ,
		int *	s_err
	)

Definition at line 2241 of file tline.h.

    {
  mfunname("double t_find_entire_x_for_already_integ_step_ar(...)");
  //Iprintn(mcout, mesh);
  //Iprintn(mcout, integ);
  *s_err = 0;
  //mcout<<"start t_step_integ_ar\n";
  //check_econd11(xpower , != 0 , mcerr);
  check_econd11(integ, < 0.0, mcerr);
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
  //if(x1 > x2) return 0.0;
  long xmin = mesh.get_xmin();
  long xmax = mesh.get_xmax();
  if (integ == 0) return xmin;
  if (integ > y[qi - 1]) {
    *s_err = 1;
    return xmax;
  }
  if (integ == y[qi - 1]) return xmax;
  if (integ < y[0]) {  // answer in the first bin
    long xp1(0);
    mesh.get_scoor(0, xp1);
    return xp1;
  }
  // binary search
  long nl = 0;
  long nr = qi - 1;
  long nc;
  while (nr - nl > 1) {
    nc = (nr + nl) / 2;
    if (integ < y[nc])
      nr = nc;
    else
      nl = nc;
  }
  //Iprint2n(mcout, nl, nr);
  //Iprint2n(mcout, y[nl], y[nr]);
  //Iprint2n(mcout, nl, nr);
  long x(0);
  mesh.get_scoor(nr, x);
  //Iprintn(mcout, x);
 
  return x;
}

Referenced by t_entire_hisran_step_ar().

t_find_interval()

template<class T , class D >

long t_find_interval	(	double	x,
		long	q,
		const D &	coor
	)

Definition at line 314 of file tline.h.

                                                          {
  long n1, n2, n3;
#ifndef TLINE_REDUCE_TO_RAW_ARR
  if (q <= 1) return -1;
  if (x < coor[0] || x > coor[q - 1]) return -1;
  if (x < coor[1]) return 0;
  if (x >= coor[q - 2]) return q - 2;
  n1 = 0;
  n2 = q - 1;
  while (n2 - n1 > 1) {
    n3 = n1 + (n2 - n1) / 2;
    if (x < coor[n3])
      n2 = n3;
    else
      n1 = n3;
  }
  return n1;
#else
  T* arr = &(coor[0]);  // take the address of the first element
  if (q <= 1) return -1;
  if (x < arr[0] || x > arr[q - 1]) return -1;
  if (x < arr[1]) return 0;
  if (x >= arr[q - 2]) return q - 2;
  n1 = 0;
  n2 = q - 1;
  while (n2 - n1 > 1) {
    n3 = n1 + (n2 - n1) / 2;
    if (x < arr[n3])
      n2 = n3;
    else
      n1 = n3;
  }
  return n1;
 
#endif
}

t_find_interval_end()

template<class T , class D >

long t_find_interval_end	(	double	x,
		long	q,
		const D &	coor,
		long	n_start
	)

Definition at line 358 of file tline.h.

                                                                        {
  long n1, n2, n3;
  if (n_start < 0 || n_start > q - 1) {
    mcerr << " ERROR in t_find_interval_end(...):\n";
    mcerr << "n_start < 0 || n_start > q-1\n";
    Iprint2n(mcout, n_start, q);
    spexit(mcerr);
  }
#ifndef TLINE_REDUCE_TO_RAW_ARR
  //if(q <= 1) return -1;
  if (q - n_start <= 1) return -1;
  if (x < coor[n_start] || x > coor[q - 1]) return -1;
  if (x < coor[n_start + 1]) return n_start;
  if (x >= coor[q - 2]) return q - 2;
  n1 = n_start;
  n2 = q - 1;
  while (n2 - n1 > 1) {
    n3 = n1 + (n2 - n1) / 2;
    if (x < coor[n3])
      n2 = n3;
    else
      n1 = n3;
  }
  return n1;
#else
  T* arr = &(coor[0]);  // take the address of the first element
                        //if(q <= 1) return -1;
  if (q - n_start <= 1) return -1;
  if (x < arr[n_start] || x > arr[q - 1]) return -1;
  if (x < arr[n_start + 1]) return n_start;
  if (x >= arr[q - 2]) return q - 2;
  n1 = n_start;
  n2 = q - 1;
  while (n2 - n1 > 1) {
    n3 = n1 + (n2 - n1) / 2;
    if (x < arr[n3])
      n2 = n3;
    else
      n1 = n3;
  }
  return n1;
 
#endif
}

t_find_x_for_already_integ_step_ar()

template<class T , class D , class M >

T t_find_x_for_already_integ_step_ar	(	const M &	mesh,
		const D &	y,
		T	integ,
		int *	s_err
	)

Definition at line 2176 of file tline.h.

    {
  mfunname("double t_find_x_for_already_integ_step_ar(...)");
 
  *s_err = 0;
  //mcout<<"start t_step_integ_ar\n";
  //check_econd11(xpower , != 0 , mcerr);
  check_econd11(integ, < 0.0, mcerr);
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
  //if(x1 > x2) return 0.0;
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  if (integ == 0.0) return xmin;
  if (integ > y[qi - 1]) {
    *s_err = 1;
    return xmax;
  }
  if (integ == y[qi - 1]) return xmax;
  if (integ < y[0]) {  // answer in the first bin
    T xp1(0.0);
    T xp2(0.0);
    mesh.get_scoor(0, xp1);
    mesh.get_scoor(1, xp2);
    return xp1 + (xp2 - xp1) * integ / y[0];
  }
  // binary search
  long nl = 0;
  long nr = qi - 1;
  long nc;
  while (nr - nl > 1) {
    nc = (nr + nl) / 2;
    if (integ < y[nc])
      nr = nc;
    else
      nl = nc;
  }
  //Iprint2n(mcout, nl, nr);
  T xl(0.0);
  T xr(0.0);
  mesh.get_scoor(nl + 1, xl);
  mesh.get_scoor(nr + 1, xr);
  // Note "+1" in the previous two expressions.
  // This arises from the fact that the nl'th element of
  // y-array contains integral of nl'th bin plus all previous bins.
  // So y[nl] is related to x of nl+1.
  T a = (xr - xl) / (y[nr] - y[nl]);
  T ret = xl + a * (integ - y[nl]);
 
  return ret;
}

Referenced by t_hisran_step_ar().

t_find_x_for_integ_step_ar()

template<class T , class D , class M >

T t_find_x_for_integ_step_ar	(	const M &	mesh,
		const D &	y,
		T	integ,
		int *	s_err
	)

Definition at line 2127 of file tline.h.

    {
  mfunname("double t_integ_step_ar(...)");
 
  *s_err = 0;
  //mcout<<"start t_step_integ_ar\n";
  //check_econd11(xpower , != 0 , mcerr);
  check_econd11(integ, < 0.0, mcerr);
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
  //if(x1 > x2) return 0.0;
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  if (integ == 0.0) return xmin;
  T s(0.0);
  long n = 0;
  T xp1(0.0);
  T xp2(0.0);
  mesh.get_scoor(n, xp2);
  for (n = 0; n < qi; n++) {
    xp1 = xp2;
    mesh.get_scoor(n + 1, xp2);
    T step = xp2 - xp1;
    T s1 = s + y[n] * step;
    //Iprint3n(mcout, n, s1, integ);
    if (s1 > integ) break;
    if (s1 == integ) return xp2;
    s = s1;
  }
 
  if (n == qi) {
    *s_err = 1;
    return xmax;
  }
  double x = xp1;
  //Iprint3n(mcout, n, s, x);
  x += (integ - s) / y[n];
  //Iprintn(mcout, x);
  return x;
}

t_hfill_step_ar()

template<class T , class D , class M >

void t_hfill_step_ar	(	const M &	mesh,
		const D &	y,
		T	x,
		T	val = 1,
		int	s_include_last_point = 0
	)

Definition at line 1714 of file tline.h.

    {
  mfunname("double t_hfill_step_ar(...)");
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  //Iprint3n(mcout, x, xmin, xmax);
  if (x < xmin) return;
  if (s_include_last_point == 0) {
    if (x >= xmax) return;
  } else {
    if (x > xmax) return;
  }
  long n1;
  int i_ret = 0;
  i_ret = mesh.get_interval(x, n1);
  check_econd11(i_ret, != 1, mcerr);
  y[n1] += val;
  return;
}

t_hfill_step_ar_ac() [1/2]

template<class T , class D , class M >

void t_hfill_step_ar_ac	(	const M &	mesh,
		const D &	y,
		T	x,
		T	val = 1,
		int	s_include_last_point = 0
	)

Definition at line 1740 of file tline.h.

    {
  mfunname("double t_hfill_step_ar(...)");
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  //Iprint3n(mcout, x, xmin, xmax);
  if (x < xmin) return;
  if (s_include_last_point == 0) {
    if (x >= xmax) return;
  } else {
    if (x > xmax) return;
  }
  long n1;
  int i_ret = 0;
  i_ret = mesh.get_interval(x, n1);
  check_econd11(i_ret, != 1, mcerr);
  y.ac(n1) += val;
  return;
}

t_hfill_step_ar_ac() [2/2]

template<class T , class D , class M1 , class M2 >

void t_hfill_step_ar_ac	(	const M1 &	mesh1,
		const M2 &	mesh2,
		const D &	y,
		T	x1,
		T	x2,
		T	val = 1,
		int	s_include_last_point = 0
	)

Definition at line 1764 of file tline.h.

    {
  mfunname("double t_hfill_step_ar(...)");
  double x1min = mesh1.get_xmin();
  double x1max = mesh1.get_xmax();
  double x2min = mesh2.get_xmin();
  double x2max = mesh2.get_xmax();
  //Iprint3n(mcout, x, xmin, xmax);
  if (x1 < x1min) return;
  if (s_include_last_point == 0) {
    if (x1 >= x1max) return;
  } else {
    if (x1 > x1max) return;
  }
  if (x2 < x2min) return;
  if (s_include_last_point == 0) {
    if (x2 >= x2max) return;
  } else {
    if (x2 > x2max) return;
  }
  long n1;
  int i_ret1 = 0;
  i_ret1 = mesh1.get_interval(x1, n1);
  check_econd11(i_ret1, != 1, mcerr);
  long n2;
  int i_ret2 = 0;
  i_ret2 = mesh2.get_interval(x2, n2);
  check_econd11(i_ret2, != 1, mcerr);
  y.ac(n1, n2) += val;
  return;
}

t_hispre_step_ar()

template<class T , class D , class M >

T t_hispre_step_ar	(	const M &	mesh,
		const D &	y,
		D &	integ_y
	)

Definition at line 2295 of file tline.h.

                     {
  mfunname("double t_hispre_step_ar(...)");
 
  //mcout<<"start t_step_integ_ar\n";
  //check_econd11(xpower , != 0 , mcerr);
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
 
  T s(0.0);
  long n = 0;
  T xp1(0.0);
  T xp2(0.0);
  mesh.get_scoor(n, xp2);
  for (n = 0; n < qi; n++) {
    xp1 = xp2;
    mesh.get_scoor(n + 1, xp2);
    T step = xp2 - xp1;
    check_econd11a(y[n], < 0.0,
                   "n=" << n << " xp1=" << xp1 << " xp2=" << xp2 << '\n',
                   mcerr);
    s = s + y[n] * step;
    integ_y[n] = s;
    //Iprint3n(mcout, n, s1, integ);
  }
  check_econd11a(s, <= 0.0, "y=" << y << " integ_y=" << integ_y << '\n', mcerr);
  for (n = 0; n < qi; n++) {
    integ_y[n] /= s;
  }
  return s;
}

t_hisran_step_ar()

template<class T , class D , class M >

T t_hisran_step_ar	(	const M &	mesh,
		const D &	integ_y,
		T	rannum
	)

Definition at line 2331 of file tline.h.

                                                              {
  mfunname("double t_hisran_step_ar(...)");
  //mcout<<"start t_step_integ_ar\n";
  //check_econd11(xpower , != 0 , mcerr);
  long qi = mesh.get_qi();
  long s_same = apeq_mant(integ_y[qi - 1], 1.0, 1.0e-12);
  check_econd11a(s_same, != 1.0, "integ_y[qi-1]=" << integ_y[qi - 1] << '\n',
                 mcerr);
 
  //Iprintn(mcout, rannum);
  //check_econd11(integ_y[qi-1] , != 1.0 , mcerr);
  int s_err;
 
  T ret = t_find_x_for_already_integ_step_ar(mesh,     // dimension q
                                             integ_y,  // dimension q-1
                                             rannum, &s_err);
  check_econd11a(s_err, != 0, "mesh=" << mesh << " integ_y=" << integ_y
                                      << " rannum=" << rannum << '\n',
                 mcerr);
  return ret;
  //return  t_find_x_for_already_integ_step_ar
  // (mesh,               // dimension q
  //  integ_y,                  // dimension q-1
  //  rannum,
  //  &s_err);
}

t_integ_generic_point_ar()

template<class T , class D , class M >

T t_integ_generic_point_ar	(	const M &	mesh,
		const D &	y,
		T(*)(T xp1, T yp1, T xp2, T yp2, T xmin, T xmax, T x1, T x2)	fun,
		T	x1,
		T	x2,
		int	s_extrap_left,
		T	left_bond,
		int	s_extrap_right,
		T	right_bond
	)

Definition at line 2786 of file tline.h.

                                                                            {
  mfunname("double t_integ_generic_point_ar(...)");
 
  //mcout<<"Strart t_integ_straight_point_ar\n";
  //check_econd21(xpower , != 0 &&  , != 1 , mcerr);
  check_econd12(x1, >, x2, mcerr);
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
  //if(x1 > x2) return 0.0;
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  if (x2 <= xmin && s_extrap_left == 0) return 0.0;
  if (x1 >= xmax && s_extrap_right == 0) return 0.0;
  if (x2 <= left_bond) return 0.0;
  if (x1 >= right_bond) return 0.0;
  // long istart, iafterend; // indexes to sum total intervals
  if (x1 < left_bond) x1 = left_bond;
  if (x2 > right_bond) x2 = right_bond;
  if (x1 <= xmin && s_extrap_left == 0) x1 = xmin;
  if (x2 > xmax && s_extrap_left == 0) x2 = xmax;
  long np1, np2;
  T bp1, bp2;
  int i_ret = 0;
  // restore the interval in which x1 reside
  i_ret = mesh.get_interval_extrap(x1, np1, bp1, np2, bp2);
  // restore the x-coordinates of given points
  T xp1;
  mesh.get_scoor(np1, xp1);
  T xp2;
  mesh.get_scoor(np2, xp2);
  T res;
  T yp1 = y[np1];
  T yp2 = y[np2];
  if (i_ret == 2 || x2 <= xp2)  // then all in one interval
      {
    res = fun(xp1, yp1, xp2, yp2, xmin, xmax, x1, x2);
  } else {
    // integrate only till end of the current interval
    T x1i = x1;
    T x2i = xp2;
    res = fun(xp1, yp1, xp2, yp2, xmin, xmax, x1i, x2i);
    //x2i = x1;  // prepere for loop
    int s_stop = 0;
    do {
      np1 = np2;
      np2++;
      xp1 = xp2;
      mesh.get_scoor(np2, xp2);
      x1i = x2i;
      if (xp2 >= x2) {
        x2i = x2;  // till end of integral
        s_stop = 1;
      } else {
        if (np2 == qi)  // end of the mesh, but x2 is farther
            {
          x2i = x2;  // till end of integral
          s_stop = 1;
        } else {
          x2i = xp2;  // till end of current interval
          s_stop = 0;
        }
      }
      yp1 = yp2;
      yp2 = y[np2];
      res += fun(xp1, yp1, xp2, yp2, xmin, xmax, x1i, x2i);
      //Iprint2n(mcout, xp1, xp2);
      //Iprint2n(mcout, x1i, x2i);
      //Iprint2n(mcout, yp1, yp2);
      //Iprint2n(mcout, res, s_stop);
 
    } while (s_stop == 0);
  }
  return res;
}

Referenced by Heed::glin_integ_ar().

t_integ_generic_step_ar()

template<class T , class D , class M >

T t_integ_generic_step_ar	(	const M &	mesh,
		const D &	y,
		T(*)(long np, T xp1, T xp2, T yp, T xmin, T xmax, T x1, T x2)	fun,
		T	x1,
		T	x2
	)

Definition at line 1907 of file tline.h.

                                      {
  mfunname("double t_integ_step_ar(...)");
 
  //mcout<<"start t_step_integ_ar\n";
  check_econd12(x1, >, x2, mcerr);
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
  //if(x1 > x2) return 0;
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  if (x2 <= xmin) return 0;
  if (x1 >= xmax) return 0;
  if (x1 == x2) return 0;
  long istart, iafterend;  // indexes to sum total intervals
  T s(0);
  if (x1 <= xmin) {
    x1 = xmin;
    istart = 0;
  } else {
    long n1, n2;
    T b1, b2;
    int i_ret = 0;
    i_ret = mesh.get_interval(x1, n1, b1, n2, b2);
    //Iprint2n(mcout, x1, i_ret);
    //Iprint4n(mcout, n1, b1, n2, b2);
    check_econd11(i_ret, != 1, mcerr);
    if (b2 - x1 > 0)  // otherwise it could be only equal to 0
        {
      if (x2 <= b2)  // if x2 in the same interval
          {
        s = fun(n1, b1, b2, y[n1], xmin, xmax, x1, x2);
        return s;
      }
      s = fun(n1, b1, b2, y[n1], xmin, xmax, x1, x2);
    }
    istart = n2;
  }
  if (x2 >= xmax) {
    x2 = xmax;
    iafterend = qi;
  } else {
    long n1, n2;
    T b1, b2;
    int i_ret = 0;
    i_ret = mesh.get_interval(x2, n1, b1, n2, b2);
    //Iprint2n(mcout, x2, i_ret);
    //Iprint4n(mcout, n1, b1, n2, b2);
    check_econd11(i_ret, != 1, mcerr);
    if (x2 - b1 > 0) {
      s += fun(n1, b1, b2, y[n1], xmin, xmax, b1, x2);
    }
    iafterend = n1;
  }
  //Iprint2n(mcout, istart, iafterend);
  long i;
  double b;
  mesh.get_scoor(istart, b);
  for (i = istart; i < iafterend; i++) {
    double a = b;
    mesh.get_scoor(i + 1, b);
    s += fun(i, a, b, y[i], xmin, xmax, a, b);
  }
  //Iprintn(mcout, s);
 
  //T t;
  return s;
 
}

t_integ_power_2point()

template<class T >

T t_integ_power_2point	(	T	x1,
		T	y1,
		T	x2,
		T	y2,
		T	xl,
		T	xr
	)

Definition at line 2661 of file tline.h.

    {
  mfunname("double t_integ_power_2point(...)");
 
  check_econd11(y1, <= 0.0, mcerr);
  check_econd11(y2, <= 0.0, mcerr);
  check_econd12(y1, ==, y2, mcerr);
  check_econd12(x1, ==, x2, mcerr);
  T pw = log(y1 / y2) / log(x1 / x2);
  check_econd11(pw, == -1.0, mcerr);
  T k = y1 * pow(x1, -pw);
  T t = k / (1 + pw) * (pow(xr, (pw + 1)) - pow(xl, (pw + 1)));
  return t;
}

t_integ_step_ar()

template<class T , class D , class M >

T t_integ_step_ar	(	const M &	mesh,
		const D &	y,
		T	x1,
		T	x2,
		int	xpower
	)

Definition at line 1810 of file tline.h.

    {
  mfunname("double t_integ_step_ar(...)");
 
  // mcout<<"start t_step_integ_ar\n";
  check_econd21(xpower, != 0 &&, != 1, mcerr);
  check_econd12(x1, >, x2, mcerr);
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
  //if(x1 > x2) return 0;
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  if (x2 <= xmin) return 0;
  if (x1 >= xmax) return 0;
  if (x1 == x2) return 0;
  long istart, iafterend;  // indexes to sum total intervals
  T s(0);
  if (x1 <= xmin) {
    x1 = xmin;
    istart = 0;
  } else {
    long n1, n2;
    T b1, b2;
    int i_ret = 0;
    i_ret = mesh.get_interval(x1, n1, b1, n2, b2);
    //Iprint2n(mcout, x1, i_ret);
    //Iprint4n(mcout, n1, b1, n2, b2);
    check_econd11(i_ret, != 1, mcerr);
    if (b2 - x1 > 0) {  // otherwise it could be only equal to 0
      if (x2 <= b2) {   // if x2 in the same interval
        if (xpower == 0) {
          s = (x2 - x1) * y[n1];
        } else {
          s = 0.5 * (x2 * x2 - x1 * x1) * y[n1];
        }
        return s;
      }
      if (xpower == 0) {
        s += (b2 - x1) * y[n1];
      } else {
        s += 0.5 * (b2 * b2 - x1 * x1) * y[n1];
      }
    }
    istart = n2;
  }
  if (x2 >= xmax) {
    x2 = xmax;
    iafterend = qi;
  } else {
    long n1, n2;
    T b1, b2;
    int i_ret = 0;
    i_ret = mesh.get_interval(x2, n1, b1, n2, b2);
    //Iprint2n(mcout, x2, i_ret);
    //Iprint4n(mcout, n1, b1, n2, b2);
    check_econd11(i_ret, != 1, mcerr);
    if (x2 - b1 > 0) {
      if (xpower == 0) {
        s += (x2 - b1) * y[n1];
      } else {
        s += 0.5 * (x2 * x2 - b1 * b1) * y[n1];
      }
    }
    iafterend = n1;
  }
  //Iprint2n(mcout, istart, iafterend);
  long i;
  double b;
  mesh.get_scoor(istart, b);
  if (xpower == 0) {
    for (i = istart; i < iafterend; i++) {
      double a = b;
      mesh.get_scoor(i + 1, b);
      s += (b - a) * y[i];
    }
  } else {
    for (i = istart; i < iafterend; i++) {
      double a = b;
      mesh.get_scoor(i + 1, b);
      s += 0.5 * (b * b - a * a) * y[i];
    }
  }
  //Iprintn(mcout, s);
 
  //T t;
  return s;
 
}

Referenced by Heed::EnTransfCS::EnTransfCS(), and t_mean_step_ar().

t_integ_straight_2point()

template<class T >

T t_integ_straight_2point	(	T	x1,
		T	y1,
		T	x2,
		T	y2,
		T	xl,
		T	xr,
		int	xpower,
		int	s_ban_neg
	)

Definition at line 2473 of file tline.h.

    {
  mfunname("double t_integ_straight_2point(...)");
  check_econd12(x1, ==, x2, mcerr);
 
  T a = (y2 - y1) / (x2 - x1);
  T b = y1;
  T yl = a * (xl - x1) + b;
  T yr = a * (xr - x1) + b;
  if (s_ban_neg == 1) {
    if (yl <= 0.0 && yr <= 0.0) return 0.0;
    if (yl < 0.0 || yr < 0.0) {
      T xz = x1 - b / a;
      if (yl < 0.0) {
        xl = xz;
        yl = 0.0;
      } else {
        xr = xz;
        yr = 0.0;
      }
    }
  }
  T res;
  if (xpower == 0)
    res = 0.5 * a * (xr * xr - xl * xl) + (b - a * x1) * (xr - xl);
  else
    res = a * (xr * xr * xr - xl * xl * xl) / 3.0 +
          0.5 * (b - a * x1) * (xr * xr - xl * xl);
 
  return res;
}

t_integ_straight_point_ar()

template<class T , class D , class M >

T t_integ_straight_point_ar	(	const M &	mesh,
		const D &	y,
		T	x1,
		T	x2,
		int	xpower,
		int	s_ban_neg,
		int	s_extrap_left,
		T	left_bond,
		int	s_extrap_right,
		T	right_bond
	)

Definition at line 2678 of file tline.h.

                                                              {
  mfunname("double t_integ_straight_point_ar(...)");
 
  //mcout<<"Strart t_integ_straight_point_ar\n";
  check_econd21(xpower, != 0 &&, != 1, mcerr);
  check_econd12(x1, >, x2, mcerr);
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
  //if(x1 > x2) return 0.0;
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  if (x2 <= xmin && s_extrap_left == 0) return 0.0;
  if (x1 >= xmax && s_extrap_right == 0) return 0.0;
  if (x2 <= left_bond) return 0.0;
  if (x1 >= right_bond) return 0.0;
  T s(0.0);
  if (x1 < left_bond) x1 = left_bond;
  if (x2 > right_bond) x2 = right_bond;
  if (x1 <= xmin && s_extrap_left == 0) x1 = xmin;
  if (x2 > xmax && s_extrap_left == 0) x2 = xmax;
  long np1, np2;
  T bp1, bp2;
  int i_ret = 0;
  // restore the interval in which x1 reside
  i_ret = mesh.get_interval_extrap(x1, np1, bp1, np2, bp2);
  // restore the x-coordinates of given points
  T xp1;
  mesh.get_scoor(np1, xp1);
  T xp2;
  mesh.get_scoor(np2, xp2);
  T res;
  T yp1 = y[np1];
  T yp2 = y[np2];
  if (i_ret == 2 || x2 <= xp2)  // then all in one interval
      {
    res = t_integ_straight_2point<T>(xp1, yp1, xp2, yp2, x1, x2, xpower,
                                     s_ban_neg);
  } else {
    // integrate only till end of the current interval
    T x1i = x1;
    T x2i = xp2;
    res = t_integ_straight_2point<T>(xp1, yp1, xp2, yp2, x1i, x2i, xpower,
                                     s_ban_neg);
    //x2i = x1;  // prepere for loop
    int s_stop = 0;
    do {
      np1 = np2;
      np2++;
      xp1 = xp2;
      mesh.get_scoor(np2, xp2);
      x1i = x2i;
      if (xp2 >= x2) {
        x2i = x2;  // till end of integral
        s_stop = 1;
      } else {
        if (np2 == qi)  // end of the mesh, but x2 is farther
            {
          x2i = x2;  // till end of integral
          s_stop = 1;
        } else {
          x2i = xp2;  // till end of current interval
          s_stop = 0;
        }
      }
      yp1 = yp2;
      yp2 = y[np2];
      res += t_integ_straight_2point<T>(xp1, yp1, xp2, yp2, x1i, x2i, xpower,
                                        s_ban_neg);
      //Iprint2n(mcout, xp1, xp2);
      //Iprint2n(mcout, x1i, x2i);
      //Iprint2n(mcout, yp1, yp2);
      //Iprint2n(mcout, res, s_stop);
 
    } while (s_stop == 0);
  }
  return res;
}

Referenced by t_mean_straight_point_ar().

t_mean_step_ar()

template<class T , class D , class M >

T t_mean_step_ar	(	const M &	mesh,
		const D &	y,
		T	x1,
		T	x2,
		int &	s_err
	)

Definition at line 2425 of file tline.h.

                                         {
  mfunname("double t_mean_step_ar(...)");
  s_err = 0;
  T integ = t_integ_step_ar(mesh, y, x1, x2, 0);
  if (integ == 0) {
    s_err = 1;
    return 0.0;
  }
  T xinteg = t_integ_step_ar(mesh, y, x1, x2, 1);
  return xinteg / integ;
}

t_mean_straight_point_ar()

template<class T , class D , class M >

T t_mean_straight_point_ar	(	const M &	mesh,
		const D &	y,
		T	x1,
		T	x2,
		int	s_extrap_left,
		T	left_bond,
		int	s_extrap_right,
		T	right_bond,
		int &	s_err
	)

Definition at line 2762 of file tline.h.

                                                                         {
  mfunname("double t_mean_straight_point_ar(...)");
  s_err = 0;
  T integ = t_integ_straight_point_ar(mesh, y, x1, x2, 0, 1, s_extrap_left,
                                      left_bond, s_extrap_right, right_bond);
  if (integ == 0) {
    s_err = 1;
    return 0.0;
  }
  T xinteg = t_integ_straight_point_ar(mesh, y, x1, x2, 1, 1, s_extrap_left,
                                       left_bond, s_extrap_right, right_bond);
  return xinteg / integ;
}

t_opposite_hisran_step_ar()

template<class T , class D , class M >

T t_opposite_hisran_step_ar	(	const M &	mesh,
		const D &	integ_y,
		T	x
	)

Definition at line 2362 of file tline.h.

                                                                  {
  mfunname("double t_opposite_hisran_step_ar(...)");
 
  //mcout<<"start t_step_integ_ar\n";
  //check_econd11(xpower , != 0 , mcerr);
  long qi = mesh.get_qi();
  long s_same = apeq_mant(integ_y[qi - 1], 1.0, 1.0e-12);
  check_econd11a(s_same, != 1.0, "integ_y[qi-1]=" << integ_y[qi - 1] << '\n',
                 mcerr);
 
  long n1;
  T b1;
  long n2;
  T b2;
 
  mesh.get_interval_extrap(x, n1, b1, n2, b2);
  T y1;
  T y2;
  if (n1 == 0) {
    y1 = 0.0;
    y2 = integ_y[0];
  } else {
    y1 = integ_y[n1 - 1];
    y2 = integ_y[n2 - 1];
  }
  T res = y1 + ((y2 - y1) / (b2 - b1)) * (x - b1);
  return res;
}

t_total_integ_step_ar() [1/3]

template<class T , class D , class M >

T t_total_integ_step_ar	(	const M &	mesh,
		const D &	y
	)

Definition at line 1987 of file tline.h.

                          {
  mfunname("double t_total_integ_step_ar(...)");
 
  //mcout<<"start t_step_integ_ar\n";
  long qi = mesh.get_qi();
  check_econd12(qi, <, 1, mcerr);
  //if(x1 > x2) return 0;
  long istart, iafterend;  // indexes to sum total intervals
  T s(0);
  istart = 0;
  iafterend = qi;
  //Iprint2n(mcout, istart, iafterend);
  long i;
  double b;
  mesh.get_scoor(istart, b);
  for (i = istart; i < iafterend; i++) {
    double a = b;
    mesh.get_scoor(i + 1, b);
    s += (b - a) * y[i];
  }
 
  //T t;
  return s;
 
}

t_total_integ_step_ar() [2/3]

template<class T , class D , class M1 , class M2 >

T t_total_integ_step_ar	(	const M1 &	mesh1,
		const M2 &	mesh2,
		const D &	y
	)

Definition at line 2017 of file tline.h.

                          {
  mfunname("double t_total_integ_step_ar(...)");
 
  //mcout<<"start t_step_integ_ar\n";
  long qi1 = mesh1.get_qi();
  check_econd12(qi1, <, 1, mcerr);
  long qi2 = mesh2.get_qi();
  check_econd12(qi2, <, 1, mcerr);
  //if(x1 > x2) return 0;
  long istart1, iafterend1;  // indexes to sum total intervals
  T s1(0);
  istart1 = 0;
  iafterend1 = qi1;
  //Iprint2n(mcout, istart, iafterend);
  long i1;
  double b1;
  mesh1.get_scoor(istart1, b1);
  for (i1 = istart1; i1 < iafterend1; i1++) {
    double a1 = b1;
    mesh1.get_scoor(i1 + 1, b1);
    // time to obtain integral by the second dimension
    //if(x1 > x2) return 0;
    long istart2, iafterend2;  // indexes to sum total intervals
    T s2(0);
    istart2 = 0;
    iafterend2 = qi2;
    //Iprint2n(mcout, istart, iafterend);
    long i2;
    double b2;
    mesh2.get_scoor(istart2, b2);
    for (i2 = istart2; i2 < iafterend2; i2++) {
      double a2 = b2;
      mesh2.get_scoor(i2 + 1, b2);
      s2 += (b2 - a2) * y[i1][i2];
    }
    // OK, integral = s2
    s1 += (b1 - a1) * s2;
  }
 
  //T t;
  return s1;
 
}

t_total_integ_step_ar() [3/3]

template<class T , class M1 , class M2 >

T t_total_integ_step_ar	(	const M1 &	mesh1,
		const M2 &	mesh2,
		const DynArr< T > &	y
	)

Definition at line 2066 of file tline.h.

                          {
  mfunname("double t_total_integ_step_ar(...)");
 
  //mcout<<"start t_step_integ_ar\n";
  long qi1 = mesh1.get_qi();
  check_econd12(qi1, <, 1, mcerr);
  check_econd12(qi1, !=, y.get_qel()[0], mcerr);
  long qi2 = mesh2.get_qi();
  check_econd12(qi2, <, 1, mcerr);
  check_econd12(qi2, !=, y.get_qel()[1], mcerr);
  //if(x1 > x2) return 0;
  long istart1, iafterend1;  // indexes to sum total intervals
  T s1(0);
  istart1 = 0;
  iafterend1 = qi1;
  //Iprint2n(mcout, istart, iafterend);
  long i1;
  double b1;
  mesh1.get_scoor(istart1, b1);
  for (i1 = istart1; i1 < iafterend1; i1++) {
    double a1 = b1;
    mesh1.get_scoor(i1 + 1, b1);
 
    // time to obtain integral by the second dimension
 
    //if(x1 > x2) return 0.0;
    long istart2, iafterend2;  // indexes to sum total intervals
    T s2(0.0);
    istart2 = 0;
    iafterend2 = qi2;
    //Iprint2n(mcout, istart, iafterend);
    long i2;
    double b2;
    mesh2.get_scoor(istart2, b2);
    for (i2 = istart2; i2 < iafterend2; i2++) {
      double a2 = b2;
      mesh2.get_scoor(i2 + 1, b2);
      s2 += (b2 - a2) * y.acu(i1, i2);
    }
 
    // OK, integral = s2
 
    s1 += (b1 - a1) * s2;
  }
 
  //T t;
  return s1;
 
}

t_value_exp_2point()

template<class T >

T t_value_exp_2point	(	T	x1,
		T	y1,
		T	x2,
		T	y2,
		T	x
	)

Definition at line 2643 of file tline.h.

                                                                     {
  mfunname("double t_value_exp_2point(...)");
 
  check_econd11(y1, <= 0.0, mcerr);
  check_econd11(y2, <= 0.0, mcerr);
  check_econd12(y1, ==, y2, mcerr);
  check_econd12(x1, ==, x2, mcerr);
  T res;
 
  T a = log(y1 / y2) / (x1 - x2);
  T c = y1 / exp(a * x1);
  //check_econd11(pw , == -1.0 , mcerr);
  res = c * exp(a * x);
  ;
  return res;
}

t_value_generic_point_ar()

template<class T , class D , class M >

T t_value_generic_point_ar	(	const M &	mesh,
		const D &	y,
		T(*)(T xp1, T yp1, T xp2, T yp2, T xmin, T xmax, T x)	funval,
		T	x,
		int	s_extrap_left,
		T	left_bond,
		int	s_extrap_right,
		T	right_bond
	)

Definition at line 2572 of file tline.h.

                                                                           {
  // 0 - not include, 1 - include
  mfunname("double t_value_generic_point_ar(...)");
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  //Iprint3n(mcout, x, xmin, xmax);
  if (x < left_bond) return 0.0;
  if (x > right_bond) return 0.0;
  if (x < xmin && s_extrap_left == 0) return 0.0;
  if (x > xmax && s_extrap_right == 0) return 0.0;
  long n1, n2;
  T b1, b2;
  mesh.get_interval_extrap(x, n1, b1, n2, b2);
  T x1;
  mesh.get_scoor(n1, x1);
  T x2;
  mesh.get_scoor(n2, x2);
  return funval(x1, y[n1], x2, y[n2], left_bond, right_bond, x);
}

Referenced by Heed::SimpleTablePhotoAbsCS::get_CS().

t_value_power_2point()

template<class T >

T t_value_power_2point	(	T	x1,
		T	y1,
		T	x2,
		T	y2,
		T	x
	)

Definition at line 2603 of file tline.h.

                                                                       {
  mfunname("double t_value_power_2point(...)");
 
  check_econd11(y1, <= 0.0, mcerr);
  check_econd11(y2, <= 0.0, mcerr);
  check_econd12(y1, ==, y2, mcerr);
  check_econd12(x1, ==, x2, mcerr);
  T res = y1;
  if (x1 <= 0.0 && x2 >= 0.0) {
    mcerr << "T t_value_power_2point(...): \n";
    mcerr << "x's are of different sign, power cannot be drawn\n";
    spexit(mcerr);
  } else {
    T pw = log(y1 / y2) / log(x1 / x2);
    //check_econd11(pw , == -1.0 , mcerr);
    res = y1 * pow(x, pw) / pow(x1, pw);
  }
  return res;
}

t_value_power_extended_2point()

template<class T >

T t_value_power_extended_2point	(	T	x1,
		T	y1,
		T	x2,
		T	y2,
		T	x
	)

Definition at line 2625 of file tline.h.

                                                             {
  mfunname("double t_value_power_2point(...)");
 
  check_econd11(y1, <= 0.0, mcerr);
  check_econd11(y2, <= 0.0, mcerr);
  check_econd12(y1, ==, y2, mcerr);
  check_econd12(x1, ==, x2, mcerr);
  T res;
  if (x1 <= 0.0 && x2 >= 0.0) {
    res = y1 + (x - x1) * (y2 - y1) / (x2 - x1);
  } else {
    T pw = log(y1 / y2) / log(x1 / x2);
    //check_econd11(pw , == -1.0 , mcerr);
    res = y1 * pow(x, pw) / pow(x1, pw);
  }
  return res;
}

t_value_step_ar() [1/2]

template<class T , class D , class M >

T t_value_step_ar	(	const M &	mesh,
		const D &	y,
		T	x,
		int	s_include_last_point = 0
	)

Definition at line 1649 of file tline.h.

    {
  mfunname("double t_value_step_ar(...)");
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  //Iprint3n(mcout, x, xmin, xmax);
  if (x < xmin) return 0;
  if (s_include_last_point == 0) {
    if (x >= xmax) return 0;
  } else {
    if (x > xmax) return 0;
  }
  long n1, n2;
  T b1, b2;
  int i_ret = 0;
  i_ret = mesh.get_interval(x, n1, b1, n2, b2);
  check_econd11(i_ret, != 1, mcerr);
  return y[n1];
}

t_value_step_ar() [2/2]

template<class T , class D , class M1 , class M2 >

T t_value_step_ar	(	const M1 &	mesh1,
		const M2 &	mesh2,
		const D &	y,
		T	x1,
		T	x2,
		int	s_include_last_point = 0
	)

Definition at line 1673 of file tline.h.

    {
  mfunname("double t_value_step_ar(...)");
  double x1min = mesh1.get_xmin();
  double x1max = mesh1.get_xmax();
  //Iprint3n(mcout, x, xmin, xmax);
  if (x1 < x1min) return 0;
  if (s_include_last_point == 0) {
    if (x1 >= x1max) return 0;
  } else {
    if (x1 > x1max) return 0;
  }
  double x2min = mesh2.get_xmin();
  double x2max = mesh2.get_xmax();
  //Iprint3n(mcout, x, xmin, xmax);
  if (x2 < x2min) return 0;
  if (s_include_last_point == 0) {
    if (x2 >= x2max) return 0;
  } else {
    if (x2 > x2max) return 0;
  }
  long n11, n12;
  long n21, n22;
  T b1, b2;
  int i_ret = 0;
 
  i_ret = mesh1.get_interval(x1, n11, b1, n12, b2);
  check_econd11(i_ret, != 1, mcerr);
 
  i_ret = mesh2.get_interval(x2, n21, b1, n22, b2);
 
  check_econd11(i_ret, != 1, mcerr);
  return y[n11][n21];
}

t_value_straight_2point()

template<class T >

T t_value_straight_2point	(	T	x1,
		T	y1,
		T	x2,
		T	y2,
		T	x,
		int	s_ban_neg
	)

Definition at line 2439 of file tline.h.

                                                                      {
  mfunname("double t_value_straight_2point(...)");
  check_econd12(x1, ==, x2, mcerr);
 
  T a = (y2 - y1) / (x2 - x1);
  // Less numerical precision
  //T b = y[n1];
  //T res = a * ( x - x1) + b;
  // More numerical precision (although it is not proved),
  // starting from what is closer to x
  T res;
  T dx1 = x - x1;
  T adx1 = (dx1 > 0) ? dx1 : -dx1;  // absolute value
                                    //if(dx1 > 0)
                                    //  adx1 = dx1;
                                    //else
                                    //  adx1 = -dx1;
  T dx2 = x - x2;
  T adx2 = (dx2 > 0) ? dx2 : -dx2;  // absolute value
                                    //if(dx2 > 0)
                                    //  adx2 = dx2;
                                    //else
                                    //  adx2 = -dx2;
  if (adx1 < adx2)                  // x is closer to x1
      {
    res = a * dx1 + y1;
  } else {
    res = a * dx2 + y2;
  }
  if (s_ban_neg == 1 && res < 0.0) res = 0.0;
  return res;
}

Referenced by t_value_straight_point_ar(), and t_width_at_hheight_step_ar().

t_value_straight_point_ar()

template<class T , class D , class M >

T t_value_straight_point_ar	(	const M &	mesh,
		const D &	y,
		T	x,
		int	s_ban_neg,
		int	s_extrap_left,
		T	left_bond,
		int	s_extrap_right,
		T	right_bond
	)

Definition at line 2511 of file tline.h.

                                                              {
  // 0 - not include, 1 - include
  mfunname("double t_value_straight_point_ar(...)");
  double xmin = mesh.get_xmin();
  double xmax = mesh.get_xmax();
  //Iprint3n(mcout, x, xmin, xmax);
  if (x < left_bond) return 0.0;
  if (x > right_bond) return 0.0;
  if (x < xmin && s_extrap_left == 0) return 0.0;
  if (x > xmax && s_extrap_right == 0) return 0.0;
  long n1, n2;
  T b1, b2;
  mesh.get_interval_extrap(x, n1, b1, n2, b2);
  T x1;
  mesh.get_scoor(n1, x1);
  T x2;
  mesh.get_scoor(n2, x2);
  return t_value_straight_2point(x1, y[n1], x2, y[n2], x, s_ban_neg);
  /*
  T a = (y[n2] - y[n1])/(x2 - x1);
  // Less numerical precision
  //T b = y[n1];
  //T res = a * ( x - x1) + b;
  // More numerical precision (although it is not proved),
  // starting from what is closer to x
  T res;
  T dx1 = x - x1;
  T adx1 = (dx1 > 0) ? dx1 : -dx1;       // absolute value
  //if(dx1 > 0)
  //  adx1 = dx1;
  //else
  //  adx1 = -dx1;
  T dx2 = x - x2;
  T adx2 = (dx2 > 0) ? dx2 : -dx2;            // absolute value
  //if(dx2 > 0)
  //  adx2 = dx2;
  //else
  //  adx2 = -dx2;
  if(adx1 < adx2)  // x is closer to x1
  {
    res = a * dx1 + y[n1];
  }
  else
  {
    res = a * dx2 + y[n2];
  }
  //T res = a * ( x - x1) + b;
  if(s_ban_neg == 1 && res < 0.0) res = 0.0;
  //Iprint2n(mcout, x, res);
  //Iprint2n(mcout, x1, x2);
  //Iprint2n(mcout, y[n1], y[n2]);
  //Iprintn(mcout, a);
  return res;
  */
}

Referenced by Heed::HeedMatterDef::replace_epsi12().

t_width_at_hheight_step_ar()

template<class T , class D , class M >

T t_width_at_hheight_step_ar	(	const M &	mesh,
		const D &	y
	)

Definition at line 2874 of file tline.h.

                                                        {
  // 0 - not include, 1 - include
  mfunname("double t_width_at_hheight_step_ar(...)");
  //mcout<<"t_width_at_hheight_step_ar is started\n";
  long qi = mesh.get_qi();
  long n;
  T ymax = 0;
  long nmax;
  for (n = 0; n < qi; ++n) {
    if (y[n] > ymax) {
      check_econd11(y[n], < 0.0, mcerr);
      ymax = y[n];
      nmax = n;
    }
  }
  //Iprint2n(mcout, ymax, nmax);
  if (ymax == 0) return 0;
  T ylev = ymax / 2.0;
  T s2 = 0;
  long q = 0;
  for (n = nmax; n < qi; n++) {
 
    if (y[n] > ylev && y[n + 1] <= ylev) {
      T x1, x2;
      mesh.get_interval(n, x1, x2);
      T step1, step2;
      mesh.get_step(n, step1);
      mesh.get_step(n + 1, step2);
      step1 = step1 / 2.0;
      step2 = step2 / 2.0;
      s2 += t_value_straight_2point(y[n], x1 + step1, y[n + 1], x2 + step2,
                                    ylev, 0);
      //Iprint2n(mcout, x1, x2);
      //Iprint2n(mcout, x1+step1, x2+step2);
      //Iprint2n(mcout, y[n], y[n+1]);
      //Iprint2n(mcout, n, t_value_straight_2point(y[n], x1+step1, y[n+1],
      //x2+step2, ylev, 0));
      q++;
    }
  }
  check_econd11(q, <= 0, mcerr);
  s2 = s2 / q;
  T s1 = 0;
  q = 0;
  for (n = nmax; n >= 0; n--) {
    if (y[n] > ylev && y[n - 1] <= ylev) {
      T x1, x2;
      mesh.get_interval(n - 1, x1, x2);
      T step1, step2;
      mesh.get_step(n - 1, step1);
      mesh.get_step(n, step2);
      step1 = step1 / 2.0;
      step2 = step2 / 2.0;
      s1 += t_value_straight_2point(y[n - 1], x1 + step1, y[n], x2 + step2,
                                    ylev, 0);
      //Iprint2n(mcout, x1, x2);
      //Iprint2n(mcout, x1+step1, x2+step2);
      //Iprint2n(mcout, y[n-1], y[n]);
      //Iprint2n(mcout, n, t_value_straight_2point(y[n-1], x1+step1, y[n],
      //x2+step2, ylev, 0));
      q++;
    }
  }
  check_econd11(q, <= 0, mcerr);
  s1 = s1 / q;
  //Iprint3n(mcout, s1, s2, s2 - s1);
  return s2 - s1;
}

verify_types()

template<class T , class B >

int verify_types	(	const T *	ths,
		const B *	b2,
		const T **	tb2
	)

Definition at line 1179 of file tline.h.

                                                           {
  mfunnamep("template<class T> verify_types(const T* ths, const B* b2, const "
            "T* tb2)");
  //mcout<<"verify_types is working\n";
  //Iprintn(mcerr, typeid(T).name());
  //Iprintn(mcerr, typeid(B).name());
  if (typeid(*b2) != typeid(*ths)) return 0;
  if (typeid(*ths) != typeid(T)) {
    funnw.ehdr(cerr);
    mcerr << "Operator == for class T is called for first object of different "
             "class\n";
    mcerr << "This may mean that this operator is missed in one of derived "
             "classes\n";
    Iprintn(mcerr, typeid(*ths).name());
    spexit(mcerr);
  }
  *tb2 = dynamic_cast<const T*>(b2);
  check_econd11(*tb2, == NULL, mcerr);
  return 1;
}

Referenced by VirtEqualStepCoorMesh< T >::apeq_mant(), VirtCopiedPointCoorMesh< T >::apeq_mant(), VirtEqualStepCoorMesh< T >::operator==(), and VirtCopiedPointCoorMesh< T >::operator==().