c:/Users/efeyhl/devs/math2/basic_math.h

Go to the documentation of this file.

#ifndef __BASIC_MATH_H__
#define __BASIC_MATH_H__

#include "c_basic_math.h"


void printBMStatus( const BM_STATUS bms, FILE* file=(FILE*)0 )
{
  return printBM_STATUS( bms, file );
};


bool isValidValue( const double* value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return ( isDouble( value, bms ) != 0 );
};


bool isValidValue( const __int64* value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return ( isI64( value, bms ) != 0 );
};


double x_add_y(
  const double augend,
  const double addend,
  BM_STATUS* bms=NULL )
{
  return doubleAddDouble( augend, addend, bms );
};


__int64 x_add_y(
  const __int64 augend,
  const __int64 addend,
  BM_STATUS* bms=NULL )
{
  return i64AddI64( augend, addend, bms );
};


double x_sub_y(
  const double minuend,
  const double subtrahend,
  BM_STATUS* bms=NULL )
{
  return doubleSubDouble( minuend, subtrahend, bms );
};


__int64 x_sub_y(
  const __int64 minuend,
  const __int64 subtrahend,
  BM_STATUS* bms=NULL )
{
  return i64SubI64( minuend, subtrahend, bms );
};


double x_mul_y(
  const double multiplier,
  const double multiplicand,
  BM_STATUS* bms=NULL )
{
  return doubleMulDouble( multiplier, multiplicand, bms );
};


__int64 x_mul_y(
  const __int64 multiplier,
  const __int64 multiplicand,
  BM_STATUS* bms=NULL )
{
  return i64MulI64( multiplier, multiplicand, bms );
};


double x_div_y(
  const double numerator,
  const double denominator,
  BM_STATUS* bms=NULL )
{
  return doubleDivDouble( numerator, denominator, bms );
};


__int64 x_div_y(
  const __int64 numerator,
  const __int64 denominator,
  BM_STATUS* bms=NULL )
{
  return i64DivI64( numerator, denominator, bms );
};


double x_mod_y(
  const double numerator,
  const double denominator,
  BM_STATUS* bms=NULL )
{
  return doubleModDouble( numerator, denominator, bms );
};


__int64 x_mod_y(
  const __int64 numerator,
  const __int64 denominator,
  BM_STATUS* bms=NULL )
{
  return i64ModI64( numerator, denominator, bms );
};


double reciproc_x(
  const double value,
  BM_STATUS* bms=NULL )
{
  return reciprocDouble( value, bms );
};


double Ceil( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{ 
  return ceilDouble( value, bms );
};


double Floor( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{ 
  return floorDouble( value, bms );
};


__int64 toInt64( const double value, double* intDbl=(double*)0, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return doubleToInt64( value, intDbl, bms );
}


double toDouble( const __int64 value )
{
  return i64ToDouble( value );
}


double Round( const double value, const int decPlaces=0, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return roundDouble( value, decPlaces, bms );
}


int Compare( const double value1, const double value2, const double diff=NANO, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return doubleCompareDouble( value1, value2, diff, bms );
}


int Compare( const __int64 value1, const __int64 value2, const __int64 diff=0 )
{
  return i64CompareI64( value1, value2, diff );
}


int isEven( const __int64 value )
{
  return isEvenI64( value );
}


double Positive( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return positiveDouble( value, bms );
}


__int64 Positive( const __int64 value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return positiveI64( value, bms );
}


double Negative( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return negativeDouble( value, bms );
}


__int64 Negative( const __int64 value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return negativeI64( value );
}


double InvertSign( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return invertSignDouble( value, bms );
}


__int64 InvertSign( const __int64 value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return invertSignI64( value, bms );
}


double x_pow_2( const double base, BM_STATUS* bms=NULL )
{
  return doublePow_2( base, bms );
};


__int64 x_pow_2( const __int64 base, BM_STATUS* bms=NULL )
{
  return i64Pow_2( base, bms );
};


double x_pow_3( const double base, BM_STATUS* bms=NULL )
{
  return doublePow_3( base, bms );
};


__int64 x_pow_3( const __int64 base, BM_STATUS* bms=NULL )
{
  return i64Pow_3( base, bms );
};


double x_pow_4( const double base, BM_STATUS* bms=NULL )
{
  return doublePow_4( base, bms );
};


__int64 x_pow_4( const __int64 base, BM_STATUS* bms=NULL )
{
  return i64Pow_4( base, bms );
};


double x_pow_y(
  const double base,
  const double exponent, //exponent can also be negative
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  return doublePowDouble( base, exponent, bms );
};


__int64 x_pow_y(
  const __int64 base,
  const __int64 exponent, //exponent can also be negative
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  return i64PowI64( base, exponent, bms );
};


double x_root_2(
  const double radicand,
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  return doubleRoot_2( radicand, bms );
};


__int64 x_root_2( const __int64 radicand, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return i64Root_2(radicand, bms);
};


double x_root_3(
  const double radicand,
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  return doubleRoot_3( radicand, bms );
};


double x_root_4(
  const double radicand,
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  return doubleRoot_4( radicand, bms );
};


double x_root_y(
  const double radicand,
  const double rootExponent,
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  return doubleRootDouble( radicand, rootExponent, bms );
};


__int64 x_root_y(
  const __int64 radicand,
  const __int64 rootExponent,
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  return i64RootI64( radicand, rootExponent, bms );
};


double log_b_x( 
  const double base,
  const double value,
  BM_STATUS* bms=(BM_STATUS*)0 ) //status is optional
{
  return doubleLogDouble( base, value, bms );
}


__int64 log_b_x( 
  const __int64 base,
  const __int64 value,
  BM_STATUS* bms=(BM_STATUS*)0 ) //status is optional
{
  return i64LogI64( base, value, bms );
}


void sortAscendant(
  double* values,
  const unsigned long count,
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  sortAscendantDouble( values, count, bms );
};


void sortAscendant(
  __int64* values,
  const unsigned long count,
  BM_STATUS* bms=(BM_STATUS*)0 )
{
  sortAscendantI64( values, count );
};


long solveP1norm(
  double* xr,
  const double* pf )
{
  return doubleSolveP1norm( xr, pf );
};


long solveP1(
  double* xr,
  const double* pf )
{
  return doubleSolveP1( xr, pf );
};


long solveP2norm(
  double* xr,
  const double* pf )
{
  return doubleSolveP2norm( xr, pf );
};


long solveP2(
  double* xr,
  const double* pf )
{
  return doubleSolveP2( xr, pf );
};


long solveP3norm(
  double* xr,
  const double* pf )
{
  return doubleSolveP3norm( xr, pf );
};


long solveP3(
  double* xr,
  const double* pf )
{
  return doubleSolveP3( xr, pf );
};


long solveP4norm(
  double* xr,
  const double* pf )
{
  return doubleSolveP4norm( xr, pf );
};


long solveP4(
  double* xr,
  const double* pf )
{
  return doubleSolveP4( xr, pf );
};


long getPolyFactors1(
  double* pf,
  const double* xz)
{
  return doubleGetPolyFactors1( pf, xz );
}


BM_STATUS getPolyFactors2(
  double* pf,
  const double* xz)
{
  return doubleGetPolyFactors2( pf, xz );
};


BM_STATUS getPolyFactors3(
  double* pf,
  const double* xz)
{
  return doubleGetPolyFactors3( pf, xz );
};


BM_STATUS getPolyFactors4(
  double* pf,
  const double* xz)
{
  return doubleGetPolyFactors4( pf, xz );
};


double deg2Rad( const double degree, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return deg2RadDouble( degree, bms );
};


double rad2Deg( const double radian, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return rad2DegDouble( radian, bms );
};


double stringToDbl( const char* stringValue, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return stringToDouble( stringValue, bms );
};


__int64 stringToInt64( const char* stringValue, char** stopChar=(char**)0, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return stringToI64( stringValue, stopChar, bms );
};


double strToDbl(
  const char* str,
  BM_STATUS* bms=NULL)
{
  return strToDouble( str, bms );
};


BM_STATUS solveL1(
  double* xr,
  const double* lf )
{
  return doubleSolveL1( xr, lf );
};


BM_STATUS solveL2(
  double* xr,
  double* lf[2] )
{
  return doubleSolveL2( xr, lf );
};


void printBitpattern( double value, FILE* file=(FILE*)0 )
{
  return printDoubleBitpattern( value, file );
};


void printBitpatternFormatted( double value, FILE* file=(FILE*)0 )
{
  return printDoubleBitpatternFormatted( value, file );
};


double sinus( const double rad, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return sinDouble( rad, bms );
}


double arcSin( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return asinDouble( value, bms );
}


double cosinus( const double rad, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return cosDouble( rad, bms );
}


double arcCos( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return acosDouble( value, bms );
}


double tangent( const double rad, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return tanDouble( rad, bms );
}


double arcTan( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return atanDouble( value, bms );
}


double cotangent( const double rad, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return cotDouble( rad, bms );
}


double arcCot( const double value, BM_STATUS* bms=(BM_STATUS*)0 )
{
  return acotDouble( value, bms );
}


int Find( const double* element1, const unsigned int maxElements, const double elem )
{
  return findDouble( element1, maxElements, elem );
}



int Find( const __int64* element1, const unsigned int maxElements, const __int64 elem )
{
  return findI64( element1, maxElements, elem );
}

#endif //__BASIC_MATH_H__

---