Source: vargmp.h


Annotated List
Files
Globals
Hierarchy
Index
/*  vargmp.h - 
    This file is part of Kalamaris
    Copyright (C) 2000  Antonio Larrosa Jimenez
    Kalamaris' homepage : http://www.arrakis.es/~rlarrosa/kalamaris.html

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 

    Send comments and bug fixes to Antonio Larrosa <larrosa@kde.org>

 ***************************************************************************/
#ifndef _VARGMP_H
#define _VARGMP_H

#include "vartype.h"
#include <gmp.h>

class QString;

class TArbitraryPrecision : public T
{
protected:
  
  mpf_t v;

public:

  TArbitraryPrecision(const QString &s);
  TArbitraryPrecision(const mpf_t & g);
  TArbitraryPrecision(const double g);
  TArbitraryPrecision(const int g);
  TArbitraryPrecision(const unsigned int g);
  /**
   * Copy constructor
   */
  TArbitraryPrecision( const TArbitraryPrecision &x);
  // XXX destructor !!!

  virtual TArbitraryPrecision *copy(void);

  // XXX Should be const ... &
  virtual inline int operator==( const TArbitraryPrecision &v1 );
  virtual inline int operator==( const T &v1 );
  virtual inline int operator==( const mpf_t & v1 );
  virtual inline int operator!=( const TArbitraryPrecision &v1 );
  virtual inline int operator!=( const T &v1 );
  virtual inline int operator!=( const mpf_t & v1 );
  virtual inline int operator<( const TArbitraryPrecision &v1 );
  virtual inline int operator<( const T &v1 );
  virtual inline int operator<( const mpf_t & v1 );
  virtual inline int operator>( const TArbitraryPrecision &v1 );
  virtual inline int operator>( const T &v1 );
  virtual inline int operator>( const mpf_t & v1 );
  virtual inline int operator>=( const TArbitraryPrecision &v1 );
  virtual inline int operator>=( const T &v1 );
  virtual inline int operator>=( const mpf_t & v1 );
  virtual inline int operator<=( const TArbitraryPrecision &v1 );
  virtual inline int operator<=( const T &v1 );
  virtual inline int operator<=( const mpf_t & v1 );
  virtual T &operator=( const TArbitraryPrecision &x );
  virtual T &operator=( const mpf_t & x );
  virtual T &operator++( ); 
  virtual T &operator++( int ); 
  virtual T &operator--( ); 
  virtual T &operator--( int ); 
  virtual T &operator+=( const TArbitraryPrecision &x );
  virtual T &operator-=( const TArbitraryPrecision &x );
  virtual T &operator*=( const TArbitraryPrecision &x );
  virtual T &operator/=( const TArbitraryPrecision &x );
  virtual T &operator+=( const unsigned int i );
  virtual T &operator-=( const unsigned int i );
  virtual T &operator*=( const unsigned int i );
  virtual T &operator/=( const unsigned int i );
  virtual T &operator+=( const int i );
  virtual T &operator-=( const int i );
  virtual T &operator*=( const int i );
  virtual T &operator/=( const int i );
  virtual T &abs( void );
  virtual T &sqrt( const double &idx=2.0 );
  virtual T &sin( void );
  virtual T &cos( void );
  virtual T &tan( void );
  virtual T &exp( void );  
  virtual T &log( void );  
  virtual T &log( const T &base );  

  static T *add(const TArbitraryPrecision *t1, const TArbitraryPrecision *t2);
  static T *sub(const TArbitraryPrecision *t1, const TArbitraryPrecision *t2);
  static T *mul(const TArbitraryPrecision *t1, const TArbitraryPrecision *t2);
  static T *div(const TArbitraryPrecision *t1, const TArbitraryPrecision *t2);
  static T *pow(const TArbitraryPrecision *t1, const TArbitraryPrecision *t2);
  static T *add(const TArbitraryPrecision * m1, const unsigned int i);
  static T *sub(const TArbitraryPrecision * m1, const unsigned int i);
  static T *mul(const TArbitraryPrecision * m1, const unsigned int i);
  static T *div(const TArbitraryPrecision * m1, const unsigned int i);
  static T *add(const TArbitraryPrecision * m1, const int i);
  static T *sub(const TArbitraryPrecision * m1, const int i);
  static T *mul(const TArbitraryPrecision * m1, const int i);
  static T *div(const TArbitraryPrecision * m1, const int i);

  virtual operator const double () const;
  inline const mpf_t & value() const { return v; };

  virtual QString string(void) const;
  virtual const char *isA() const { return "TArbitraryPrecision"; };
   
  /**
   * XXX The next method is optimized as there's only T, TArbitraryPrecision
   * and TMatrix data types. It should be changed when more types are added
   */
  virtual int isA(const char *str) const { return (strlen(str)==19); };
      
};

// Operators

inline T &operator+( const TArbitraryPrecision &v1, const TArbitraryPrecision &v2 );
inline T &operator-( const TArbitraryPrecision &v1, const TArbitraryPrecision &v2 );
inline T &operator*( const TArbitraryPrecision &v1, const TArbitraryPrecision &v2 );
inline T &operator/( const TArbitraryPrecision &v1, const TArbitraryPrecision &v2 );

#endif

Generated by: antlarr@terminus on Wed May 31 08:19:51 2000, using kdoc 2.0a22.