You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
657 lines
22 KiB
657 lines
22 KiB
// Public float operations.
|
|
|
|
#ifndef _CL_FLOAT_H
|
|
#define _CL_FLOAT_H
|
|
|
|
#include "cln/number.h"
|
|
#include "cln/float_class.h"
|
|
#include "cln/floatformat.h"
|
|
#include "cln/random.h"
|
|
#include "cln/integer_class.h"
|
|
#include "cln/sfloat_class.h"
|
|
#include "cln/ffloat_class.h"
|
|
#include "cln/dfloat_class.h"
|
|
#include "cln/lfloat_class.h"
|
|
|
|
namespace cln {
|
|
|
|
CL_DEFINE_AS_CONVERSION(cl_F)
|
|
|
|
|
|
// Return type for integer_decode_float:
|
|
struct cl_idecoded_float {
|
|
cl_I mantissa;
|
|
cl_I exponent;
|
|
cl_I sign;
|
|
// Constructor.
|
|
cl_idecoded_float () {}
|
|
cl_idecoded_float (const cl_I& m, const cl_I& e, const cl_I& s) : mantissa(m), exponent(e), sign(s) {}
|
|
};
|
|
|
|
|
|
// zerop(x) testet, ob (= x 0).
|
|
extern cl_boolean zerop (const cl_F& x);
|
|
|
|
// minusp(x) testet, ob (< x 0).
|
|
extern cl_boolean minusp (const cl_F& x);
|
|
|
|
// plusp(x) testet, ob (> x 0).
|
|
extern cl_boolean plusp (const cl_F& x);
|
|
|
|
|
|
// cl_F_to_SF(x) wandelt ein Float x in ein Short-Float um und rundet dabei.
|
|
extern const cl_SF cl_F_to_SF (const cl_F& x);
|
|
|
|
// cl_F_to_FF(x) wandelt ein Float x in ein Single-Float um und rundet dabei.
|
|
extern const cl_FF cl_F_to_FF (const cl_F& x);
|
|
|
|
// cl_F_to_DF(x) wandelt ein Float x in ein Double-Float um und rundet dabei.
|
|
extern const cl_DF cl_F_to_DF (const cl_F& x);
|
|
|
|
// cl_F_to_LF(x,len) wandelt ein Float x in ein Long-Float mit len Digits um
|
|
// und rundet dabei.
|
|
// > uintC len: gewünschte Anzahl Digits, >=LF_minlen
|
|
extern const cl_LF cl_F_to_LF (const cl_F& x, uintC len);
|
|
|
|
|
|
// The default float format used when converting rational numbers to floats.
|
|
extern float_format_t default_float_format;
|
|
|
|
// Returns the smallest float format which guarantees at least n decimal digits
|
|
// in the mantissa (after the decimal point).
|
|
extern float_format_t float_format (uintL n);
|
|
|
|
// cl_float(x,y) wandelt ein Float x in das Float-Format des Floats y um
|
|
// und rundet dabei nötigenfalls.
|
|
// > x,y: Floats
|
|
// < ergebnis: (float x y)
|
|
extern const cl_F cl_float (const cl_F& x, const cl_F& y);
|
|
|
|
// cl_float(x,f) wandelt ein Float x in das Float-Format f um
|
|
// und rundet dabei nötigenfalls.
|
|
// > x: ein Float
|
|
// > f: eine Float-Format-Spezifikation
|
|
// < ergebnis: (float x f)
|
|
extern const cl_F cl_float (const cl_F& x, float_format_t f);
|
|
|
|
// cl_float(x) wandelt eine reelle Zahl x in ein Float um
|
|
// und rundet dabei nötigenfalls.
|
|
// > x: eine reelle Zahl
|
|
// < ergebnis: (float x)
|
|
// Abhängig von default_float_format.
|
|
inline const cl_F cl_float (const cl_F& x) { return x; }
|
|
|
|
// cl_float(x,y) wandelt ein Integer x in das Float-Format des Floats y um
|
|
// und rundet dabei nötigenfalls.
|
|
// > x: ein Integer
|
|
// > y: ein Float
|
|
// < ergebnis: (float x y)
|
|
extern const cl_F cl_float (const cl_I& x, const cl_F& y);
|
|
|
|
// cl_float(x,y) wandelt ein Integer x in das Float-Format f um
|
|
// und rundet dabei nötigenfalls.
|
|
// > x: ein Integer
|
|
// > f: eine Float-Format-Spezifikation
|
|
// < ergebnis: (float x f)
|
|
extern const cl_F cl_float (const cl_I& x, float_format_t f);
|
|
|
|
// cl_float(x) wandelt ein Integer x in ein Float um und rundet dabei.
|
|
// > x: ein Integer
|
|
// < ergebnis: (float x)
|
|
// Abhängig von default_float_format.
|
|
extern const cl_F cl_float (const cl_I& x);
|
|
|
|
// cl_float(x,y) wandelt eine rationale Zahl x in das Float-Format des
|
|
// Floats y um und rundet dabei nötigenfalls.
|
|
// > x: eine rationale Zahl
|
|
// > y: ein Float
|
|
// < ergebnis: (float x y)
|
|
extern const cl_F cl_float (const cl_RA& x, const cl_F& y);
|
|
|
|
// cl_float(x,y) wandelt eine rationale Zahl x in das Float-Format f um
|
|
// und rundet dabei nötigenfalls.
|
|
// > x: eine rationale Zahl
|
|
// > f: eine Float-Format-Spezifikation
|
|
// < ergebnis: (float x f)
|
|
extern const cl_F cl_float (const cl_RA& x, float_format_t f);
|
|
|
|
// cl_float(x) wandelt eine rationale Zahl x in ein Float um und rundet dabei.
|
|
// > x: eine rationale Zahl
|
|
// < ergebnis: (float x)
|
|
// Abhängig von default_float_format.
|
|
extern const cl_F cl_float (const cl_RA& x);
|
|
|
|
// The C++ compilers are not clever enough to guess this:
|
|
inline const cl_F cl_float (int x, const cl_F& y)
|
|
{ return cl_float(cl_I(x),y); }
|
|
inline const cl_F cl_float (unsigned int x, const cl_F& y)
|
|
{ return cl_float(cl_I(x),y); }
|
|
inline const cl_F cl_float (int x, float_format_t y)
|
|
{ return cl_float(cl_I(x),y); }
|
|
inline const cl_F cl_float (unsigned int x, float_format_t y)
|
|
{ return cl_float(cl_I(x),y); }
|
|
inline const cl_F cl_float (int x)
|
|
{ return cl_float(cl_I(x)); }
|
|
inline const cl_F cl_float (unsigned int x)
|
|
{ return cl_float(cl_I(x)); }
|
|
// The C++ compilers could hardly guess the following:
|
|
inline const cl_F cl_float (float x, const cl_F& y)
|
|
{ return cl_float(cl_FF(x),y); }
|
|
inline const cl_F cl_float (double x, const cl_F& y)
|
|
{ return cl_float(cl_DF(x),y); }
|
|
inline const cl_F cl_float (float x, float_format_t y)
|
|
{ return cl_float(cl_FF(x),y); }
|
|
inline const cl_F cl_float (double x, float_format_t y)
|
|
{ return cl_float(cl_DF(x),y); }
|
|
inline const cl_F cl_float (float x)
|
|
{ return cl_float(cl_FF(x)); }
|
|
inline const cl_F cl_float (double x)
|
|
{ return cl_float(cl_DF(x)); }
|
|
|
|
|
|
// Liefert (- x), wo x ein Float ist.
|
|
extern const cl_F operator- (const cl_F& x);
|
|
|
|
// Liefert (+ x y), wo x und y Floats sind.
|
|
extern const cl_F operator+ (const cl_F& x, const cl_F& y);
|
|
// The C++ compilers could hardly guess the following:
|
|
inline const cl_F operator+ (const cl_RA& x, const cl_F& y)
|
|
{ return cl_float(x,y) + y; }
|
|
inline const cl_F operator+ (const cl_I& x, const cl_F& y)
|
|
{ return cl_float(x,y) + y; }
|
|
inline const cl_F operator+ (const cl_F& x, const cl_RA& y)
|
|
{ return x + cl_float(y,x); }
|
|
inline const cl_F operator+ (const cl_F& x, const cl_I& y)
|
|
{ return x + cl_float(y,x); }
|
|
// Dem C++-Compiler muß man nun auch das Folgende sagen:
|
|
inline const cl_F operator+ (const int x, const cl_F& y)
|
|
{ return cl_I(x) + y; }
|
|
inline const cl_F operator+ (const unsigned int x, const cl_F& y)
|
|
{ return cl_I(x) + y; }
|
|
inline const cl_F operator+ (const long x, const cl_F& y)
|
|
{ return cl_I(x) + y; }
|
|
inline const cl_F operator+ (const unsigned long x, const cl_F& y)
|
|
{ return cl_I(x) + y; }
|
|
inline const cl_F operator+ (const cl_F& x, const int y)
|
|
{ return x + cl_I(y); }
|
|
inline const cl_F operator+ (const cl_F& x, const unsigned int y)
|
|
{ return x + cl_I(y); }
|
|
inline const cl_F operator+ (const cl_F& x, const long y)
|
|
{ return x + cl_I(y); }
|
|
inline const cl_F operator+ (const cl_F& x, const unsigned long y)
|
|
{ return x + cl_I(y); }
|
|
|
|
// Liefert (- x y), wo x und y Floats sind.
|
|
extern const cl_F operator- (const cl_F& x, const cl_F& y);
|
|
// The C++ compilers could hardly guess the following:
|
|
inline const cl_F operator- (const cl_RA& x, const cl_F& y)
|
|
{ return cl_float(x,y) - y; }
|
|
inline const cl_F operator- (const cl_I& x, const cl_F& y)
|
|
{ return cl_float(x,y) - y; }
|
|
inline const cl_F operator- (const cl_F& x, const cl_RA& y)
|
|
{ return x - cl_float(y,x); }
|
|
inline const cl_F operator- (const cl_F& x, const cl_I& y)
|
|
{ return x - cl_float(y,x); }
|
|
// Dem C++-Compiler muß man nun auch das Folgende sagen:
|
|
inline const cl_F operator- (const int x, const cl_F& y)
|
|
{ return cl_I(x) - y; }
|
|
inline const cl_F operator- (const unsigned int x, const cl_F& y)
|
|
{ return cl_I(x) - y; }
|
|
inline const cl_F operator- (const long x, const cl_F& y)
|
|
{ return cl_I(x) - y; }
|
|
inline const cl_F operator- (const unsigned long x, const cl_F& y)
|
|
{ return cl_I(x) - y; }
|
|
inline const cl_F operator- (const cl_F& x, const int y)
|
|
{ return x - cl_I(y); }
|
|
inline const cl_F operator- (const cl_F& x, const unsigned int y)
|
|
{ return x - cl_I(y); }
|
|
inline const cl_F operator- (const cl_F& x, const long y)
|
|
{ return x - cl_I(y); }
|
|
inline const cl_F operator- (const cl_F& x, const unsigned long y)
|
|
{ return x - cl_I(y); }
|
|
|
|
// Liefert (* x y), wo x und y Floats sind.
|
|
extern const cl_F operator* (const cl_F& x, const cl_F& y);
|
|
// Spezialfall x oder y Integer oder rationale Zahl.
|
|
inline const cl_R operator* (const cl_F& x, const cl_I& y)
|
|
{
|
|
extern const cl_R cl_F_I_mul (const cl_F&, const cl_I&);
|
|
return cl_F_I_mul(x,y);
|
|
}
|
|
inline const cl_R operator* (const cl_I& x, const cl_F& y)
|
|
{
|
|
extern const cl_R cl_F_I_mul (const cl_F&, const cl_I&);
|
|
return cl_F_I_mul(y,x);
|
|
}
|
|
inline const cl_R operator* (const cl_F& x, const cl_RA& y)
|
|
{
|
|
extern const cl_R cl_F_RA_mul (const cl_F&, const cl_RA&);
|
|
return cl_F_RA_mul(x,y);
|
|
}
|
|
inline const cl_R operator* (const cl_RA& x, const cl_F& y)
|
|
{
|
|
extern const cl_R cl_F_RA_mul (const cl_F&, const cl_RA&);
|
|
return cl_F_RA_mul(y,x);
|
|
}
|
|
// Dem C++-Compiler muß man nun auch das Folgende sagen:
|
|
inline const cl_R operator* (const int x, const cl_F& y)
|
|
{ return cl_I(x) * y; }
|
|
inline const cl_R operator* (const unsigned int x, const cl_F& y)
|
|
{ return cl_I(x) * y; }
|
|
inline const cl_R operator* (const long x, const cl_F& y)
|
|
{ return cl_I(x) * y; }
|
|
inline const cl_R operator* (const unsigned long x, const cl_F& y)
|
|
{ return cl_I(x) * y; }
|
|
inline const cl_R operator* (const cl_F& x, const int y)
|
|
{ return x * cl_I(y); }
|
|
|