?? tlargefloat.h
字號:
#ifndef _TLARGE_FLOAT_H__INCLUDED_
#define _TLARGE_FLOAT_H__INCLUDED_
#include <vector>
#include <sstream>
#include <string>
#include <Exception>
#include <limits>
#include <algorithm>
class TLargeFloat;//超高精度浮點數類TLargeFloat
class TLargeFloatException;//超高精度浮點數異常類
//改進方向：
// 1.強力優化ArrayMUL數組乘運算(當前算法復雜度為n*n)，
// 可以使用二分算法來降低運算量，并使用復雜度為n*log(n)的快速復利葉變換或數論變換）
// 2.增加運算精度動態控制能力，有利于優化，減少乘法量；
// 3.添加新的基本運算函數，如：指數運算power、對數運算log、三角函數sin,cos,tan等
// 4.可以考慮：內部使用2的次方的底數;這樣的話，輸出函數就會麻煩一些了
//////注意：如果浮點數與TLargeFloat進行混合運算；
// 可能會產生誤差(有效位數會受到浮點數影響)；
// 整數 或 為可表示整數的浮點數 參與運算不會產生誤差；
//超高精度浮點數異常類
class TLargeFloatException :public std::exception
{
private:
std::string m_ErrorMsg;
public:
TLargeFloatException() {};
TLargeFloatException(const char * Error_Msg) :m_ErrorMsg(Error_Msg){ }
virtual const char* what() const throw() { return m_ErrorMsg.c_str();}
virtual ~TLargeFloatException() throw() {}
};
//TCatchIntError只是對整數類型TInt進行的包裝
//設計TCatchIntError是為了當整數運算超出值域的時候，拋出異常
//超高精度浮點數類的指數運算時使用
template <typename TInt,typename TException,TInt MinValue,TInt MaxValue>
//<要包裝的整數類型，超界時拋出的異常類型，TInt最小值，TInt最大值>
class TCatchIntError
{
private:
typedef TCatchIntError<TInt,TException,MinValue,MaxValue> SelfType;
TInt m_Int;
SelfType& inc(TInt uValue)
{
if (MaxValue-uValue<m_Int)
throw TException("ERROR:TCatchIntError::inc(); ");
m_Int+=uValue;
return (*this);
}
SelfType& dec(TInt uValue)
{
if (MinValue+uValue>m_Int)
throw TException("ERROR:TCatchIntError::dec()");
m_Int-=uValue;
return (*this);
}
public:
TCatchIntError() :m_Int(0){}
TCatchIntError(TInt Value) :m_Int(Value){}
TCatchIntError(const SelfType& Value) :m_Int(Value.m_Int){}
TInt AsInt()const { return m_Int; }
SelfType& operator +=(TInt Value) //throw(TLargeFloatException)
{ if (Value<0) return dec(-Value);
else return inc(Value); }
SelfType& operator -=(TInt Value) //throw(TLargeFloatException)
{ if (Value<0) return inc(-Value);
else return dec(Value); }
SelfType& operator +=(const SelfType& Value) { return (*this)+=(Value.m_Int); }//throw(TLargeFloatException)
SelfType& operator -=(const SelfType& Value) { return (*this)-=(Value.m_Int); }//throw(TLargeFloatException)
};
////填寫編譯器支持的較大的整數類型
//__int64 Int64_Min() { return std::numeric_limits<__int64>::min(); }//返回0, :(
//__int64 Int64_Max() { return std::numeric_limits<__int64>::max(); }//返回0, :(
//const __int64 Int64_Min = - __int64(9223372036854775808);//注意負號
//const __int64 Int64_Max = __int64(9223372036854775807);
const long int Int64_Min = -2147483648;//注意負號
const long int Int64_Max = 2147483647;
namespace Private_
{
template<typename T>
inline const T& min(const T& x,const T& y)//求最小值
{
if (x>y)
return y;
else
return x;
}
template<typename T>
inline const T& max(const T& x,const T& y)//求最大值
{
if (x>y)
return x;
else
return y;
}
template<typename T>
inline const T abs(const T& x)//求絕對值
{
if (x<0)
return -x;
else
return x;
}
template<typename T>
inline void swap(T& x,T& y) //交換兩個變量的值
{
T temp=x;
x=y;
y=temp;
}
}//end namespace
//超高精度浮點數類
class TLargeFloat
{
private:
enum {
emLongDoubleDigits=std::numeric_limits<long double>::digits10,//long double的10進制有效精度
emLongDoubleMaxExponent=std::numeric_limits<long double>::max_exponent10,//long double的最大10進制指數
emLongDoubleMinExponent=std::numeric_limits<long double>::min_exponent10 };//long double的最小10進制指數
typedef TLargeFloat SelfType;
typedef TLargeFloatException TException;
typedef long int Int32bit;//32bit位的整數類型,超過也可以
//typedef __int64 TMaxInt; //填寫編譯器支持的較大的整數類型
typedef long int TMaxInt; //填寫編譯器支持的較大的整數類型
typedef TCatchIntError<TMaxInt,TException,Int64_Min,Int64_Max> ExpInt;//注意：后面的兩個值為TMaxInt的最小值和最大值
typedef std::vector<Int32bit> TArray;//小數位使用的數組類型
enum { em10Power=4, emBase=10000};//數組為10000進制，數組的一個元素表示一位，對應4個十進制位
Int32bit m_Sign; //符號位 正:1, 負:-1, 零: 0
ExpInt m_Exponent; //保存10為底的指數
TArray m_Digits; //小數部分 排列順序是TArray[0]為第一個小數位,依此類推；取值范圍0--999
void Abs_Add(const SelfType& Value);//絕對值加 x:=|x|+|y|;
void Abs_Sub_Abs(const SelfType& Value);//絕對值減的絕對值x:=| |x|-|y| |;
void MoveLeft10Power(TMaxInt MoveCount);//十進制指數移動 值不變指數增大MoveCount
void MoveRight10Power(TMaxInt MoveCount);//十進制指數移動 值不變指數減小MoveCount
void MulInt(TMaxInt iValue);//乘以一個整數；
void DivInt(TMaxInt iValue);//除以一個整數；
void Clear();//清零
void Chs();//求負
int Compare(const SelfType& Value) const;//比較兩個數；(*this)>Value 返回1，小于返回-1，相等返回0
void Canonicity();//規格化 轉化值到合法格式
static std::string DigitToString(Int32bit iDigit);//將數組的一個元素轉換為字符串表示
static void toEqExponent(SelfType& x,SelfType& y);//值不變，x,y的小數點對齊
static void SetSameSizeMax(SelfType& x,SelfType& y);//使兩個高精度數的有效位數相同，位數小的進行提升
static bool FloatIsInteger(long double fValue);//判斷浮點數是否為可表示整數
static unsigned int DigitsSize(unsigned int uiDigitsLength);//
//數組乘 （卷積result[i+j]=x[i]*y[j];) //ArrayMUL 是需要優化的首要目標
static void ArrayMUL(const Int32bit* x,const Int32bit* y,Int32bit* result,unsigned int MulSize);
class TCharacter{};
TLargeFloat(long double DefultFloatValue,const TCharacter&);//內部使用，浮點數轉化為 TLargeFloat
void Abs();//絕對值
void Rev();//求倒數1/x
void RevSqrt();//求1/x^0.5;
void Sqrt();//求x^0.5;
public:
class TDigits//TDigits用來設置TLargeFloat的精度;//增加這個類是為了避免TLargeFloat的構造函數的可能誤用
{
private:
unsigned int m_eDigits;
public:
explicit TDigits(unsigned int uiDigitsLength) :m_eDigits(uiDigitsLength){}
unsigned int GetDigits()const { return m_eDigits; }
};
TLargeFloat(const SelfType& Value);
TLargeFloat(long double DefultValue,const TDigits& DigitsLength);//TDigits (十進制的)有效位數
virtual ~TLargeFloat(){}
void swap(SelfType& Value);//交換值
unsigned int GetDigitsLength() const;//返回當前的10進制有效位數
void SetDigitsLength(unsigned int uiDigitsLength);//重新設置10進制有效位數
void SetDigitsLength(const TDigits& DigitsLength) { SetDigitsLength(DigitsLength.GetDigits()); }
long double AsFloat() const;//轉化為浮點數
std::string AsString() const;//轉換為字符串
const SelfType operator - () const;//求負 //注意：不能使用SelfType&
const SelfType& operator + () const;//求正 //注意：可以使用SelfType&,因為值不變
SelfType& operator = (long double fValue); //注意：轉換可能存在小的誤差
SelfType& operator = (const SelfType& Value); //編譯器默認的也行
SelfType& operator *= (long double fValue);
SelfType& operator /= (long double fValue);
SelfType& operator += (long double fValue);
SelfType& operator -= (long double fValue);
SelfType& operator += (const SelfType& Value);
SelfType& operator -= (const SelfType& Value);
SelfType& operator *= (const SelfType& Value);
SelfType& operator /= (const SelfType& Value);
friend const TLargeFloat operator + (const TLargeFloat& x,const TLargeFloat& y);
friend const TLargeFloat operator - (const TLargeFloat& x,const TLargeFloat& y);
friend const TLargeFloat operator * (const TLargeFloat& x,const TLargeFloat& y);
friend const TLargeFloat operator / (const TLargeFloat& x,const TLargeFloat& y);
friend const TLargeFloat operator + (const TLargeFloat& x,long double y);
friend const TLargeFloat operator - (const TLargeFloat& x,long double y);
friend const TLargeFloat operator * (const TLargeFloat& x,long double y);
friend const TLargeFloat operator / (const TLargeFloat& x,long double y);
friend const TLargeFloat operator + (long double x,const TLargeFloat& y);
friend const TLargeFloat operator - (long double x,const TLargeFloat& y);
friend const TLargeFloat operator * (long double x,const TLargeFloat& y);
friend const TLargeFloat operator / (long double x,const TLargeFloat& y);
friend bool operator ==(const TLargeFloat& x,const TLargeFloat& y);
friend bool operator < (const TLargeFloat& x,const TLargeFloat& y);
friend bool operator ==(const TLargeFloat& x,long double y);
friend bool operator < (const TLargeFloat& x,long double y);
friend bool operator ==(long double x,const TLargeFloat& y) { return (y==x); }
friend bool operator < (long double x,const TLargeFloat& y) { return (y>x); }
friend bool operator !=(const TLargeFloat& x,const TLargeFloat& y) { return !(x==y); }
friend bool operator > (const TLargeFloat& x,const TLargeFloat& y) { return (y<x); }
friend bool operator >=(const TLargeFloat& x,const TLargeFloat& y) { return !(x<y); }
friend bool operator <=(const TLargeFloat& x,const TLargeFloat& y) { return !(x>y); }
friend bool operator !=(const TLargeFloat& x,long double y) { return !(x==y); }
friend bool operator > (const TLargeFloat& x,long double y) { return (y<x); }
friend bool operator >=(const TLargeFloat& x,long double y) { return !(x<y); }
friend bool operator <=(const TLargeFloat& x,long double y) { return !(x>y); }
friend bool operator !=(long double x,const TLargeFloat& y) { return !(x==y); }
friend bool operator > (long double x,const TLargeFloat& y) { return (y<x); }
friend bool operator >=(long double x,const TLargeFloat& y) { return !(x<y); }
friend bool operator <=(long double x,const TLargeFloat& y) { return !(x>y); }
friend std::ostream& operator << (std::ostream& cout, const TLargeFloat& Value) { return cout<<Value.AsString(); }
friend void swap(TLargeFloat& x,TLargeFloat& y) { x.swap(y); }
friend const TLargeFloat abs(const TLargeFloat& x) { TLargeFloat result(x); result.Abs(); return result; }//絕對值,|x|
friend const TLargeFloat sqrt(const TLargeFloat& x) { TLargeFloat result(x); result.Sqrt(); return result;} //開方,x^0.5
friend const TLargeFloat revsqrt(const TLargeFloat& x) { TLargeFloat result(x); result.RevSqrt(); return result; }//求1/x^0.5;
friend const TLargeFloat sqr(const TLargeFloat& x) { return x*x; };//平方,x^2
};
void LargeFloat_UnitTest();//正確性測試
void Debug_toCout(const std::string& strx,const TLargeFloat& x);//調試輸出
#endif // _TLARGE_FLOAT_H__INCLUDED_
// TLargeFloat.h
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -