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

Go to the documentation of this file.

#ifndef __FPV_H__
#define __FPV_H__

#include "number.h"


class fpv : public number<double>
{
public: //implementation of pure virtual methods of number


  virtual double stringToValue( const char* stringValue )
  {
    return stringToDbl( stringValue, &bms );
  };

public: //methods


  fpv(const double val)
  {
    assignCopy( val );
  };


  fpv(const fpv& val)
  {
    assignCopy( val );
  };


  void printBitpattern( FILE* file=(FILE*)0 ) const
  {
    ::printBitpattern( value, file );
  };


  void printBitpatternFormatted( FILE* file=0 ) const
  {
    ::printBitpatternFormatted( value, file );
  };

// basic operations


  fpv operator + (const double addend) const
  {
    fpv res(*this);
    res.assignAdd( addend );
    return res;
  };


  fpv operator + (const fpv& addend) const
  {
    fpv res(*this);
    res.assignAdd( addend );
    return res;
  };


  inline fpv operator - (const double& subtrahend) const
  {
    fpv res(*this);
    res.assignSub( subtrahend );
    return res;
  };


  inline fpv operator - (const fpv& subtrahend) const
  {
    fpv res(*this);
    res.bms.status |= subtrahend.bms.status;
    res.assignSub( subtrahend.value );
    return res;
  };


  inline fpv operator * (const double multiplicand) const
  {
    fpv res(*this);
    res.assignMul( multiplicand );
    return res;
  };


  inline fpv operator * (const fpv& multiplicand) const
  {
    fpv res(*this);
    res.bms.status |= multiplicand.bms.status;
    res.assignMul( multiplicand.value );
    return res;
  };


  inline fpv operator / (const double denominator) const
  {
    fpv res(*this);
    res.assignDiv( denominator );
    return res;
  };


  inline fpv operator / (const fpv& denominator) const
  {
    fpv res(*this);
    res.assignDiv( denominator );
    return res;
  };


  inline fpv operator % (const double denominator) const
  {
    fpv remainder(*this);
    remainder.assignMod( denominator );
    return remainder;
  }


  inline fpv operator % (const fpv& denominator) const
  {
    fpv remainder(*this);
    remainder.assignMod( denominator );
    return remainder;
  }
  

  inline fpv& assignReciproc()
  {
    value = reciproc_x( value, &bms );
    return *this;
  };


  inline fpv reciproc() const
  {
    fpv recVal( *this );
    recVal.assignReciproc();
    return recVal;
  };

// rounding methods


  inline fpv& assignCeil()
  { //value will become the smallest integer greater than or equal to value
    //e.g. value = 2.8 -->> value = 3.0
    //e.g. value = -2.8 -->> value = -2.0
    value = Ceil( value, &bms );
    return *this;
  };


  inline fpv ceil() const
  {
    fpv ceilVal( *this );
    ceilVal.assignCeil();
    return ceilVal;
  };


  inline fpv& assignFloor()
  { //value will become the largest integers less than or equal to value
    //e.g. value = 2.8 -->> value = 2.0
    //e.g. value = -2.8 -->> value = -3.0
    value = Floor( value, &bms );
    return *this;
  };


  inline fpv floor() const
  {
    fpv floorVal( *this );
    floorVal.assignFloor();
    return floorVal;
  };


  inline fpv& assignInteger()
  { //sets the integer part of this fpv into this fpv
    //(strips the decimal places)
    double iDbl = 0.0;
    toInt64( value, &iDbl, &bms );
    value = iDbl;
    return *this;
  };


  inline fpv integer() const
  { //returns the integer part of the floating point value as fpv
    //(strips the decimal places)
    fpv intVal( *this );
    intVal.assignInteger();
    return intVal;
  };


  inline fpv& assignRound( const int decPlaces=0 )
  {
    value = Round( value, decPlaces, &bms );
    return *this;
  };
  

  inline fpv round( const long decPlaces ) const
  {
    fpv rndVal( *this );
    rndVal.assignRound( decPlaces );
    return rndVal;
  };

// sign handling


  fpv positive() const
  {
    fpv absVal( *this );
    absVal.assignPositive();
    return absVal;
  };


  fpv negative() const
  {
    fpv negVal( *this );
    negVal.assignNegative();
    return negVal;
  };


  inline fpv inv() const
  {
    fpv invVal( *this );
    invVal.assignInvertSign();
    return invVal;
  };

// end of sign handling

// power, root, log


  fpv pow( const double exponent )
  {
    fpv result(*this);
    result.assignPow( exponent );
    return result;
  };


  inline fpv sqrt() const //returns the square-root
  { //if this value is negative
    //  - status will be set to negRadicand
    //  - the result is -sqrt( abs(this value) )   (negative sqrt)
    fpv sr( *this );
    sr.assignSqrt();
    return sr;
  };


  inline fpv root(const long rootExp) const //returns the rootExp's-root
  { //if this value is negative
    //  - status will be set to negRadicand
    //  - the result is -sqrt( abs(this value) )   (negative sqrt)
    fpv rt( *this );
    rt.assignRoot( rootExp );
    return rt;
  };


  inline fpv log( const double base ) const
  {
    fpv logVal(*this);
    logVal.assignLog( base );
    return logVal;
  };

// end of power, root, log

// Trigonometric functions


  inline fpv& assignRad()
  { //this value is in degree
    //this value will be converted into rad
    assignMul( PI1 );
    return *this;
  };


  inline fpv rad() const
  { //this value is in degree
    //return value is in rad
    fpv radVal( *this );
    radVal.assignRad();
    return radVal;
  };


  inline fpv& assignDeg()
  { //this value is in rad
    //this value will be converted into degree
    assignMul( DEG1 );
    return *this;
  };


  inline fpv deg() const
  { //this value is in rad
    //return value is in degree
    fpv degVal( *this );
    degVal.assignDeg();
    return degVal;
  };


  inline fpv& assignSin()
  {
    value = sinus( value, &bms );
    return *this;
  };


  inline fpv sin() const
  {
    fpv sinVal( *this );
    sinVal.assignSin();
    return sinVal;
  };


  inline fpv& assignASin()
  {
    value = arcSin( value, &bms );
    return *this;
  };


  inline fpv asin() const
  {
    fpv arcSinVal( *this );
    arcSinVal.assignASin();
    return arcSinVal;
  };


  inline fpv& assignCos()
  {
    value = cosinus( value, &bms );
    return *this;
  };


  inline fpv cos() const
  {
    fpv cosVal( *this );
    cosVal.assignCos();
    return cosVal;
  };
  

  inline fpv& assignACos()
  {
    value = arcCos( value, &bms );
    return *this;
  };


  inline fpv acos() const
  {
    fpv arcCosVal( *this );
    arcCosVal.assignACos();
    return arcCosVal;
  };


  inline fpv& assignTan()
  { // pi/2 can not represented in 64 bit floating point value 
    // such that tan will fail
    value = tangent( value, &bms );
    return *this;
  };


  inline fpv tan() const
  {
    fpv tanVal( *this );
    tanVal.assignTan(); // with PI/2, 3PI/2, ... results into divide by zero!!!
    return tanVal;
  };


  inline fpv& assignATan()
  {
    value = arcTan( value, &bms );
    return *this;
  };


  inline fpv atan() const
  {
    fpv arcTanVal( *this );
    arcTanVal.assignATan();
    return arcTanVal;
  };


  inline fpv& assignCot()
  {
    value = cotangent( value, &bms );
    return *this;
  };


  inline fpv cot() const
  {
    fpv cotVal( *this );
    cotVal.assignCot(); // with 0, PI, ... results into divide by zero!!!
    return cotVal;
  };


  inline fpv& assignACot()
  {
    value = arcCot( value, &bms );
    return *this;
  };


  inline fpv acot() const
  {
    fpv aCotVal( *this );
    aCotVal.assignACot();
    return aCotVal;
  };
};

#endif //__FPV_H__

---