自己动手打造“超高精度浮点数类”
自己动手打造“超高精度浮点数类”
[email protected]
tag:PI,超高精度浮点数,TLargeFloat,FFT乘法,二分乘法,牛顿迭代法,borwein四次迭代,AGM二次迭代
很多人可能都想自己写一个能够执行任意精度计算的浮点数；:D我写的第一个程序就是用qbasic计算自然数e到100万位(后来计算PI); 这里有一个C++类的实现TLargeFloat，它能够执行高精度的浮点数运算；演示代码里面有一个计算PI的Borwein四次迭代式和一个AGM二次迭代式（我用它计算出了上亿位的PI小数位:）
源代码的简要导读文章： http://blog.csdn.net/housisong/archive/2007/12/24/1965652.aspx
(2007.12.14 进行了一些速度优化,添加了FFT实现的大数乘法； 进行高精度(百万千万位)运算时的速度提高了很多!)
(2007.11.29 对代码进行了一次梳理，添加了二分法实现的大数乘法,改进了除法和开方运算；速度提高很多)
(2007.11.20 对乘法进行了一点小的优化,速度提高了些; 修正了两处bug,在MoveLeft10Power和MulInt函数中的进位问题)
类的声明文件:TLargeFloat.h
/////
// TLargeFloat.h: interface for the TLargeFloat class.
// 超高精度浮点数类TLargeFloat
// 2004.03.28 by [email protected]
//
// Update 2004.03.31 by HouSisong
// ......
// Update 2007.11.29-12.20 by HouSisong 重构一遍,速度加快很多，我用它计算了上亿位的PI值:)
#ifndef _TLARGE_FLOAT_H__INCLUDED_
#define _TLARGE_FLOAT_H__INCLUDED_
#include <vector>
#include <sstream>
#include <string>
#include <Exception>
#include <limits>
class TLargeFloat;//超高精度浮点数类TLargeFloat
class TLargeFloatException;// 超高精度浮点数异常类
// 改进方向：
// 1.强力优化ArrayMUL数组乘运算(当前实现了二分法和FFT算法)：
// a.将实数按齐偶作为复数进行傅立叶变换的算法实现，加快乘法速度
// b.实现混合基的傅立叶变换，加快乘法速度
// c.考虑用x87的10byte浮点数实现FFT以减小误差从而增大FFT能够计算的最大位数限制
// d.用SSE2等优化快速复利叶变换，加快乘法速度
// e.或者将傅立叶变换替换为数论变换的实现(使用整数)
// 2.内部使用8位(或9位)十进制来实现，节约内存；或者2进制的底数(这样的话，输出函数就会麻烦一些了)
// 3.添加新的基本运算函数，如：指数运算power、对数运算log、三角函数sin,cos,tan等
// 注意：如果浮点数与TLargeFloat进行混合运算, 可能会产生误差(有效位数会受到浮点数影响)；
// 整数 或 为可表示整数的浮点数 参与运算不会产生误差；
// 对于很大的整数或者有小数位的浮点数，建议用字符串的形式转换为超高精度浮点数(不会引入误差)
//void ArrayMUL(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize);// 数组乘, 需要优化的首要目标
//超高精度浮点数异常类 //TLargeFloat运算中出现错误的时候会抛出该类型的异常
class TLargeFloatException :public std::runtime_error
{
public :
TLargeFloatException(const char * Error_Msg) :runtime_error(Error_Msg){}
virtual ~TLargeFloatException() throw () {}
};
// TCatchIntError只是对整数类型TInt进行的一层包装
// 超高精度浮点数类的指数运算时使用
// 设计TCatchIntError是为了当整数运算超出值域的时候，抛出异常
//template<要包装的整数类型，超界时抛出的异常类型，TInt最小值，TInt最大值>
template <typename TInt,typename TException,TInt MinValue,TInt MaxValue>
class TCatchIntError
{
private :
typedef TCatchIntError<TInt,TException,MinValue,MaxValue> SelfType;
TInt m_Int;
inline SelfType& inc(const TInt& uValue)
{
if ( (uValue<0)||(uValue>MaxValue)||(MaxValue-uValue< m_Int) )
throw TException("ERROR:TCatchIntError::inc(); " );
m_Int+= uValue;
return (*this );
}
inline SelfType& dec(const TInt& uValue)
{
if ( (uValue<0)||(uValue>MaxValue)||(MinValue+uValue> m_Int) )
throw TException("ERROR:TCatchIntError::dec()" );
m_Int-= uValue;
return (*this );
}
inline SelfType& mul(const TInt& iValue)
{
if (iValue==0 )
m_Int=0 ;
else
{
TInt tmp =m_Int* iValue;
if ( (iValue<MinValue)||(iValue>MaxValue)||(tmp<MinValue)||(tmp>MaxValue)||((tmp/iValue)!= m_Int) )
throw TException("ERROR:TCatchIntError::mul(); " );
m_Int= tmp;
}
return (*this );
}
public :
inline TCatchIntError() :m_Int(0 ){ }
inline TCatchIntError(const TInt& Value) :m_Int(0) { (*this)+= Value;}
inline TCatchIntError(const SelfType& Value) :m_Int(0) { (*this)+= (Value.m_Int); }
inline const TInt& AsInt() const { return m_Int; }
inline SelfType& operator +=(const TInt& Value) //throw(TLargeFloatException)
{ if (Value<0) return dec(- Value);
else return inc(Value); }
inline SelfType& operator -=(const TInt& Value) //throw(TLargeFloatException)
{ if (Value<0) return inc(- Value);
else return dec(Value); }
inline SelfType& operator *=(const TInt& Value) //throw(TLargeFloatException)
{ return mul(Value); }
inline SelfType& operator +=(const SelfType& Value) { return (*this)+=(Value.m_Int); }//throw(TLargeFloatException)
inline SelfType& operator -=(const SelfType& Value) { return (*this)-=(Value.m_Int); }//throw(TLargeFloatException)
inline SelfType& operator *=(const SelfType& Value) { return (*this)*=(Value.m_Int); }//throw(TLargeFloatException)
};
// 指数部分使用的整数类型 填写编译器支持的较大的整数类型
//typedef __int64 TMaxInt; // type long long TMaxInt;
// const TMaxInt TMaxInt_MAX_VALUE = TMaxInt(9223372036854775807);
//const TMaxInt TMaxInt_MIN_VALUE = - TMaxInt_MAX_VALUE;
typedef long TMaxInt;
const TMaxInt TMaxInt_MAX_VALUE = 2147483647 ;
const TMaxInt TMaxInt_MIN_VALUE = - TMaxInt_MAX_VALUE;
//小数部分使用的整数类型 32bit位的整数类型
typedef long TInt32bit;
const TInt32bit TInt32bit_MAX_VALUE = 2147483647 ;
const TInt32bit TInt32bit_MIN_VALUE = - TInt32bit_MAX_VALUE;
//超高精度浮点数类
class TLargeFloat
{
public :
//一些常量和类型定义
typedef std::vector<TInt32bit> TArray;//小数位使用的数组类型
enum { em10Power =4, //数组为10000进制，
emBase =10000, //数组的一个元素对应4个十进制位
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 TLargeFloatException TException;
typedef TCatchIntError<TMaxInt,TException,TMaxInt_MIN_VALUE,TMaxInt_MAX_VALUE> TExpInt;//指数类型
typedef TLargeFloat SelfType;
public :
class TDigits//TDigits用来设置TLargeFloat的精度;//增加这个类是为了避免TLargeFloat的构造函数的可能误用
{
private :
unsigned long m_DigitsArraySize;
public :
explicit TDigits(const long uiDigitsLength)
{ if (uiDigitsLength<=0) throw TException("ERROR:TLargeFloat::TDigits()" );
m_DigitsArraySize=(uiDigitsLength+em10Power-1)/ em10Power; }
inline const unsigned long GetDigitsArraySize() const { return m_DigitsArraySize; }
};
TLargeFloat(const SelfType& Value);
explicit TLargeFloat(const long double DefultValue);//默认浮点精度 //注意：转换可能存在小的误差
explicit TLargeFloat(const long double DefultValue,const TDigits& DigitsLength);//TDigits 十进制有效位数 //注意：转换可能存在小的误差
explicit TLargeFloat(const char* strValue);//使用字符串本身的精度
explicit TLargeFloat(const char* strValue,const TDigits& DigitsLength);
explicit TLargeFloat(const std::string& strValue);
explicit TLargeFloat(const std::string& strValue,const TDigits& DigitsLength);
long double AsFloat() const;//转化为浮点数
std::string AsString() const;//转换为字符串
void SetDigitsLength(const TDigits& DigitsLength); //重新设置10进制有效位数
inline void SetDigitsLength(const long uiDigitsLength) { SetDigitsLength(TDigits(uiDigitsLength)); }
unsigned long GetDigitsLength() const;//返回当前的10进制有效位数
void Swap(SelfType& Value);//交换值
void Zero(); //设置为0
inline void StrToLargeFloat(const std::string& strValue) { sToLargeFloat(strValue); }
inline void StrToLargeFloat(const char* strValue) { sToLargeFloat(std::string (strValue)); }
SelfType& operator = (const SelfType& Value);
SelfType& operator = (long double fValue); //注意：转换可能存在小的误差
inline const SelfType operator - () const { SelfType temp(*this); temp.Chs(); return temp; }//求负
inline const SelfType& operator + () const { return (*this); }//求正
SelfType & operator += (const SelfType& Value);
SelfType& operator -= (const SelfType& Value);
inline SelfType& operator += (long double fValue) { return (*this)+= TLargeFloat(fValue); }
inline SelfType& operator -= (long double fValue) { return (*this)-= TLargeFloat(fValue); }
friend inline const TLargeFloat operator + (const TLargeFloat& x,const TLargeFloat& y) { TLargeFloat temp(x); return temp+= y; }
friend inline const TLargeFloat operator - (const TLargeFloat& x,const TLargeFloat& y) { TLargeFloat temp(x); return temp-= y; }
friend inline const TLargeFloat operator + (const TLargeFloat& x,long double y) { TLargeFloat temp(x); return temp+= y; }
friend inline const TLargeFloat operator - (const TLargeFloat& x,long double y) { TLargeFloat temp(x); return temp-= y; }
friend inline const TLargeFloat operator + (long double x,const TLargeFloat& y) { return y+ x; }
friend inline const TLargeFloat operator - (long double x,const TLargeFloat& y) { return -(y- x); }
SelfType& operator *= (long double fValue);
SelfType& operator *= (const SelfType& Value);
friend inline const TLargeFloat operator * (const TLargeFloat& x,const TLargeFloat& y) { TLargeFloat temp(x); if (&x!=&y) return temp*=y; else { temp.Sqr(); return temp; } }
friend inline const TLargeFloat operator * (const TLargeFloat& x,long double y) {TLargeFloat temp(x); return temp*= y;}
friend inline const TLargeFloat operator * (long double x,const TLargeFloat& y) { return y* x; }
SelfType& operator /= (long double fValue);
SelfType& operator /= (const SelfType& Value);
friend inline const TLargeFloat operator / (const TLargeFloat& x,const TLargeFloat& y) { TLargeFloat temp(x); return temp/= y; }
friend inline const TLargeFloat operator / (const TLargeFloat& x,long double y) { TLargeFloat temp(x); return temp/= y; }
friend inline const TLargeFloat operator / (long double x,const TLargeFloat& y) { TLargeFloat temp(y); temp.Rev(); return temp*= x; }
friend inline bool operator ==(const TLargeFloat& x,const TLargeFloat& y) { return (x.Compare(y)==0 ); }
friend inline bool operator < (const TLargeFloat& x,const TLargeFloat& y) { return (x.Compare(y)<0 ); }
friend inline bool operator ==(const TLargeFloat& x,long double y) { return (x== TLargeFloat(y)); }
friend inline bool operator < (const TLargeFloat& x,long double y) { return (x< TLargeFloat(y)); }
friend inline bool operator ==(long double x,const TLargeFloat& y) { return (y== x); }
friend inline bool operator < (long double x,const TLargeFloat& y) { return (y> x); }
friend inline bool operator !=(const TLargeFloat& x,const TLargeFloat& y) { return !(x== y); }
friend inline bool operator > (const TLargeFloat& x,const TLargeFloat& y) { return (y< x); }
friend inline bool operator >=(const TLargeFloat& x,const TLargeFloat& y) { return !(x< y); }
friend inline bool operator <=(const TLargeFloat& x,const TLargeFloat& y) { return !(x> y); }
friend inline bool operator !=(const TLargeFloat& x,long double y) { return !(x== y); }
friend inline bool operator > (const TLargeFloat& x,long double y) { return (y< x); }
friend inline bool operator >=(const TLargeFloat& x,long double y) { return !(x< y); }
friend inline bool operator <=(const TLargeFloat& x,long double y) { return !(x> y); }
friend inline bool operator !=(long double x,const TLargeFloat& y) { return !(x== y); }
friend inline bool operator > (long double x,const TLargeFloat& y) { return (y< x); }
friend inline bool operator >=(long double x,const TLargeFloat& y) { return !(x< y); }
friend inline bool operator <=(long double x,const TLargeFloat& y) { return !(x> y); }
friend inline const TLargeFloat abs(const TLargeFloat& x) { TLargeFloat result(x); result.Abs(); return result; }//绝对值,|x|
friend inline const TLargeFloat sqrt(const TLargeFloat& x) { TLargeFloat result(x); result.Sqrt(); return result;} //开方,x^0.5
friend inline const TLargeFloat revsqrt(const TLargeFloat& x) { TLargeFloat result(x); result.RevSqrt(); return result; }//求1/x^0.5;
friend inline const TLargeFloat sqr(const TLargeFloat& x) { TLargeFloat result(x); result.Sqr(); return result; };//平方,x^2
friend inline void swap(TLargeFloat& a,TLargeFloat& b) { a.Swap(b); }//交换值
friend inline std::ostream& operator << (std::ostream& cout, const TLargeFloat& Value) { return cout<< Value.AsString(); }
///
private :
TInt32bit m_Sign; //符号位 正:1, 负:-1, 零: 0
TExpInt m_Exponent; //保存10为底的指数
TArray m_Digits; //小数部分 排列顺序是TArray[0]为第一个小数位(em10Power个10进制位),依此类推；取值范围[0--(emBase-1)]
private :
void Canonicity();//规格化 转化值到合法格式
void fToLargeFloat(long double fValue);//内部使用 浮点数转化为 TLargeFloat,并采用默认精度
void iToLargeFloat(TMaxInt iValue);//内部使用 整数转化为 TLargeFloat,并采用默认精度
void sToLargeFloat(const std::string& strValue);//内部使用 字符串转化为 TLargeFloat
long Compare(const SelfType& Value) const;//比较两个数；(*this)>Value 返回1，小于返回-1，相等返回0
void Abs_Add(const SelfType& Value);//绝对值加 x:=|x|+|y|;
void Abs_Sub_Abs(const SelfType& Value);//绝对值减的绝对值x:=| |x|-|y| |;
public :
void Chs();//求负
void Abs();//绝对值
void MulInt(TMaxInt iValue);//乘以一个整数；
void DivInt(TMaxInt iValue);//除以一个整数；
void Rev();//求倒数
void RevSqrt();//求1/x^0.5;
inline void Sqrt() { SelfType x(*this); x.RevSqrt(); (*this)*=x; } //求x^0.5;
inline void Sqr() { (*this)*=(*this); };//平方,x^2
};
//单元测试
void LargeFloat_UnitTest();
#endif // _TLARGE_FLOAT_H__INCLUDED_
// TLargeFloat.h
/// //
// TLargeFloat.h: interface for the TLargeFloat class.
// 超高精度浮点数类TLargeFloat
// 2004.03.28 by [email protected]
//
// Update 2004.03.31 by HouSisong
// ......
// Update 2007.11.29-12.20 by HouSisong 重构一遍,速度加快很多，我用它计算了上亿位的PI值:)
#ifndef _TLARGE_FLOAT_H__INCLUDED_
#define _TLARGE_FLOAT_H__INCLUDED_
#include <vector>
#include <sstream>
#include <string>
#include <Exception>
#include <limits>
class TLargeFloat;//超高精度浮点数类TLargeFloat
class TLargeFloatException;// 超高精度浮点数异常类
// 改进方向：
// 1.强力优化ArrayMUL数组乘运算(当前实现了二分法和FFT算法)：
// a.将实数按齐偶作为复数进行傅立叶变换的算法实现，加快乘法速度
// b.实现混合基的傅立叶变换，加快乘法速度
// c.考虑用x87的10byte浮点数实现FFT以减小误差从而增大FFT能够计算的最大位数限制
// d.用SSE2等优化快速复利叶变换，加快乘法速度
// e.或者将傅立叶变换替换为数论变换的实现(使用整数)
// 2.内部使用8位(或9位)十进制来实现，节约内存；或者2进制的底数(这样的话，输出函数就会麻烦一些了)
// 3.添加新的基本运算函数，如：指数运算power、对数运算log、三角函数sin,cos,tan等
// 注意：如果浮点数与TLargeFloat进行混合运算, 可能会产生误差(有效位数会受到浮点数影响)；
// 整数 或 为可表示整数的浮点数 参与运算不会产生误差；
// 对于很大的整数或者有小数位的浮点数，建议用字符串的形式转换为超高精度浮点数(不会引入误差)
//void ArrayMUL(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize);// 数组乘, 需要优化的首要目标
//超高精度浮点数异常类 //TLargeFloat运算中出现错误的时候会抛出该类型的异常
class TLargeFloatException :public std::runtime_error
{
public :
TLargeFloatException(const char * Error_Msg) :runtime_error(Error_Msg){}
virtual ~TLargeFloatException() throw () {}
};
// TCatchIntError只是对整数类型TInt进行的一层包装
// 超高精度浮点数类的指数运算时使用
// 设计TCatchIntError是为了当整数运算超出值域的时候，抛出异常
//template<要包装的整数类型，超界时抛出的异常类型，TInt最小值，TInt最大值>
template <typename TInt,typename TException,TInt MinValue,TInt MaxValue>
class TCatchIntError
{
private :
typedef TCatchIntError<TInt,TException,MinValue,MaxValue> SelfType;
TInt m_Int;
inline SelfType& inc(const TInt& uValue)
{
if ( (uValue<0)||(uValue>MaxValue)||(MaxValue-uValue< m_Int) )
throw TException("ERROR:TCatchIntError::inc(); " );
m_Int+= uValue;
return (*this );
}
inline SelfType& dec(const TInt& uValue)
{
if ( (uValue<0)||(uValue>MaxValue)||(MinValue+uValue> m_Int) )
throw TException("ERROR:TCatchIntError::dec()" );
m_Int-= uValue;
return (*this );
}
inline SelfType& mul(const TInt& iValue)
{
if (iValue==0 )
m_Int=0 ;
else
{
TInt tmp =m_Int* iValue;
if ( (iValue<MinValue)||(iValue>MaxValue)||(tmp<MinValue)||(tmp>MaxValue)||((tmp/iValue)!= m_Int) )
throw TException("ERROR:TCatchIntError::mul(); " );
m_Int= tmp;
}
return (*this );
}
public :
inline TCatchIntError() :m_Int(0 ){ }
inline TCatchIntError(const TInt& Value) :m_Int(0) { (*this)+= Value;}
inline TCatchIntError(const SelfType& Value) :m_Int(0) { (*this)+= (Value.m_Int); }
inline const TInt& AsInt() const { return m_Int; }
inline SelfType& operator +=(const TInt& Value) //throw(TLargeFloatException)
{ if (Value<0) return dec(- Value);
else return inc(Value); }
inline SelfType& operator -=(const TInt& Value) //throw(TLargeFloatException)
{ if (Value<0) return inc(- Value);
else return dec(Value); }
inline SelfType& operator *=(const TInt& Value) //throw(TLargeFloatException)
{ return mul(Value); }
inline SelfType& operator +=(const SelfType& Value) { return (*this)+=(Value.m_Int); }//throw(TLargeFloatException)
inline SelfType& operator -=(const SelfType& Value) { return (*this)-=(Value.m_Int); }//throw(TLargeFloatException)
inline SelfType& operator *=(const SelfType& Value) { return (*this)*=(Value.m_Int); }//throw(TLargeFloatException)
};
// 指数部分使用的整数类型 填写编译器支持的较大的整数类型
//typedef __int64 TMaxInt; // type long long TMaxInt;
// const TMaxInt TMaxInt_MAX_VALUE = TMaxInt(9223372036854775807);
//const TMaxInt TMaxInt_MIN_VALUE = - TMaxInt_MAX_VALUE;
typedef long TMaxInt;
const TMaxInt TMaxInt_MAX_VALUE = 2147483647 ;
const TMaxInt TMaxInt_MIN_VALUE = - TMaxInt_MAX_VALUE;
//小数部分使用的整数类型 32bit位的整数类型
typedef long TInt32bit;
const TInt32bit TInt32bit_MAX_VALUE = 2147483647 ;
const TInt32bit TInt32bit_MIN_VALUE = - TInt32bit_MAX_VALUE;
//超高精度浮点数类
class TLargeFloat
{
public :
//一些常量和类型定义
typedef std::vector<TInt32bit> TArray;//小数位使用的数组类型
enum { em10Power =4, //数组为10000进制，
emBase =10000, //数组的一个元素对应4个十进制位
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 TLargeFloatException TException;
typedef TCatchIntError<TMaxInt,TException,TMaxInt_MIN_VALUE,TMaxInt_MAX_VALUE> TExpInt;//指数类型
typedef TLargeFloat SelfType;
public :
class TDigits//TDigits用来设置TLargeFloat的精度;//增加这个类是为了避免TLargeFloat的构造函数的可能误用
{
private :
unsigned long m_DigitsArraySize;
public :
explicit TDigits(const long uiDigitsLength)
{ if (uiDigitsLength<=0) throw TException("ERROR:TLargeFloat::TDigits()" );
m_DigitsArraySize=(uiDigitsLength+em10Power-1)/ em10Power; }
inline const unsigned long GetDigitsArraySize() const { return m_DigitsArraySize; }
};
TLargeFloat(const SelfType& Value);
explicit TLargeFloat(const long double DefultValue);//默认浮点精度 //注意：转换可能存在小的误差
explicit TLargeFloat(const long double DefultValue,const TDigits& DigitsLength);//TDigits 十进制有效位数 //注意：转换可能存在小的误差
explicit TLargeFloat(const char* strValue);//使用字符串本身的精度
explicit TLargeFloat(const char* strValue,const TDigits& DigitsLength);
explicit TLargeFloat(const std::string& strValue);
explicit TLargeFloat(const std::string& strValue,const TDigits& DigitsLength);
long double AsFloat() const;//转化为浮点数
std::string AsString() const;//转换为字符串
void SetDigitsLength(const TDigits& DigitsLength); //重新设置10进制有效位数
inline void SetDigitsLength(const long uiDigitsLength) { SetDigitsLength(TDigits(uiDigitsLength)); }
unsigned long GetDigitsLength() const;//返回当前的10进制有效位数
void Swap(SelfType& Value);//交换值
void Zero(); //设置为0
inline void StrToLargeFloat(const std::string& strValue) { sToLargeFloat(strValue); }
inline void StrToLargeFloat(const char* strValue) { sToLargeFloat(std::string (strValue)); }
SelfType& operator = (const SelfType& Value);
SelfType& operator = (long double fValue); //注意：转换可能存在小的误差
inline const SelfType operator - () const { SelfType temp(*this); temp.Chs(); return temp; }//求负
inline const SelfType& operator + () const { return (*this); }//求正
SelfType & operator += (const SelfType& Value);
SelfType& operator -= (const SelfType& Value);
inline SelfType& operator += (long double fValue) { return (*this)+= TLargeFloat(fValue); }
inline SelfType& operator -= (long double fValue) { return (*this)-= TLargeFloat(fValue); }
friend inline const TLargeFloat operator + (const TLargeFloat& x,const TLargeFloat& y) { TLargeFloat temp(x); return temp+= y; }
friend inline const TLargeFloat operator - (const TLargeFloat& x,const TLargeFloat& y) { TLargeFloat temp(x); return temp-= y; }
friend inline const TLargeFloat operator + (const TLargeFloat& x,long double y) { TLargeFloat temp(x); return temp+= y; }
friend inline const TLargeFloat operator - (const TLargeFloat& x,long double y) { TLargeFloat temp(x); return temp-= y; }
friend inline const TLargeFloat operator + (long double x,const TLargeFloat& y) { return y+ x; }
friend inline const TLargeFloat operator - (long double x,const TLargeFloat& y) { return -(y- x); }
SelfType& operator *= (long double fValue);
SelfType& operator *= (const SelfType& Value);
friend inline const TLargeFloat operator * (const TLargeFloat& x,const TLargeFloat& y) { TLargeFloat temp(x); if (&x!=&y) return temp*=y; else { temp.Sqr(); return temp; } }
friend inline const TLargeFloat operator * (const TLargeFloat& x,long double y) {TLargeFloat temp(x); return temp*= y;}
friend inline const TLargeFloat operator * (long double x,const TLargeFloat& y) { return y* x; }
SelfType& operator /= (long double fValue);
SelfType& operator /= (const SelfType& Value);
friend inline const TLargeFloat operator / (const TLargeFloat& x,const TLargeFloat& y) { TLargeFloat temp(x); return temp/= y; }
friend inline const TLargeFloat operator / (const TLargeFloat& x,long double y) { TLargeFloat temp(x); return temp/= y; }
friend inline const TLargeFloat operator / (long double x,const TLargeFloat& y) { TLargeFloat temp(y); temp.Rev(); return temp*= x; }
friend inline bool operator ==(const TLargeFloat& x,const TLargeFloat& y) { return (x.Compare(y)==0 ); }
friend inline bool operator < (const TLargeFloat& x,const TLargeFloat& y) { return (x.Compare(y)<0 ); }
friend inline bool operator ==(const TLargeFloat& x,long double y) { return (x== TLargeFloat(y)); }
friend inline bool operator < (const TLargeFloat& x,long double y) { return (x< TLargeFloat(y)); }
friend inline bool operator ==(long double x,const TLargeFloat& y) { return (y== x); }
friend inline bool operator < (long double x,const TLargeFloat& y) { return (y> x); }
friend inline bool operator !=(const TLargeFloat& x,const TLargeFloat& y) { return !(x== y); }
friend inline bool operator > (const TLargeFloat& x,const TLargeFloat& y) { return (y< x); }
friend inline bool operator >=(const TLargeFloat& x,const TLargeFloat& y) { return !(x< y); }
friend inline bool operator <=(const TLargeFloat& x,const TLargeFloat& y) { return !(x> y); }
friend inline bool operator !=(const TLargeFloat& x,long double y) { return !(x== y); }
friend inline bool operator > (const TLargeFloat& x,long double y) { return (y< x); }
friend inline bool operator >=(const TLargeFloat& x,long double y) { return !(x< y); }
friend inline bool operator <=(const TLargeFloat& x,long double y) { return !(x> y); }
friend inline bool operator !=(long double x,const TLargeFloat& y) { return !(x== y); }
friend inline bool operator > (long double x,const TLargeFloat& y) { return (y< x); }
friend inline bool operator >=(long double x,const TLargeFloat& y) { return !(x< y); }
friend inline bool operator <=(long double x,const TLargeFloat& y) { return !(x> y); }
friend inline const TLargeFloat abs(const TLargeFloat& x) { TLargeFloat result(x); result.Abs(); return result; }//绝对值,|x|
friend inline const TLargeFloat sqrt(const TLargeFloat& x) { TLargeFloat result(x); result.Sqrt(); return result;} //开方,x^0.5
friend inline const TLargeFloat revsqrt(const TLargeFloat& x) { TLargeFloat result(x); result.RevSqrt(); return result; }//求1/x^0.5;
friend inline const TLargeFloat sqr(const TLargeFloat& x) { TLargeFloat result(x); result.Sqr(); return result; };//平方,x^2
friend inline void swap(TLargeFloat& a,TLargeFloat& b) { a.Swap(b); }//交换值
friend inline std::ostream& operator << (std::ostream& cout, const TLargeFloat& Value) { return cout<< Value.AsString(); }
///
private :
TInt32bit m_Sign; //符号位 正:1, 负:-1, 零: 0
TExpInt m_Exponent; //保存10为底的指数
TArray m_Digits; //小数部分 排列顺序是TArray[0]为第一个小数位(em10Power个10进制位),依此类推；取值范围[0--(emBase-1)]
private :
void Canonicity();//规格化 转化值到合法格式
void fToLargeFloat(long double fValue);//内部使用 浮点数转化为 TLargeFloat,并采用默认精度
void iToLargeFloat(TMaxInt iValue);//内部使用 整数转化为 TLargeFloat,并采用默认精度
void sToLargeFloat(const std::string& strValue);//内部使用 字符串转化为 TLargeFloat
long Compare(const SelfType& Value) const;//比较两个数；(*this)>Value 返回1，小于返回-1，相等返回0
void Abs_Add(const SelfType& Value);//绝对值加 x:=|x|+|y|;
void Abs_Sub_Abs(const SelfType& Value);//绝对值减的绝对值x:=| |x|-|y| |;
public :
void Chs();//求负
void Abs();//绝对值
void MulInt(TMaxInt iValue);//乘以一个整数；
void DivInt(TMaxInt iValue);//除以一个整数；
void Rev();//求倒数
void RevSqrt();//求1/x^0.5;
inline void Sqrt() { SelfType x(*this); x.RevSqrt(); (*this)*=x; } //求x^0.5;
inline void Sqr() { (*this)*=(*this); };//平方,x^2
};
//单元测试
void LargeFloat_UnitTest();
#endif // _TLARGE_FLOAT_H__INCLUDED_
// TLargeFloat.h
/// //
类的实现文件:TLargeFloat.cpp
/////
// TLargeFloat.cpp: implementation of the TLargeFloat class.
// 超高精度浮点数类TLargeFloat
//
#include "TLargeFloat.h"
#include <algorithm>
//#include "assert.h"
#include <math.h>
// #define MyDebugAssert(b) { if (!(b)) __asm{ int 3 } }
//用以控制运算精度的工具
class TDigitsLengthCtrl
{
private :
std::vector<TLargeFloat*> m_list;
public :
inline void add_to_ctrl(TLargeFloat* var) { m_list.push_back(var); }
void SetDigitsLength(const long uiDigitsLength)
{
long size= m_list.size();
for (long i=0;i<size;++ i)
m_list[i]-> SetDigitsLength(uiDigitsLength);
}
};
//自动精度控制
class TDigitsLengthAutoCtrl:public TDigitsLengthCtrl
{
private :
std::vector<long> m_DigitsLengthList;
long step;
public :
TDigitsLengthAutoCtrl(long DigitsMul,long DigitsLength0,long MaxDigitsLength)//(收敛系数,初始精度,最终需要精度)
{
// MyDebugAssert(DigitsLength0>0);
//得到最佳的精度梯度
long curDigitsLength= MaxDigitsLength;
while (curDigitsLength> DigitsLength0)
{
m_DigitsLengthList.push_back(curDigitsLength);
if ((DigitsLength0<=1)&&(curDigitsLength==1)) break ;
curDigitsLength=(curDigitsLength+DigitsMul-1)/ DigitsMul;
}
step=get_runcount()-1 ;
}
inline long get_runcount() { return m_DigitsLengthList.size(); }
inline void SetNextDigits()
{
//MyDebugAssert(step>=0);
long DigitsLength= m_DigitsLengthList[step];
if (step>0 )
DigitsLength+=4 ;
SetDigitsLength(DigitsLength);
-- step;
if (step<0) step=0 ;
}
};
/
void TLargeFloat_CtrlExponent(TLargeFloat::TArray& v,TMaxInt iMoveRightCount)
{
//iMoveCountBig 有可能存不下 但现在的体系下因右移超过值域比较难
long iMoveCountBig=(long)(iMoveRightCount/ TLargeFloat::em10Power);
long iMoveCountSmall=(long)(iMoveRightCount% TLargeFloat::em10Power);
//大的右移
if (iMoveCountBig>0 )
{
for (long i=v.size()-1;i>=iMoveCountBig;-- i)
v[i]=v[i- iMoveCountBig];
for (long j=0;j<iMoveCountBig;++ j)
v[j]=0 ;
}
//小的右移
if (iMoveCountSmall>0 )
{
TInt32bit iDiv=1 ;
for (long j=0;j<iMoveCountSmall;++j) iDiv*=10 ;
long v_size= v.size();
for (long i=iMoveCountBig;i<v_size-1;++ i)
{
v[i+1]+=(v[i]%iDiv)* TLargeFloat::emBase;
v[i]/= iDiv;
}
if (v_size>=1 )
v[v_size-1]/= iDiv;
}
}
void TLargeFloat_ArrayAddTestLast(TInt32bit* x,long xsize)
{
for (long i=xsize-1;i>0;-- i)
{
if (x[i]>=TLargeFloat::emBase)//进位
{
++x[i-1 ];
x[i]-= TLargeFloat::emBase;
}
else
break ;
}
}
void TLargeFloat_ArrayAdd(TInt32bit* result,long rsize,const TInt32bit* y,long ysize)
{
// MyDebugAssert(rsize>=ysize);
//MyDebugAssert(ysize>0);
TInt32bit* ri=&result[rsize- ysize];
long i;
for (i=ysize-1;i>0;-- i)
{
TInt32bit r=ri[i]+ y[i];
if (r>=TLargeFloat::emBase)//进位
{
++ri[i-1 ];
r-= TLargeFloat::emBase;
}
ri[i]= r;
}
ri[0]+=y[0 ];
TLargeFloat_ArrayAddTestLast(result,rsize-ysize+1 );
}
void TLargeFloat_ArraySub(TInt32bit* result,long rsize,const TInt32bit* y,long ysize)
{
// MyDebugAssert(rsize>=ysize);
//MyDebugAssert(ysize>0);
TInt32bit* ri=&result[rsize- ysize];
long i;
for (i=ysize-1;i>0;-- i)
{
TInt32bit r=ri[i]- y[i];
if (r<0)//借位
{
--ri[i-1 ];
r+= TLargeFloat::emBase;
}
ri[i]= r;
}
ri[0]-=y[0 ];
for (i=rsize-ysize;i>0;-- i)
{
if (result[i]<0)//借位
{
--result[i-1 ];
result[i]+= TLargeFloat::emBase;
}
else
break ;
}
}
TInt32bit _inti_csMaxMuliValue()
{
double rb=1; double mb=1 ;
for (long i=0;i<100/TLargeFloat::em10Power;++ i)
{
mb*=(1.0/ TLargeFloat::emBase);
rb+= mb;
}
return (TInt32bit)( TInt32bit_MAX_VALUE*(1.0/(TLargeFloat::emBase-1))/rb ) -1 ;
}
//不超界所允许的乘数值M满足: (emBase-1)*M + (emBase-1)*M/B + (emBase-1)*M/B^2 + (emBase-1)*M/B^3 ... <=TInt32bit_MAX_VALUE
static const TInt32bit csMaxMuliValue= _inti_csMaxMuliValue();
static const TInt32bit csMaxMulAddValue = csMaxMuliValue - (TLargeFloat::emBase-1 );
void TLargeFloat_ArrayMUL_ExE(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize)
{
//N*N复杂度的简单乘法实现
for (long k=0;k<rminsize;++k) result[k]=0 ;
while ((ysize>0)&&(y[0]==0)) { --ysize; ++y; ++result; -- rminsize;}
//while ((xsize>0)&&(x[0]==0)) { --xsize; ++x; ++result; --rminsize;}
while ((ysize>0)&&(y[ysize-1]==0)) { -- ysize; }
//while ((xsize>0)&&(x[xsize-1]==0)) { --xsize; }
long add_sum=0 ;
for (long i=0;i<xsize;++ i)
{
long xi= x[i];
if (xi>0 )
{
TInt32bit* resulti=&result[i+1 ];
long y_limit=std::min(rminsize-1- i,ysize);
for (long j=0;j<y_limit;++ j)
{
resulti[j]+=(xi* y[j]);
}
add_sum+= xi;
if (add_sum> csMaxMulAddValue)
{
for (long k=i+y_limit;k>0;-- k)
{
TInt32bit v= result[k];
if (v>= TLargeFloat::emBase)
{
result[k-1]+=v/ TLargeFloat::emBase;
result[k]= v% TLargeFloat::emBase;
}
}
add_sum=0 ;
}
}
}
if (add_sum>0 )
{
for (long k=rminsize-1;k>0;-- k)
{
TInt32bit v= result[k];
if (v>= TLargeFloat::emBase)
{
result[k-1]+=v/ TLargeFloat::emBase;
result[k]= v% TLargeFloat::emBase;
}
}
}
}
//数组乘法 核心
void ArrayMUL(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize);
void ArrayMUL_Dichotomy(TInt32bit* result,long rminsize,const TInt32bit* x,const TInt32bit* y,long MulSize)
{
// 二分法的乘法实现
// x*y=(a*E+b)*(c*E+d)=(E*E-E)*ac + E*(a+b)*(c+d) -(E-1)*bd
// temp_a_add_b=a+b;
// temp_c_add_d=c+d;
// result=E*temp_a_add_b*temp_c_add_d;
// temp_ac=a*c;
// result+=E*E*temp_ac;
// result-=E*temp_ac;
// temp_bd=b*d;
// result+=temp_bd;
// result-=E*temp_bd;
//
long i;
const long E=((MulSize+1)>>1 );
//if (tmpData+2*(E+1)>end_tmpData) __asm int 3
const long acSize=MulSize- E;
const long acErrorSize=E- acSize;
const TInt32bit* a= x;
const TInt32bit* b=& x[acSize];
const TInt32bit* c= y;
const TInt32bit* d=& y[acSize];
TLargeFloat::TArray _tmpData((E+1)*2 );
TInt32bit* tmpData=&_tmpData[0 ];
TInt32bit* temp_a_add_b=&tmpData[0 ];
TInt32bit* temp_c_add_d=&tmpData[(E+1 )];
temp_a_add_b[0]=0 ;
for (i=0;i<E;++i) temp_a_add_b[i+1]= b[i];
TLargeFloat_ArrayAdd(temp_a_add_b,1+E,a,E- acErrorSize);
temp_c_add_d[0]=0 ;
for (i=0;i<E;++i) temp_c_add_d[i+1]= d[i];
TLargeFloat_ArrayAdd(temp_c_add_d,1+E,c,E- acErrorSize);
const long abcdPos=(2*MulSize-E-2*(E+1 ));
for (i=0;i<abcdPos;++i) result[i]=0 ;
ArrayMUL(&result[abcdPos],std::min(rminsize-abcdPos,2*(E+1)),temp_a_add_b,E+1,temp_c_add_d,E+1 );
for (i=abcdPos+2*(E+1);i<rminsize;++i) result[i]=0 ;
TInt32bit* temp_ac=&tmpData[0 ];
const long acminsize=std::min(rminsize,acSize*2 );
ArrayMUL(temp_ac,acminsize,a,acSize,c,acSize);
TLargeFloat_ArrayAdd(result,acminsize,temp_ac,acminsize);
long sub_ac_size=acSize*2 ;
if (E+sub_ac_size>rminsize) sub_ac_size=rminsize- E;
TLargeFloat_ArraySub(result,E+ sub_ac_size,temp_ac,sub_ac_size);
const long add_bdPos=2*MulSize-2* E;
long sub_bd_size=2* E;
const long sub_bdPos=add_bdPos- E;
if (sub_bdPos+sub_bd_size>rminsize) sub_bd_size=rminsize- sub_bdPos;
if (sub_bd_size>0 )
{
TInt32bit* temp_bd=&tmpData[0 ];
ArrayMUL(temp_bd,sub_bd_size,b,E,d,E);
long add_bd_size=2* E;
if (add_bdPos+add_bd_size>rminsize) add_bd_size=rminsize- add_bdPos;
if (add_bd_size>0 )
TLargeFloat_ArrayAdd(result,add_bdPos+ add_bd_size,temp_bd,add_bd_size);
TLargeFloat_ArraySub(result,sub_bdPos+ sub_bd_size,temp_bd,sub_bd_size);
}
}
void ArrayMUL_DichotomyPart(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize)
{
//二分法的辅助函数
///
//x*y=(a*E+b)*y=a*y*E+b*y;
if (xsize== ysize)
{
ArrayMUL_Dichotomy(result,rminsize,x,y,ysize);
return ;
}
if (xsize< ysize)
{
std::swap(xsize,ysize);
std::swap(x,y);
}
const long E= ysize;
const long asize=xsize- E;
const TInt32bit* a=&x[0 ];
const TInt32bit* b=& x[asize];
ArrayMUL(result,rminsize,a,asize,y,ysize);
for (long i=asize+ysize;i<rminsize;++i) result[i]=0 ;
const long byPos= asize;
if (byPos< rminsize)
{
const long byminsize=rminsize- byPos;
TLargeFloat::TArray tmpData(byminsize);
TInt32bit* tmp_by=&tmpData[0 ];
ArrayMUL_Dichotomy(tmp_by,byminsize,b,y,E);
TLargeFloat_ArrayAdd(result,rminsize,tmp_by,byminsize);
}
}
/
const long csTMaxInt_Digits=(long)(log10((long double)TMaxInt_MAX_VALUE)+1 );
TLargeFloat::TLargeFloat(const SelfType& Value)
:m_Digits(Value.m_Digits)
{
m_Exponent= Value.m_Exponent;
m_Sign= Value.m_Sign;
}
TLargeFloat::TLargeFloat(const long double DefultValue)
:m_Digits(TDigits(emLongDoubleDigits+1).GetDigitsArraySize(),0 )
{
fToLargeFloat(DefultValue);
}
TLargeFloat::TLargeFloat(const long double DefultValue,const TDigits& DigitsLength)
:m_Digits(DigitsLength.GetDigitsArraySize(),0 )
{
fToLargeFloat(DefultValue);
}
TLargeFloat::TLargeFloat(const char* strValue)
:m_Digits(TDigits(csTMaxInt_Digits).GetDigitsArraySize(),0 )
{
sToLargeFloat(std::string (strValue));
}
TLargeFloat::TLargeFloat(const char* strValue,const TDigits& DigitsLength)
:m_Digits(DigitsLength.GetDigitsArraySize(),0 )
{
sToLargeFloat(std::string (strValue));
}
TLargeFloat::TLargeFloat(const std::string& strValue)
:m_Digits(TDigits(csTMaxInt_Digits).GetDigitsArraySize(),0 )
{
sToLargeFloat(strValue);
}
TLargeFloat::TLargeFloat(const std::string& strValue,const TDigits& DigitsLength)
:m_Digits(DigitsLength.GetDigitsArraySize(),0 )
{
sToLargeFloat(strValue);
}
void TLargeFloat::Zero()
{
if (m_Sign==0) return ;
m_Sign=0 ;
m_Exponent=0 ;
long old_size= m_Digits.size();
for (long i=0;i<old_size;++ i)
m_Digits[i]=0 ;
}
void TLargeFloat::Canonicity()
{
// 规格化 小数部分
// 规格化前允许:m_Digits[0]>=emBase 也就是小数部分的值大于等于1.0;
// 规格化前允许:m_Digits[]前面有多个0值 也就是小数部分的值小于0.1;
//规格化后的数满足的条件：小数部分的值 小于1.0，大于等于0.1;
if (m_Sign==0 )
{
return ;
}
long old_size= m_Digits.size();
if (old_size<=0) return; //不可能发生:)
if ( (m_Digits[0]<emBase)&&(m_Digits[0]>=(emBase/10)) ) return ;
//处理右移
while (m_Digits[0]>=emBase)//是否需要右移1
{
m_Exponent+= em10Power;
for (long i=old_size-1;i>=2;-- i)
m_Digits[i]=m_Digits[i-1 ];
if (old_size>=2) m_Digits[1]=m_Digits[0] % emBase;
m_Digits[0]/= emBase;
}
// 考虑左移
//大的左移
long iMoveCountBig= old_size;
for (long i=0;i<old_size;++ i)
{
if (m_Digits[i]!=0 )
{
iMoveCountBig= i;
break ;
}
}
if (iMoveCountBig== old_size)
{
//as Zero();
m_Sign=0 ;
m_Exponent=0 ;
return ;
}
if (iMoveCountBig>0 )
{
m_Exponent-=(iMoveCountBig* em10Power);
for (long j=0;j<old_size-iMoveCountBig;++ j)
m_Digits[j]=m_Digits[j+ iMoveCountBig];
for (long k=old_size-iMoveCountBig;k<old_size;++ k)
m_Digits[k]=0 ;
}
//小的左移
TInt32bit iMoveMul=1 ;
long iMoveCountSmall=0 ;
while (iMoveMul*m_Digits[0]<(emBase/10 ))
{
iMoveMul*=10 ;
++ iMoveCountSmall;
}
if (iMoveCountSmall>0 )
{
m_Exponent-= iMoveCountSmall;
for (long i=old_size-1;i>=0;-- i)
m_Digits[i]*= iMoveMul;
for (long j=old_size-1;j>0;-- j)
{
TInt32bit value= m_Digits[j];
m_Digits[j]=value% emBase;
m_Digits[j-1]+=value/ emBase;
}
}
}
void TLargeFloat::iToLargeFloat(TMaxInt iValue)
{
Zero();
long new_size= TDigits(csTMaxInt_Digits).GetDigitsArraySize();
if ((long)m_Digits.size()< new_size)
m_Digits.resize(new_size,0 );
if (iValue==0 )
return ;
else if (iValue>0 )
m_Sign=1 ;
else
{
m_Sign =-1 ;
iValue=- iValue;
}
//无误差转换
TMaxInt tmp_iValue= iValue;
long n=0 ;
for (;tmp_iValue!=0;++ n)
tmp_iValue/= emBase;
m_Exponent=n* em10Power;
for (long i=0;i<n;++ i)
{
m_Digits[n-1-i]=(TInt32bit)(iValue% emBase);
iValue/= emBase;
}
Canonicity();
}
void TLargeFloat::fToLargeFloat(long double fValue)
{
TMaxInt iValue= (TMaxInt)fValue;
if (iValue== fValue)
{
iToLargeFloat(iValue);
return ;
}
Zero();
long new_size=TDigits(emLongDoubleDigits+1 ).GetDigitsArraySize();
if ((long)m_Digits.size()< new_size)
m_Digits.resize(new_size,0 );
if (fValue==0 )
return ;
else if (fValue>0 )
m_Sign=1 ;
else
{
m_Sign =-1 ;
fValue=- fValue;
}
m_Exponent=(long )floor(log10(fValue));
fValue/=pow(10.0,(long )m_Exponent.AsInt());
long size= m_Digits.size();
for (long i=0;i<size;++i)//得到小数位
{
if (fValue<=0) break ;
fValue*= emBase;
TInt32bit iValue= (TInt32bit)floor(fValue);
fValue-= iValue;
m_Digits[i]= iValue;
}
Canonicity();
}
void TLargeFloat::Swap(SelfType& Value)
{
if (this==&Value) return ;
m_Digits.swap(Value.m_Digits);
std::swap(m_Sign,Value.m_Sign);
std::swap(m_Exponent,Value.m_Exponent);
}
void TLargeFloat::Chs()
{
m_Sign*=(-1 );
}
void TLargeFloat::Abs()
{
if (m_Sign!=0) m_Sign=1 ;
}
unsigned long TLargeFloat::GetDigitsLength() const
{
return m_Digits.size()* em10Power;
}
void TLargeFloat::SetDigitsLength(const TDigits& DigitsLength)
{
m_Digits.resize(DigitsLength.GetDigitsArraySize(),0 );
}
TLargeFloat::SelfType& TLargeFloat::operator = (const SelfType& Value)
{
if (this==&Value) return *this ;
m_Digits= Value.m_Digits;
m_Sign= Value.m_Sign;
m_Exponent= Value.m_Exponent;
return *this ;
}
TLargeFloat::SelfType& TLargeFloat::operator = (long double fValue)
{
fToLargeFloat(fValue);
return *this ;
}
long double TLargeFloat::AsFloat() const
{
if ( ((m_Exponent.AsInt())>= emLongDoubleMaxExponent)
||((m_Exponent.AsInt())<= emLongDoubleMinExponent) )
{
throw TException("ERROR:TLargeFloat::AsFloat()" );
}
if (m_Sign==0) return 0 ;
long double result=m_Sign*pow((long double)10.0,(long double )m_Exponent.AsInt());
long double r=1 ;
long double Sum=0 ;
long old_size= m_Digits.size();
for (long i=0;i<old_size;++i)//得到小数位
{
r/=emBase;//r*=(1.0/emBase);
if (r==0) break ;
Sum+=(m_Digits[i]* r);
}
return result* Sum;
}
std::string TLargeFloat::AsString() const
{
if (m_Sign==0 )
return "0" ;
//计算需要的字符串空间大小
long str_length=2+m_Digits.size()* em10Power;
if (m_Sign<0) ++str_length; //负号
TMaxInt EpValue = m_Exponent.AsInt();
long UEP_StrLength=0 ;
if (EpValue!=0 )
{
++ str_length;
if (EpValue<0 )
{
EpValue=- EpValue;
++ str_length;
}
UEP_StrLength=0 ;
while (EpValue>0 )
{
EpValue/=10 ;
++ UEP_StrLength;
}
str_length+= UEP_StrLength;
}
std::string result(str_length,' ' );
std::string::value_type* pStr=&result[0 ];
//输出字符串
if (m_Sign<0) { *pStr='-'; ++ pStr; }
*pStr='0'; ++pStr; *pStr='.'; ++ pStr;
long dgsize= m_Digits.size();
for (long i=0;i<dgsize;++ i)
{
TInt32bit Value= m_Digits[i];
for (long d=0;d<em10Power;++ d)
{
pStr[em10Power-1-d]=(char)('0'+(Value%10 ));
Value/=10 ;
}
pStr+= em10Power;
}
EpValue= m_Exponent.AsInt();
if (EpValue!=0 )
{
*pStr='e'; ++ pStr;
if (EpValue<0 )
{
EpValue=- EpValue;
*pStr='-'; ++ pStr;
}
for (long i=0;i<UEP_StrLength;++ i)
{
pStr[UEP_StrLength-1-i]=(char)('0'+(EpValue%10 ));
EpValue/=10 ;
}
pStr+= UEP_StrLength;
}
return result;
}
template<class PChar>
PChar sToLargeFloat_GetCharIntEnd(PChar int_begin,PChar str_end)
{
long int_count=0 ;
for (PChar i=int_begin;i<str_end;++ i)
{
if ( ('0'<=(*i)) && ((*i)<='9' ) )
++ int_count;
else
break ;
}
return & int_begin[int_count];
}
inline void sToLargeFloat_setAChar(TLargeFloat::TArray& Digits,long set_index,char aChar)
{
unsigned long Value=aChar-'0' ;
long e10Power_count=TLargeFloat::em10Power-1-(set_index% TLargeFloat::em10Power);
for (long i=0;i<e10Power_count;++ i)
Value*=10 ;
Digits[set_index/TLargeFloat::em10Power]+= Value;
}
void TLargeFloat::sToLargeFloat(const std::string& strValue)
{
if (strValue.size()<=0 )
{
this-> Zero();
return ;
}
typedef const std::string::value_type* PChar;
PChar pstr_begin= strValue.c_str();
PChar pstr_end=& pstr_begin[strValue.size()];
//str as: [+|-][0..9][.][0..9][E|e][+|-][0..9]
bool is_have_sign=false ;
long sign=1 ;
bool is_have_int=false ;
PChar int_begin=0; PChar int_end=0 ;
bool is_have_dot=false ;
bool is_have_digits=false ;
PChar digits_begin=0; PChar digits_end=0 ;
bool is_have_ep=false ;
bool is_have_ep_sign=false ;
long ep_sign=1 ;
bool is_have_ep_int=false ;
PChar ep_int_begin=0; PChar ep_int_end=0 ;
//处理正负号
if ((*pstr_begin)=='-' )
{
sign = -1 ;
is_have_sign=true ;
++ pstr_begin;
}
else if ((*pstr_begin)=='+' )
{
is_have_sign=true ;
++ pstr_begin;
}
//处理前面的整数部分
int_begin= pstr_begin;
int_end= sToLargeFloat_GetCharIntEnd(int_begin,pstr_end);
is_have_int=(int_begin!= int_end);
if ((int_end-int_begin>=2)&&((*int_begin)=='0')) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 0"); //'0?'数字表示错误
pstr_begin= int_end;
if (((*pstr_begin)!='.')&&(!is_have_int)) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 1"); // 没有任何数字
//处理小数部分
if ((*pstr_begin)=='.' )
{
is_have_dot=true ;
++ pstr_begin;
digits_begin= pstr_begin;
digits_end= sToLargeFloat_GetCharIntEnd(digits_begin,pstr_end);
is_have_digits=(digits_begin!= digits_end);
if ((!is_have_digits)&&(!is_have_int)) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 2"); //没有任何数字
pstr_begin= digits_end;
}
//处理指数部分
if ( ((*pstr_begin)=='e')||((*pstr_begin)=='E' ) )
{
is_have_ep=true ;
++ pstr_begin;
//处理指数的正负号
if ((*pstr_begin)=='-' )
{
ep_sign = -1 ;
is_have_ep_sign=true ;
++ pstr_begin;
}
else if((*pstr_begin)=='+' )
{
is_have_ep_sign=true ;
++ pstr_begin;
}
//处理指数中的整数
ep_int_begin= pstr_begin;
ep_int_end= sToLargeFloat_GetCharIntEnd(ep_int_begin,pstr_end);
is_have_ep_int=(ep_int_begin!= ep_int_end);
if ((ep_int_end-ep_int_begin>=2)&&((*ep_int_begin)=='0')) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 3"); //'0?'数字表示错误
pstr_begin= ep_int_end;
if (!is_have_ep_int) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 4"); //指数没有数字
}
if (pstr_begin!=pstr_end) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 5"); //未预料的字符
//
//实际的类型转换
this-> Zero();
this->m_Sign= sign;
this->m_Exponent=(int_end- int_begin);
long need_digits_count=(int_end-int_begin)+(digits_end- digits_begin);
if ((long)this->GetDigitsLength()< need_digits_count)
this-> SetDigitsLength(need_digits_count);
long set_index=0 ;
PChar set_begin= int_begin;
for (;set_begin<int_end;++set_begin,++ set_index)
sToLargeFloat_setAChar(this->m_Digits,set_index,* set_begin);
set_begin= digits_begin;
for (;set_begin<digits_end;++set_begin,++ set_index)
sToLargeFloat_setAChar(this->m_Digits,set_index,* set_begin);
if (is_have_ep)
{
TExpInt ep=0 ;
for (PChar set_begin=ep_int_begin;set_begin<ep_int_end;++ set_begin)
{
ep*=10 ;
ep+=((*set_begin)-'0' );
}
ep*= ep_sign;
this->m_Exponent+= ep;
}
Canonicity();
}
long TLargeFloat::Compare(const SelfType& Value) const
{
if (this==&Value) return 0 ;
// (*this)>Value 返回1，小于返回-1，相等返回0
//比较符号
if (m_Sign> Value.m_Sign)
return 1 ;
else if(m_Sign< Value.m_Sign)
return -1 ;
else //m_Sign==Value.m_Sign
{
if(m_Sign==0 )
return 0 ;
}
// m_Sign==Value.m_Sign
//比较指数
if (m_Exponent.AsInt()> Value.m_Exponent.AsInt())
return m_Sign;
else if (m_Exponent.AsInt()< Value.m_Exponent.AsInt())
return - m_Sign;
else//(m_Exponent==Value.m_Exponent)
{
long sizeS= m_Digits.size();
long sizeV= Value.m_Digits.size();
long min_size= std::min(sizeS,sizeV);
for (long i=0;i<min_size;++ i)
{
if (m_Digits[i]!= Value.m_Digits[i])
{
if (m_Digits[i]> Value.m_Digits[i])
return m_Sign;
else //if (m_Digits[i]
return - m_Sign;
}
}
//继续比较 处理尾部
if (sizeS> sizeV)
{
for (long i=sizeV;i<sizeS;++ i)
{
if (m_Digits[i]>0 )
return m_Sign;;
}
}
else if (sizeS< sizeV)
{
for (long i=sizeS;i<sizeV;++ i)
{
if (Value.m_Digits[i]>0 )
return - m_Sign;
}
}
//sizeS==sizeV
return 0 ;
}
}
//
//+ -
TLargeFloat::SelfType & TLargeFloat::operator += (const SelfType& Value)
{
if (Value.m_Sign==0 )
return (*this );
else if (m_Sign==0 )
return (*this)= Value;
else if (m_Sign== Value.m_Sign)
{
TInt32bit oldSign= m_Sign;
Abs_Add(Value);
m_Sign= oldSign;
return *this ;
}
else
return *this-=(- Value);
}
TLargeFloat::SelfType& TLargeFloat::operator -= (const SelfType& Value)
{
if (Value.m_Sign==0 )
return (*this );
else if (m_Sign==0 )
{
(*this)=- Value;
return (*this );
}
else if (m_Sign== Value.m_Sign)
{
long comResult=this-> Compare(Value);
if (comResult==0 )
{
this-> Zero();
}
else
{
Abs_Sub_Abs(Value);
m_Sign = comResult;
}
return *this ;
}
else
return *this+=(- Value);
}
void TLargeFloat::Abs_Add(const SelfType& Value)//绝对值加法
{
this-> Abs();
SelfType Right(Value);
Right.Abs();
//精度一致
if (m_Digits.size()< Right.m_Digits.size())
m_Digits.resize(Right.m_Digits.size(),0 );
else if (m_Digits.size()> Right.m_Digits.size())
Right.m_Digits.resize(m_Digits.size(),0 );
//被加数指数较大就可以了
if (m_Exponent.AsInt()< Right.m_Exponent.AsInt())
this-> Swap(Right);
long size= m_Digits.size();
TMaxInt iMoveRightCount=m_Exponent.AsInt()- Right.m_Exponent.AsInt();
if (iMoveRightCount>=size*(TMaxInt)TLargeFloat::em10Power) return ;
TLargeFloat_CtrlExponent(Right.m_Digits,iMoveRightCount);//对齐小数点
TLargeFloat_ArrayAdd( &m_Digits[0],size,&Right.m_Digits[0 ],size);
if (m_Digits[0]>= emBase)
Canonicity();
}
void TLargeFloat::Abs_Sub_Abs(const SelfType& Value)//绝对值减法
{
this-> Abs();
SelfType Right(Value);
Right.Abs();
long comResult=this-> Compare(Right);
if (comResult==0 )
{
this-> Zero();
return ;
}
else if (comResult<0 )
this-> Swap(Right);
//精度一致
if (m_Digits.size()< Right.m_Digits.size())
m_Digits.resize(Right.m_Digits.size(),0 );
else if (m_Digits.size()> Right.m_Digits.size())
Right.m_Digits.resize(m_Digits.size(),0 );
long size= m_Digits.size();
TMaxInt iMoveRightCount=m_Exponent.AsInt()- Right.m_Exponent.AsInt();
if (iMoveRightCount>=size*(TMaxInt)TLargeFloat::em10Power) return ;
TLargeFloat_CtrlExponent(Right.m_Digits,iMoveRightCount); //对齐小数点
TLargeFloat_ArraySub( &m_Digits[0],size,&Right.m_Digits[0 ],size);
if (m_Digits[0]*10< emBase)
Canonicity();
}
/
// /
//最大的32bit整数除数M满足: (emBase-1)+(M-1)*emBase<=TInt32bit_MAX_VALUE
const TInt32bit csMaxDiviValue=TInt32bit_MAX_VALUE/TLargeFloat::emBase -1 ;
//最大的整数除数M满足: (emBase-1)+(M-1)*emBase<=TMaxInt_MAX_VALUE
const TMaxInt csMaxDiviValueBig=TMaxInt_MAX_VALUE/TLargeFloat::emBase -1 ;
void TLargeFloat::DivInt(TMaxInt iValue)//除以一个整数
{
if (iValue==0 )
throw TException("ERROR:TLargeFloat::DivInt()" );
else if (iValue<0 )
{
iValue=- iValue;
this-> Chs();
//continue
}
if (iValue==1) return ;
if (this->m_Sign==0) return ;
if (iValue> csMaxDiviValueBig)
{
TLargeFloat y(0.0 );
y.iToLargeFloat(iValue);
(*this)/= y;
return ;
}
if (iValue<= csMaxDiviValue)
{
TInt32bit iDiv= (TInt32bit)iValue;
long size= m_Digits.size();
for (long i=0;i<size-1;++ i)
{
m_Digits[i+1]+=(m_Digits[i]%iDiv)* emBase;
m_Digits[i]/= iDiv;
}
if (size>=1 )
m_Digits[size-1]/= iDiv;
}
else
{
TMaxInt iDiv= iValue;
long size= m_Digits.size();
TMaxInt cur_value=m_Digits[0 ];
for (long i=0;i<size-1;++ i)
{
m_Digits[i]=(TInt32bit)(cur_value/ iDiv);
cur_value=m_Digits[i+1]+(cur_value%iDiv)* emBase;
}
if (size>=1 )
m_Digits[size-1]=(TInt32bit)(cur_value/ iDiv);
}
Canonicity();
}
TLargeFloat::SelfType& TLargeFloat::operator /= (long double fValue)
{
TMaxInt iValue= (TMaxInt)fValue;
if (iValue== fValue)
{
DivInt(iValue);
return *this ;
}
else
return (*this)/= TLargeFloat(fValue);
}
TLargeFloat::SelfType& TLargeFloat::operator /= (const SelfType& Value)
{
SelfType x(Value);
x.Rev();//x=1/x;
return (*this)*= x;
}
void TLargeFloat::Rev()//求倒数
{
// 求1/a,
// 则有a=1/x; y=a-1/x;
// 求导得y'=1/x^2;
// 代入牛顿方程 x(n+1)=x(n)-y(x(n))/y'(x(n));
// 有迭代式 x_next=(2-a*x)*x; // 可证明：该公式为2阶收敛公式
// 证明:令x=1/a+dx;
// 则有x_next-1/a=(2-a*(1/a+dx))*(1/a+dx)-1/a
// =(-a)*dx^2
// 证毕.
if (this->m_Sign==0) throw TException("ERROR:TLargeFloat::Rev()" );
TExpInt oldExponent= m_Exponent;
SelfType a(*this );
a.m_Exponent=0 ;
SelfType x(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
x=1.0/a.AsFloat();//初始迭代值
TDigitsLengthAutoCtrl dlCtrl( 2,emLongDoubleDigits-1,(a.m_Digits.size()* TLargeFloat::em10Power));
SelfType ta(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
SelfType temp(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
dlCtrl.add_to_ctrl(& ta);
dlCtrl.add_to_ctrl(& x);
dlCtrl.add_to_ctrl(& temp);
for (long i=0;i<dlCtrl.get_runcount();++ i)
{
ta= a;
dlCtrl.SetNextDigits();
//x=x*2-x*x*ta;
temp= x;
temp*= temp;
temp*= ta;
x*=2 ;
x-= temp;
}
x.m_Exponent-= oldExponent;
this-> Swap(x);
}
/////
//
void TLargeFloat::RevSqrt() //
{
// 求1/a^0.5,
// 则有a=1/x^2; y=a-1/x^2;
// 求导得y'=2/x^3;
// 代入牛顿方程 x(n+1)=x(n)-y(x(n))/y'(x(n));
// 有迭代式 x_next=(3-a*x*x)*x/2; // 可证明：该公式为2阶收敛公式
// 证明:令x=1/a^0.5+dx;
// 则有x_next-1/a^0.5=(3-a*(1/a^0.5+dx)*(1/a^0.5+dx))*(1/a^0.5+dx)/2 - 1/a^0.5
// =-(1.5/a^0.5)*dx^2-0.5*a*dx^3;
// 证毕.
if (this->m_Sign<0) throw TException("ERROR:TLargeFloat::RevSqrt()" );
if (this->m_Sign==0) return ;
SelfType a(*this );
TMaxInt sqrExponent=a.m_Exponent.AsInt()/2 ;
a.m_Exponent-=(sqrExponent*2 );
SelfType x(0.0 ,TDigits(a.GetDigitsLength()));
x=1.0/sqrt(a.AsFloat());//初始迭代值
TDigitsLengthAutoCtrl dlCtrl( 2,emLongDoubleDigits-1,(a.m_Digits.size()* TLargeFloat::em10Power));
SelfType ta(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
SelfType temp(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
dlCtrl.add_to_ctrl(& ta);
dlCtrl.add_to_ctrl(& x);
dlCtrl.add_to_ctrl(& temp);
for (long i=0;i<dlCtrl.get_runcount();++ i)
{
ta= a;
dlCtrl.SetNextDigits();
//x=(3-x*x*ta)*x/2;
temp= x;
temp*= temp;
temp*= ta;
temp.Chs();
temp+=3 ;
x*= temp;
x/=2 ;
}
x.m_Exponent-= sqrExponent;
this-> Swap(x);
}
////
//*
void TLargeFloat::MulInt(TMaxInt iValue)
{
if (this->m_Sign==0) return ;
if (iValue==0 )
{
this-> Zero();
return ;
}
else if (iValue<0 )
{
iValue=- iValue;
this-> Chs();
//continue
}
if (iValue> csMaxMuliValue)
{
TLargeFloat y(0.0 );
y.iToLargeFloat(iValue);
(*this)*= y;
return ;
}
//乘以一个整数
TInt32bit Value= (TInt32bit)iValue;
long size= m_Digits.size();
for (long i=size-1;i>=0;-- i)
{
m_Digits[i]*= Value;
}
for (long j=size-1;j>=1;-- j)
{
if (m_Digits[j]>= emBase)
{
m_Digits[j-1]+=m_Digits[j]/ emBase;
m_Digits[j]%= emBase;
}
}
Canonicity();
}
TLargeFloat::SelfType& TLargeFloat::operator *= (long double fValue)
{
TMaxInt iValue= (TMaxInt)fValue;
if (iValue== fValue)
{
MulInt(iValue);
return *this ;
}
else
{
TLargeFloat temp(fValue);
return (*this)*= temp;
}
}
inline void getBestMulSize(const TInt32bit*& x,long& xsize,const TInt32bit*& y,long& ysize)
{
long bxsize= xsize;
long bysize= ysize;
long i;
for (i=xsize-1;i>=0;-- i)
{
if (x[i]==0 )
-- bxsize;
else
break ;
}
for (i=ysize-1;i>=0;-- i)
{
if (y[i]==0 )
-- bysize;
else
break ;
}
if (bxsize< bysize)
{
std::swap(bxsize,bysize);
std::swap(xsize,ysize);
std::swap(x,y);
}
xsize= bxsize;
const long csABigMulSize=1000 ;
if ( (bysize<csABigMulSize)||(bxsize*2>=bysize*3)||(bxsize> ysize) )
ysize= bysize;
else
ysize= bxsize;
}
TLargeFloat::SelfType& TLargeFloat::operator *= (const SelfType& Value)
{
long xsize= m_Digits.size();
long ysize= Value.m_Digits.size();
if ((m_Sign==0)||(Value.m_Sign==0 ))
{
if (m_Sign!=0 )
this-> Zero();
if (xsize< ysize)
m_Digits.resize(ysize,0 );
return *this ;
}
if (xsize< ysize)
m_Digits.resize(ysize,0 );
long rminsize=std::max(xsize,ysize)+2;//乘法结果需要的位数
const TInt32bit* x=&m_Digits[0 ];
const TInt32bit* y=&Value.m_Digits[0 ];
getBestMulSize(x,xsize,y,ysize);
if (rminsize>xsize+ ysize)
rminsize=xsize+ ysize;
TArray tempArray(rminsize);
ArrayMUL(&tempArray[0 ],rminsize,x,xsize,y,ysize);
xsize= m_Digits.size();
long resultsize= std::min(xsize,rminsize);
long i;
for (i=0;i<resultsize;++i) this->m_Digits[i]= tempArray[i];
for (i=resultsize;i<xsize;++i) this->m_Digits[i]=0 ;
m_Exponent+= Value.m_Exponent;
m_Sign*= Value.m_Sign;
Canonicity();
return *this ;
}
// 快速傅立叶变换实现大整数乘法
// FFT Mul
struct TComplex //复数类型
{
double i;
double r;
};
//初始化
void FFTInitial(TComplex* w,long* lst,const long n)
{
//计算W^i , i in [0--n)
const double PI=3.1415926535897932385 ;
const double seta=2.0*PI/ n;
long i,j;
long n2=n>>2 ;
for (i=0;i<=n2;++ i)
{
w[i].i=sin(seta* i);
w[i].r=cos(seta* i);
}
for (j=(n2+1),i=(n2-1); i>=0 ;--i,++ j)
{
w[j].i= w[i].i;
w[j].r=- w[i].r;
}
//计算排序用数组
lst[0]=0 ;
i=1 ;
long m;
for (n2=n>>1,m=2; n2>0 ;n2=n2>>1,m =m<<1 )
{
for (long j=0;i<m;++i,++ j)
{
lst[i]=lst[j]+ n2;
}
}
}
//快速傅立叶变换
void FFT(TComplex* a,const TComplex* w,const long n)
{
long n2=1 ;
long n1=n >> 1 ;
for (long per=1;per< n;)
{
long m=n2; long j=0; long k= n2;
per<<=1 ;
while (k< n)
{
for (long i2=0; j<m ;++j,++k,i2+= n1)
{
TComplex tmpb= a[j];
double tmp1=a[k].r*w[i2].r-a[k].i* w[i2].i;
double tmp2=a[k].r*w[i2].i+a[k].i* w[i2].r;
a[j].r=tmpb.r+ tmp1;
a[j].i=tmpb.i+ tmp2;
a[k].r=tmpb.r- tmp1;
a[k].i=tmpb.i- tmp2;
}
m+= per;
j+= n2;
k+= n2;
}
n2= per;
n1>>=1 ;
}
}
//反向快速傅立叶变换
void InvFFT(TComplex* a,const TComplex* w,const long n)
{
for (long i=0;i<n;++ i)
a[i].i=- a[i].i;
FFT(a,w,n);
}
void FFT_Convolution(const TComplex* a,TComplex* b,const long n)
{
for (long i=0;i<n;++ i)
{
double br=a[i].r*b[i].r - a[i].i* b[i].i;
b[i].i=a[i].r*b[i].i + a[i].i* b[i].r;
b[i].r= br;
}
}
void FFT_IntArrayCopyToComplexArray(const TInt32bit* ACoef,const long ASize,TComplex* result,const long n,const long* lst)
{
for (long i=0;i<n;++ i)
{
long ai= lst[i];
if (ai< ASize)
result[i].r= ACoef[ai];
else
result[i].r =0.0 ;
result[i].i=0.0 ;
}
}
void FFT_ComplexArrayToIntArray(const TComplex* cmx,const long n,TInt32bit* result,const long rMinSize)
{
const double tmpRevN=1.0/ n;
double FFT_int_base;
TLargeFloat::TArray tempResult;
TInt32bit* dst=0 ;
long dstsize=0 ;
{
FFT_int_base=(long )TLargeFloat::emBase;
dstsize= rMinSize;
dst= result;
}
const double tmpRevFFT_int_base=1.0/ FFT_int_base;
double MaxWorstEr=0 ;
double tmp=0.0 ;
for (long i=std::min(n,dstsize)-1;i>=1;-- i)
{
double num =cmx[i-1].r*tmpRevN+ tmp;
tmp=floor((num+0.499)* tmpRevFFT_int_base);
dst[i]=(TInt32bit)(num+0.499-tmp* FFT_int_base);
double newWorstEr=abs(num-tmp*FFT_int_base-dst[i]);//记录最大误差
if (newWorstEr> MaxWorstEr)
MaxWorstEr= newWorstEr;
}
if (dstsize>0 )
dst[0]=(TInt32bit)(tmp+0.1 );
if (MaxWorstEr>=0.499 )
throw TLargeFloat::TException("ERROR:FFT's FFT_ComplexArrayToIntArray(); "); //误差过大
}
//FFT平方
void SquareFFT(const TInt32bit* ACoef,const long ASize,TInt32bit* CCoef,const long CMinSize)
{
long ansize=ASize+ ASize;
long n=1 ;
while (n<ansize) n<<=1 ;
std::vector<TComplex> _w((n>>1)+1 );
std::vector<long> _lst(n);
TComplex* w=&_w[0 ];
long* lst=&_lst[0 ];
FFTInitial(w,lst,n);
std::vector<TComplex> _a(n);
TComplex* a=&_a[0 ];
FFT_IntArrayCopyToComplexArray(ACoef,ASize,a,n,lst);
FFT(a,w, n);
FFT_Convolution(a,a,n);
std::vector<TComplex> _tmpa(n);
_tmpa.swap(_a);
TComplex* tmpa=&_tmpa[0]; a=&_a[0 ];
for (long i=0;i<n;++i) a[i]= tmpa[lst[i]];
_tmpa.clear();
_lst.clear();
InvFFT(a,w,n);
_w.clear();
FFT_ComplexArrayToIntArray(a,n,CCoef,CMinSize);
}
//FFT乘法
void MulFFT(const TInt32bit* ACoef,const long ASize,const TInt32bit* BCoef,const long BSize,TInt32bit* CCoef,const long CMinSize)
{
long absize=(ASize+ BSize);
long n=1 ;
while (n<absize) n<<=1 ;
std::vector<TComplex> _w((n>>1)+1 );
std::vector<long> _lst(n);
TComplex* w=&_w[0 ];
long* lst=&_lst[0 ];
FFTInitial(w,lst,n);
std::vector<TComplex> _a(n);
TComplex* a=&_a[0 ];
FFT_IntArrayCopyToComplexArray(ACoef,ASize,a,n,lst);
std::vector<TComplex> _b(n);
TComplex* b=&_b[0 ];
FFT_IntArrayCopyToComplexArray(BCoef,BSize,b,n,lst);
FFT(b,w, n);
FFT(a,w, n);
FFT_Convolution(a,b,n);
for (long i=0;i<n;++i) a[i]= b[lst[i]];
_b.clear();
_lst.clear();
InvFFT(a,w,n);
_w.clear();
FFT_ComplexArrayToIntArray(a,n,CCoef,CMinSize);
}
/
const long csBestMUL_ExE_size =1024 / TLargeFloat::em10Power;
const long csBestMUL_Dichotomy_size =4096 / TLargeFloat::em10Power;
const long csBestMul_FFT4Max_size =16777216 / TLargeFloat::em10Power;
void ArrayMUL(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize)
{
if (xsize< ysize)
{
std::swap(xsize,ysize);
std::swap(x,y);
}
if (rminsize< ysize)
{
xsize= rminsize;
ysize= rminsize;
}
if (ysize<=csBestMUL_ExE_size) //
TLargeFloat_ArrayMUL_ExE(result,rminsize,x,xsize,y,ysize);
else if (ysize<= csBestMUL_Dichotomy_size)
ArrayMUL_DichotomyPart(result,rminsize,x,xsize,y,ysize);
else if ((xsize+ysize)<=(csBestMul_FFT4Max_size*2 ))
{
if (x== y)
SquareFFT(x,xsize,result,rminsize);
else
MulFFT(x,xsize,y,ysize,result,rminsize);
}
else
ArrayMUL_DichotomyPart(result,rminsize,x,xsize,y,ysize);
}
void LargeFloat_UnitTest()
{
// 单元测试
// 测试先行... 但作者太懒...
//todo:
TLargeFloat x( 200,TLargeFloat::TDigits(100 ));
TLargeFloat y(12345.678987654321,TLargeFloat::TDigits(100 ));
//TLargeFloat z("-12345.678987654321e-100",TLargeFloat::TDigits(100));
TLargeFloat z( "99999999999999999999999999999999999999999999",TLargeFloat::TDigits(200 ));
//
}
// TLargeFloat.cpp: implementation of the TLargeFloat class.
// 超高精度浮点数类TLargeFloat
//
#include "TLargeFloat.h"
#include <algorithm>
//#include "assert.h"
#include <math.h>
// #define MyDebugAssert(b) { if (!(b)) __asm{ int 3 } }
//用以控制运算精度的工具
class TDigitsLengthCtrl
{
private :
std::vector<TLargeFloat*> m_list;
public :
inline void add_to_ctrl(TLargeFloat* var) { m_list.push_back(var); }
void SetDigitsLength(const long uiDigitsLength)
{
long size= m_list.size();
for (long i=0;i<size;++ i)
m_list[i]-> SetDigitsLength(uiDigitsLength);
}
};
//自动精度控制
class TDigitsLengthAutoCtrl:public TDigitsLengthCtrl
{
private :
std::vector<long> m_DigitsLengthList;
long step;
public :
TDigitsLengthAutoCtrl(long DigitsMul,long DigitsLength0,long MaxDigitsLength)//(收敛系数,初始精度,最终需要精度)
{
// MyDebugAssert(DigitsLength0>0);
//得到最佳的精度梯度
long curDigitsLength= MaxDigitsLength;
while (curDigitsLength> DigitsLength0)
{
m_DigitsLengthList.push_back(curDigitsLength);
if ((DigitsLength0<=1)&&(curDigitsLength==1)) break ;
curDigitsLength=(curDigitsLength+DigitsMul-1)/ DigitsMul;
}
step=get_runcount()-1 ;
}
inline long get_runcount() { return m_DigitsLengthList.size(); }
inline void SetNextDigits()
{
//MyDebugAssert(step>=0);
long DigitsLength= m_DigitsLengthList[step];
if (step>0 )
DigitsLength+=4 ;
SetDigitsLength(DigitsLength);
-- step;
if (step<0) step=0 ;
}
};
/
void TLargeFloat_CtrlExponent(TLargeFloat::TArray& v,TMaxInt iMoveRightCount)
{
//iMoveCountBig 有可能存不下 但现在的体系下因右移超过值域比较难
long iMoveCountBig=(long)(iMoveRightCount/ TLargeFloat::em10Power);
long iMoveCountSmall=(long)(iMoveRightCount% TLargeFloat::em10Power);
//大的右移
if (iMoveCountBig>0 )
{
for (long i=v.size()-1;i>=iMoveCountBig;-- i)
v[i]=v[i- iMoveCountBig];
for (long j=0;j<iMoveCountBig;++ j)
v[j]=0 ;
}
//小的右移
if (iMoveCountSmall>0 )
{
TInt32bit iDiv=1 ;
for (long j=0;j<iMoveCountSmall;++j) iDiv*=10 ;
long v_size= v.size();
for (long i=iMoveCountBig;i<v_size-1;++ i)
{
v[i+1]+=(v[i]%iDiv)* TLargeFloat::emBase;
v[i]/= iDiv;
}
if (v_size>=1 )
v[v_size-1]/= iDiv;
}
}
void TLargeFloat_ArrayAddTestLast(TInt32bit* x,long xsize)
{
for (long i=xsize-1;i>0;-- i)
{
if (x[i]>=TLargeFloat::emBase)//进位
{
++x[i-1 ];
x[i]-= TLargeFloat::emBase;
}
else
break ;
}
}
void TLargeFloat_ArrayAdd(TInt32bit* result,long rsize,const TInt32bit* y,long ysize)
{
// MyDebugAssert(rsize>=ysize);
//MyDebugAssert(ysize>0);
TInt32bit* ri=&result[rsize- ysize];
long i;
for (i=ysize-1;i>0;-- i)
{
TInt32bit r=ri[i]+ y[i];
if (r>=TLargeFloat::emBase)//进位
{
++ri[i-1 ];
r-= TLargeFloat::emBase;
}
ri[i]= r;
}
ri[0]+=y[0 ];
TLargeFloat_ArrayAddTestLast(result,rsize-ysize+1 );
}
void TLargeFloat_ArraySub(TInt32bit* result,long rsize,const TInt32bit* y,long ysize)
{
// MyDebugAssert(rsize>=ysize);
//MyDebugAssert(ysize>0);
TInt32bit* ri=&result[rsize- ysize];
long i;
for (i=ysize-1;i>0;-- i)
{
TInt32bit r=ri[i]- y[i];
if (r<0)//借位
{
--ri[i-1 ];
r+= TLargeFloat::emBase;
}
ri[i]= r;
}
ri[0]-=y[0 ];
for (i=rsize-ysize;i>0;-- i)
{
if (result[i]<0)//借位
{
--result[i-1 ];
result[i]+= TLargeFloat::emBase;
}
else
break ;
}
}
TInt32bit _inti_csMaxMuliValue()
{
double rb=1; double mb=1 ;
for (long i=0;i<100/TLargeFloat::em10Power;++ i)
{
mb*=(1.0/ TLargeFloat::emBase);
rb+= mb;
}
return (TInt32bit)( TInt32bit_MAX_VALUE*(1.0/(TLargeFloat::emBase-1))/rb ) -1 ;
}
//不超界所允许的乘数值M满足: (emBase-1)*M + (emBase-1)*M/B + (emBase-1)*M/B^2 + (emBase-1)*M/B^3 ... <=TInt32bit_MAX_VALUE
static const TInt32bit csMaxMuliValue= _inti_csMaxMuliValue();
static const TInt32bit csMaxMulAddValue = csMaxMuliValue - (TLargeFloat::emBase-1 );
void TLargeFloat_ArrayMUL_ExE(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize)
{
//N*N复杂度的简单乘法实现
for (long k=0;k<rminsize;++k) result[k]=0 ;
while ((ysize>0)&&(y[0]==0)) { --ysize; ++y; ++result; -- rminsize;}
//while ((xsize>0)&&(x[0]==0)) { --xsize; ++x; ++result; --rminsize;}
while ((ysize>0)&&(y[ysize-1]==0)) { -- ysize; }
//while ((xsize>0)&&(x[xsize-1]==0)) { --xsize; }
long add_sum=0 ;
for (long i=0;i<xsize;++ i)
{
long xi= x[i];
if (xi>0 )
{
TInt32bit* resulti=&result[i+1 ];
long y_limit=std::min(rminsize-1- i,ysize);
for (long j=0;j<y_limit;++ j)
{
resulti[j]+=(xi* y[j]);
}
add_sum+= xi;
if (add_sum> csMaxMulAddValue)
{
for (long k=i+y_limit;k>0;-- k)
{
TInt32bit v= result[k];
if (v>= TLargeFloat::emBase)
{
result[k-1]+=v/ TLargeFloat::emBase;
result[k]= v% TLargeFloat::emBase;
}
}
add_sum=0 ;
}
}
}
if (add_sum>0 )
{
for (long k=rminsize-1;k>0;-- k)
{
TInt32bit v= result[k];
if (v>= TLargeFloat::emBase)
{
result[k-1]+=v/ TLargeFloat::emBase;
result[k]= v% TLargeFloat::emBase;
}
}
}
}
//数组乘法 核心
void ArrayMUL(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize);
void ArrayMUL_Dichotomy(TInt32bit* result,long rminsize,const TInt32bit* x,const TInt32bit* y,long MulSize)
{
// 二分法的乘法实现
// x*y=(a*E+b)*(c*E+d)=(E*E-E)*ac + E*(a+b)*(c+d) -(E-1)*bd
// temp_a_add_b=a+b;
// temp_c_add_d=c+d;
// result=E*temp_a_add_b*temp_c_add_d;
// temp_ac=a*c;
// result+=E*E*temp_ac;
// result-=E*temp_ac;
// temp_bd=b*d;
// result+=temp_bd;
// result-=E*temp_bd;
//
long i;
const long E=((MulSize+1)>>1 );
//if (tmpData+2*(E+1)>end_tmpData) __asm int 3
const long acSize=MulSize- E;
const long acErrorSize=E- acSize;
const TInt32bit* a= x;
const TInt32bit* b=& x[acSize];
const TInt32bit* c= y;
const TInt32bit* d=& y[acSize];
TLargeFloat::TArray _tmpData((E+1)*2 );
TInt32bit* tmpData=&_tmpData[0 ];
TInt32bit* temp_a_add_b=&tmpData[0 ];
TInt32bit* temp_c_add_d=&tmpData[(E+1 )];
temp_a_add_b[0]=0 ;
for (i=0;i<E;++i) temp_a_add_b[i+1]= b[i];
TLargeFloat_ArrayAdd(temp_a_add_b,1+E,a,E- acErrorSize);
temp_c_add_d[0]=0 ;
for (i=0;i<E;++i) temp_c_add_d[i+1]= d[i];
TLargeFloat_ArrayAdd(temp_c_add_d,1+E,c,E- acErrorSize);
const long abcdPos=(2*MulSize-E-2*(E+1 ));
for (i=0;i<abcdPos;++i) result[i]=0 ;
ArrayMUL(&result[abcdPos],std::min(rminsize-abcdPos,2*(E+1)),temp_a_add_b,E+1,temp_c_add_d,E+1 );
for (i=abcdPos+2*(E+1);i<rminsize;++i) result[i]=0 ;
TInt32bit* temp_ac=&tmpData[0 ];
const long acminsize=std::min(rminsize,acSize*2 );
ArrayMUL(temp_ac,acminsize,a,acSize,c,acSize);
TLargeFloat_ArrayAdd(result,acminsize,temp_ac,acminsize);
long sub_ac_size=acSize*2 ;
if (E+sub_ac_size>rminsize) sub_ac_size=rminsize- E;
TLargeFloat_ArraySub(result,E+ sub_ac_size,temp_ac,sub_ac_size);
const long add_bdPos=2*MulSize-2* E;
long sub_bd_size=2* E;
const long sub_bdPos=add_bdPos- E;
if (sub_bdPos+sub_bd_size>rminsize) sub_bd_size=rminsize- sub_bdPos;
if (sub_bd_size>0 )
{
TInt32bit* temp_bd=&tmpData[0 ];
ArrayMUL(temp_bd,sub_bd_size,b,E,d,E);
long add_bd_size=2* E;
if (add_bdPos+add_bd_size>rminsize) add_bd_size=rminsize- add_bdPos;
if (add_bd_size>0 )
TLargeFloat_ArrayAdd(result,add_bdPos+ add_bd_size,temp_bd,add_bd_size);
TLargeFloat_ArraySub(result,sub_bdPos+ sub_bd_size,temp_bd,sub_bd_size);
}
}
void ArrayMUL_DichotomyPart(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize)
{
//二分法的辅助函数
///
//x*y=(a*E+b)*y=a*y*E+b*y;
if (xsize== ysize)
{
ArrayMUL_Dichotomy(result,rminsize,x,y,ysize);
return ;
}
if (xsize< ysize)
{
std::swap(xsize,ysize);
std::swap(x,y);
}
const long E= ysize;
const long asize=xsize- E;
const TInt32bit* a=&x[0 ];
const TInt32bit* b=& x[asize];
ArrayMUL(result,rminsize,a,asize,y,ysize);
for (long i=asize+ysize;i<rminsize;++i) result[i]=0 ;
const long byPos= asize;
if (byPos< rminsize)
{
const long byminsize=rminsize- byPos;
TLargeFloat::TArray tmpData(byminsize);
TInt32bit* tmp_by=&tmpData[0 ];
ArrayMUL_Dichotomy(tmp_by,byminsize,b,y,E);
TLargeFloat_ArrayAdd(result,rminsize,tmp_by,byminsize);
}
}
/
const long csTMaxInt_Digits=(long)(log10((long double)TMaxInt_MAX_VALUE)+1 );
TLargeFloat::TLargeFloat(const SelfType& Value)
:m_Digits(Value.m_Digits)
{
m_Exponent= Value.m_Exponent;
m_Sign= Value.m_Sign;
}
TLargeFloat::TLargeFloat(const long double DefultValue)
:m_Digits(TDigits(emLongDoubleDigits+1).GetDigitsArraySize(),0 )
{
fToLargeFloat(DefultValue);
}
TLargeFloat::TLargeFloat(const long double DefultValue,const TDigits& DigitsLength)
:m_Digits(DigitsLength.GetDigitsArraySize(),0 )
{
fToLargeFloat(DefultValue);
}
TLargeFloat::TLargeFloat(const char* strValue)
:m_Digits(TDigits(csTMaxInt_Digits).GetDigitsArraySize(),0 )
{
sToLargeFloat(std::string (strValue));
}
TLargeFloat::TLargeFloat(const char* strValue,const TDigits& DigitsLength)
:m_Digits(DigitsLength.GetDigitsArraySize(),0 )
{
sToLargeFloat(std::string (strValue));
}
TLargeFloat::TLargeFloat(const std::string& strValue)
:m_Digits(TDigits(csTMaxInt_Digits).GetDigitsArraySize(),0 )
{
sToLargeFloat(strValue);
}
TLargeFloat::TLargeFloat(const std::string& strValue,const TDigits& DigitsLength)
:m_Digits(DigitsLength.GetDigitsArraySize(),0 )
{
sToLargeFloat(strValue);
}
void TLargeFloat::Zero()
{
if (m_Sign==0) return ;
m_Sign=0 ;
m_Exponent=0 ;
long old_size= m_Digits.size();
for (long i=0;i<old_size;++ i)
m_Digits[i]=0 ;
}
void TLargeFloat::Canonicity()
{
// 规格化 小数部分
// 规格化前允许:m_Digits[0]>=emBase 也就是小数部分的值大于等于1.0;
// 规格化前允许:m_Digits[]前面有多个0值 也就是小数部分的值小于0.1;
//规格化后的数满足的条件：小数部分的值 小于1.0，大于等于0.1;
if (m_Sign==0 )
{
return ;
}
long old_size= m_Digits.size();
if (old_size<=0) return; //不可能发生:)
if ( (m_Digits[0]<emBase)&&(m_Digits[0]>=(emBase/10)) ) return ;
//处理右移
while (m_Digits[0]>=emBase)//是否需要右移1
{
m_Exponent+= em10Power;
for (long i=old_size-1;i>=2;-- i)
m_Digits[i]=m_Digits[i-1 ];
if (old_size>=2) m_Digits[1]=m_Digits[0] % emBase;
m_Digits[0]/= emBase;
}
// 考虑左移
//大的左移
long iMoveCountBig= old_size;
for (long i=0;i<old_size;++ i)
{
if (m_Digits[i]!=0 )
{
iMoveCountBig= i;
break ;
}
}
if (iMoveCountBig== old_size)
{
//as Zero();
m_Sign=0 ;
m_Exponent=0 ;
return ;
}
if (iMoveCountBig>0 )
{
m_Exponent-=(iMoveCountBig* em10Power);
for (long j=0;j<old_size-iMoveCountBig;++ j)
m_Digits[j]=m_Digits[j+ iMoveCountBig];
for (long k=old_size-iMoveCountBig;k<old_size;++ k)
m_Digits[k]=0 ;
}
//小的左移
TInt32bit iMoveMul=1 ;
long iMoveCountSmall=0 ;
while (iMoveMul*m_Digits[0]<(emBase/10 ))
{
iMoveMul*=10 ;
++ iMoveCountSmall;
}
if (iMoveCountSmall>0 )
{
m_Exponent-= iMoveCountSmall;
for (long i=old_size-1;i>=0;-- i)
m_Digits[i]*= iMoveMul;
for (long j=old_size-1;j>0;-- j)
{
TInt32bit value= m_Digits[j];
m_Digits[j]=value% emBase;
m_Digits[j-1]+=value/ emBase;
}
}
}
void TLargeFloat::iToLargeFloat(TMaxInt iValue)
{
Zero();
long new_size= TDigits(csTMaxInt_Digits).GetDigitsArraySize();
if ((long)m_Digits.size()< new_size)
m_Digits.resize(new_size,0 );
if (iValue==0 )
return ;
else if (iValue>0 )
m_Sign=1 ;
else
{
m_Sign =-1 ;
iValue=- iValue;
}
//无误差转换
TMaxInt tmp_iValue= iValue;
long n=0 ;
for (;tmp_iValue!=0;++ n)
tmp_iValue/= emBase;
m_Exponent=n* em10Power;
for (long i=0;i<n;++ i)
{
m_Digits[n-1-i]=(TInt32bit)(iValue% emBase);
iValue/= emBase;
}
Canonicity();
}
void TLargeFloat::fToLargeFloat(long double fValue)
{
TMaxInt iValue= (TMaxInt)fValue;
if (iValue== fValue)
{
iToLargeFloat(iValue);
return ;
}
Zero();
long new_size=TDigits(emLongDoubleDigits+1 ).GetDigitsArraySize();
if ((long)m_Digits.size()< new_size)
m_Digits.resize(new_size,0 );
if (fValue==0 )
return ;
else if (fValue>0 )
m_Sign=1 ;
else
{
m_Sign =-1 ;
fValue=- fValue;
}
m_Exponent=(long )floor(log10(fValue));
fValue/=pow(10.0,(long )m_Exponent.AsInt());
long size= m_Digits.size();
for (long i=0;i<size;++i)//得到小数位
{
if (fValue<=0) break ;
fValue*= emBase;
TInt32bit iValue= (TInt32bit)floor(fValue);
fValue-= iValue;
m_Digits[i]= iValue;
}
Canonicity();
}
void TLargeFloat::Swap(SelfType& Value)
{
if (this==&Value) return ;
m_Digits.swap(Value.m_Digits);
std::swap(m_Sign,Value.m_Sign);
std::swap(m_Exponent,Value.m_Exponent);
}
void TLargeFloat::Chs()
{
m_Sign*=(-1 );
}
void TLargeFloat::Abs()
{
if (m_Sign!=0) m_Sign=1 ;
}
unsigned long TLargeFloat::GetDigitsLength() const
{
return m_Digits.size()* em10Power;
}
void TLargeFloat::SetDigitsLength(const TDigits& DigitsLength)
{
m_Digits.resize(DigitsLength.GetDigitsArraySize(),0 );
}
TLargeFloat::SelfType& TLargeFloat::operator = (const SelfType& Value)
{
if (this==&Value) return *this ;
m_Digits= Value.m_Digits;
m_Sign= Value.m_Sign;
m_Exponent= Value.m_Exponent;
return *this ;
}
TLargeFloat::SelfType& TLargeFloat::operator = (long double fValue)
{
fToLargeFloat(fValue);
return *this ;
}
long double TLargeFloat::AsFloat() const
{
if ( ((m_Exponent.AsInt())>= emLongDoubleMaxExponent)
||((m_Exponent.AsInt())<= emLongDoubleMinExponent) )
{
throw TException("ERROR:TLargeFloat::AsFloat()" );
}
if (m_Sign==0) return 0 ;
long double result=m_Sign*pow((long double)10.0,(long double )m_Exponent.AsInt());
long double r=1 ;
long double Sum=0 ;
long old_size= m_Digits.size();
for (long i=0;i<old_size;++i)//得到小数位
{
r/=emBase;//r*=(1.0/emBase);
if (r==0) break ;
Sum+=(m_Digits[i]* r);
}
return result* Sum;
}
std::string TLargeFloat::AsString() const
{
if (m_Sign==0 )
return "0" ;
//计算需要的字符串空间大小
long str_length=2+m_Digits.size()* em10Power;
if (m_Sign<0) ++str_length; //负号
TMaxInt EpValue = m_Exponent.AsInt();
long UEP_StrLength=0 ;
if (EpValue!=0 )
{
++ str_length;
if (EpValue<0 )
{
EpValue=- EpValue;
++ str_length;
}
UEP_StrLength=0 ;
while (EpValue>0 )
{
EpValue/=10 ;
++ UEP_StrLength;
}
str_length+= UEP_StrLength;
}
std::string result(str_length,' ' );
std::string::value_type* pStr=&result[0 ];
//输出字符串
if (m_Sign<0) { *pStr='-'; ++ pStr; }
*pStr='0'; ++pStr; *pStr='.'; ++ pStr;
long dgsize= m_Digits.size();
for (long i=0;i<dgsize;++ i)
{
TInt32bit Value= m_Digits[i];
for (long d=0;d<em10Power;++ d)
{
pStr[em10Power-1-d]=(char)('0'+(Value%10 ));
Value/=10 ;
}
pStr+= em10Power;
}
EpValue= m_Exponent.AsInt();
if (EpValue!=0 )
{
*pStr='e'; ++ pStr;
if (EpValue<0 )
{
EpValue=- EpValue;
*pStr='-'; ++ pStr;
}
for (long i=0;i<UEP_StrLength;++ i)
{
pStr[UEP_StrLength-1-i]=(char)('0'+(EpValue%10 ));
EpValue/=10 ;
}
pStr+= UEP_StrLength;
}
return result;
}
template<class PChar>
PChar sToLargeFloat_GetCharIntEnd(PChar int_begin,PChar str_end)
{
long int_count=0 ;
for (PChar i=int_begin;i<str_end;++ i)
{
if ( ('0'<=(*i)) && ((*i)<='9' ) )
++ int_count;
else
break ;
}
return & int_begin[int_count];
}
inline void sToLargeFloat_setAChar(TLargeFloat::TArray& Digits,long set_index,char aChar)
{
unsigned long Value=aChar-'0' ;
long e10Power_count=TLargeFloat::em10Power-1-(set_index% TLargeFloat::em10Power);
for (long i=0;i<e10Power_count;++ i)
Value*=10 ;
Digits[set_index/TLargeFloat::em10Power]+= Value;
}
void TLargeFloat::sToLargeFloat(const std::string& strValue)
{
if (strValue.size()<=0 )
{
this-> Zero();
return ;
}
typedef const std::string::value_type* PChar;
PChar pstr_begin= strValue.c_str();
PChar pstr_end=& pstr_begin[strValue.size()];
//str as: [+|-][0..9][.][0..9][E|e][+|-][0..9]
bool is_have_sign=false ;
long sign=1 ;
bool is_have_int=false ;
PChar int_begin=0; PChar int_end=0 ;
bool is_have_dot=false ;
bool is_have_digits=false ;
PChar digits_begin=0; PChar digits_end=0 ;
bool is_have_ep=false ;
bool is_have_ep_sign=false ;
long ep_sign=1 ;
bool is_have_ep_int=false ;
PChar ep_int_begin=0; PChar ep_int_end=0 ;
//处理正负号
if ((*pstr_begin)=='-' )
{
sign = -1 ;
is_have_sign=true ;
++ pstr_begin;
}
else if ((*pstr_begin)=='+' )
{
is_have_sign=true ;
++ pstr_begin;
}
//处理前面的整数部分
int_begin= pstr_begin;
int_end= sToLargeFloat_GetCharIntEnd(int_begin,pstr_end);
is_have_int=(int_begin!= int_end);
if ((int_end-int_begin>=2)&&((*int_begin)=='0')) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 0"); //'0?'数字表示错误
pstr_begin= int_end;
if (((*pstr_begin)!='.')&&(!is_have_int)) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 1"); // 没有任何数字
//处理小数部分
if ((*pstr_begin)=='.' )
{
is_have_dot=true ;
++ pstr_begin;
digits_begin= pstr_begin;
digits_end= sToLargeFloat_GetCharIntEnd(digits_begin,pstr_end);
is_have_digits=(digits_begin!= digits_end);
if ((!is_have_digits)&&(!is_have_int)) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 2"); //没有任何数字
pstr_begin= digits_end;
}
//处理指数部分
if ( ((*pstr_begin)=='e')||((*pstr_begin)=='E' ) )
{
is_have_ep=true ;
++ pstr_begin;
//处理指数的正负号
if ((*pstr_begin)=='-' )
{
ep_sign = -1 ;
is_have_ep_sign=true ;
++ pstr_begin;
}
else if((*pstr_begin)=='+' )
{
is_have_ep_sign=true ;
++ pstr_begin;
}
//处理指数中的整数
ep_int_begin= pstr_begin;
ep_int_end= sToLargeFloat_GetCharIntEnd(ep_int_begin,pstr_end);
is_have_ep_int=(ep_int_begin!= ep_int_end);
if ((ep_int_end-ep_int_begin>=2)&&((*ep_int_begin)=='0')) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 3"); //'0?'数字表示错误
pstr_begin= ep_int_end;
if (!is_have_ep_int) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 4"); //指数没有数字
}
if (pstr_begin!=pstr_end) throw TException("ERROR:TLargeFloat::sToLargeFloat(); 5"); //未预料的字符
//
//实际的类型转换
this-> Zero();
this->m_Sign= sign;
this->m_Exponent=(int_end- int_begin);
long need_digits_count=(int_end-int_begin)+(digits_end- digits_begin);
if ((long)this->GetDigitsLength()< need_digits_count)
this-> SetDigitsLength(need_digits_count);
long set_index=0 ;
PChar set_begin= int_begin;
for (;set_begin<int_end;++set_begin,++ set_index)
sToLargeFloat_setAChar(this->m_Digits,set_index,* set_begin);
set_begin= digits_begin;
for (;set_begin<digits_end;++set_begin,++ set_index)
sToLargeFloat_setAChar(this->m_Digits,set_index,* set_begin);
if (is_have_ep)
{
TExpInt ep=0 ;
for (PChar set_begin=ep_int_begin;set_begin<ep_int_end;++ set_begin)
{
ep*=10 ;
ep+=((*set_begin)-'0' );
}
ep*= ep_sign;
this->m_Exponent+= ep;
}
Canonicity();
}
long TLargeFloat::Compare(const SelfType& Value) const
{
if (this==&Value) return 0 ;
// (*this)>Value 返回1，小于返回-1，相等返回0
//比较符号
if (m_Sign> Value.m_Sign)
return 1 ;
else if(m_Sign< Value.m_Sign)
return -1 ;
else //m_Sign==Value.m_Sign
{
if(m_Sign==0 )
return 0 ;
}
// m_Sign==Value.m_Sign
//比较指数
if (m_Exponent.AsInt()> Value.m_Exponent.AsInt())
return m_Sign;
else if (m_Exponent.AsInt()< Value.m_Exponent.AsInt())
return - m_Sign;
else//(m_Exponent==Value.m_Exponent)
{
long sizeS= m_Digits.size();
long sizeV= Value.m_Digits.size();
long min_size= std::min(sizeS,sizeV);
for (long i=0;i<min_size;++ i)
{
if (m_Digits[i]!= Value.m_Digits[i])
{
if (m_Digits[i]> Value.m_Digits[i])
return m_Sign;
else //if (m_Digits[i]
return - m_Sign;
}
}
//继续比较 处理尾部
if (sizeS> sizeV)
{
for (long i=sizeV;i<sizeS;++ i)
{
if (m_Digits[i]>0 )
return m_Sign;;
}
}
else if (sizeS< sizeV)
{
for (long i=sizeS;i<sizeV;++ i)
{
if (Value.m_Digits[i]>0 )
return - m_Sign;
}
}
//sizeS==sizeV
return 0 ;
}
}
//
//+ -
TLargeFloat::SelfType & TLargeFloat::operator += (const SelfType& Value)
{
if (Value.m_Sign==0 )
return (*this );
else if (m_Sign==0 )
return (*this)= Value;
else if (m_Sign== Value.m_Sign)
{
TInt32bit oldSign= m_Sign;
Abs_Add(Value);
m_Sign= oldSign;
return *this ;
}
else
return *this-=(- Value);
}
TLargeFloat::SelfType& TLargeFloat::operator -= (const SelfType& Value)
{
if (Value.m_Sign==0 )
return (*this );
else if (m_Sign==0 )
{
(*this)=- Value;
return (*this );
}
else if (m_Sign== Value.m_Sign)
{
long comResult=this-> Compare(Value);
if (comResult==0 )
{
this-> Zero();
}
else
{
Abs_Sub_Abs(Value);
m_Sign = comResult;
}
return *this ;
}
else
return *this+=(- Value);
}
void TLargeFloat::Abs_Add(const SelfType& Value)//绝对值加法
{
this-> Abs();
SelfType Right(Value);
Right.Abs();
//精度一致
if (m_Digits.size()< Right.m_Digits.size())
m_Digits.resize(Right.m_Digits.size(),0 );
else if (m_Digits.size()> Right.m_Digits.size())
Right.m_Digits.resize(m_Digits.size(),0 );
//被加数指数较大就可以了
if (m_Exponent.AsInt()< Right.m_Exponent.AsInt())
this-> Swap(Right);
long size= m_Digits.size();
TMaxInt iMoveRightCount=m_Exponent.AsInt()- Right.m_Exponent.AsInt();
if (iMoveRightCount>=size*(TMaxInt)TLargeFloat::em10Power) return ;
TLargeFloat_CtrlExponent(Right.m_Digits,iMoveRightCount);//对齐小数点
TLargeFloat_ArrayAdd( &m_Digits[0],size,&Right.m_Digits[0 ],size);
if (m_Digits[0]>= emBase)
Canonicity();
}
void TLargeFloat::Abs_Sub_Abs(const SelfType& Value)//绝对值减法
{
this-> Abs();
SelfType Right(Value);
Right.Abs();
long comResult=this-> Compare(Right);
if (comResult==0 )
{
this-> Zero();
return ;
}
else if (comResult<0 )
this-> Swap(Right);
//精度一致
if (m_Digits.size()< Right.m_Digits.size())
m_Digits.resize(Right.m_Digits.size(),0 );
else if (m_Digits.size()> Right.m_Digits.size())
Right.m_Digits.resize(m_Digits.size(),0 );
long size= m_Digits.size();
TMaxInt iMoveRightCount=m_Exponent.AsInt()- Right.m_Exponent.AsInt();
if (iMoveRightCount>=size*(TMaxInt)TLargeFloat::em10Power) return ;
TLargeFloat_CtrlExponent(Right.m_Digits,iMoveRightCount); //对齐小数点
TLargeFloat_ArraySub( &m_Digits[0],size,&Right.m_Digits[0 ],size);
if (m_Digits[0]*10< emBase)
Canonicity();
}
/
// /
//最大的32bit整数除数M满足: (emBase-1)+(M-1)*emBase<=TInt32bit_MAX_VALUE
const TInt32bit csMaxDiviValue=TInt32bit_MAX_VALUE/TLargeFloat::emBase -1 ;
//最大的整数除数M满足: (emBase-1)+(M-1)*emBase<=TMaxInt_MAX_VALUE
const TMaxInt csMaxDiviValueBig=TMaxInt_MAX_VALUE/TLargeFloat::emBase -1 ;
void TLargeFloat::DivInt(TMaxInt iValue)//除以一个整数
{
if (iValue==0 )
throw TException("ERROR:TLargeFloat::DivInt()" );
else if (iValue<0 )
{
iValue=- iValue;
this-> Chs();
//continue
}
if (iValue==1) return ;
if (this->m_Sign==0) return ;
if (iValue> csMaxDiviValueBig)
{
TLargeFloat y(0.0 );
y.iToLargeFloat(iValue);
(*this)/= y;
return ;
}
if (iValue<= csMaxDiviValue)
{
TInt32bit iDiv= (TInt32bit)iValue;
long size= m_Digits.size();
for (long i=0;i<size-1;++ i)
{
m_Digits[i+1]+=(m_Digits[i]%iDiv)* emBase;
m_Digits[i]/= iDiv;
}
if (size>=1 )
m_Digits[size-1]/= iDiv;
}
else
{
TMaxInt iDiv= iValue;
long size= m_Digits.size();
TMaxInt cur_value=m_Digits[0 ];
for (long i=0;i<size-1;++ i)
{
m_Digits[i]=(TInt32bit)(cur_value/ iDiv);
cur_value=m_Digits[i+1]+(cur_value%iDiv)* emBase;
}
if (size>=1 )
m_Digits[size-1]=(TInt32bit)(cur_value/ iDiv);
}
Canonicity();
}
TLargeFloat::SelfType& TLargeFloat::operator /= (long double fValue)
{
TMaxInt iValue= (TMaxInt)fValue;
if (iValue== fValue)
{
DivInt(iValue);
return *this ;
}
else
return (*this)/= TLargeFloat(fValue);
}
TLargeFloat::SelfType& TLargeFloat::operator /= (const SelfType& Value)
{
SelfType x(Value);
x.Rev();//x=1/x;
return (*this)*= x;
}
void TLargeFloat::Rev()//求倒数
{
// 求1/a,
// 则有a=1/x; y=a-1/x;
// 求导得y'=1/x^2;
// 代入牛顿方程 x(n+1)=x(n)-y(x(n))/y'(x(n));
// 有迭代式 x_next=(2-a*x)*x; // 可证明：该公式为2阶收敛公式
// 证明:令x=1/a+dx;
// 则有x_next-1/a=(2-a*(1/a+dx))*(1/a+dx)-1/a
// =(-a)*dx^2
// 证毕.
if (this->m_Sign==0) throw TException("ERROR:TLargeFloat::Rev()" );
TExpInt oldExponent= m_Exponent;
SelfType a(*this );
a.m_Exponent=0 ;
SelfType x(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
x=1.0/a.AsFloat();//初始迭代值
TDigitsLengthAutoCtrl dlCtrl( 2,emLongDoubleDigits-1,(a.m_Digits.size()* TLargeFloat::em10Power));
SelfType ta(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
SelfType temp(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
dlCtrl.add_to_ctrl(& ta);
dlCtrl.add_to_ctrl(& x);
dlCtrl.add_to_ctrl(& temp);
for (long i=0;i<dlCtrl.get_runcount();++ i)
{
ta= a;
dlCtrl.SetNextDigits();
//x=x*2-x*x*ta;
temp= x;
temp*= temp;
temp*= ta;
x*=2 ;
x-= temp;
}
x.m_Exponent-= oldExponent;
this-> Swap(x);
}
/////
//
void TLargeFloat::RevSqrt() //
{
// 求1/a^0.5,
// 则有a=1/x^2; y=a-1/x^2;
// 求导得y'=2/x^3;
// 代入牛顿方程 x(n+1)=x(n)-y(x(n))/y'(x(n));
// 有迭代式 x_next=(3-a*x*x)*x/2; // 可证明：该公式为2阶收敛公式
// 证明:令x=1/a^0.5+dx;
// 则有x_next-1/a^0.5=(3-a*(1/a^0.5+dx)*(1/a^0.5+dx))*(1/a^0.5+dx)/2 - 1/a^0.5
// =-(1.5/a^0.5)*dx^2-0.5*a*dx^3;
// 证毕.
if (this->m_Sign<0) throw TException("ERROR:TLargeFloat::RevSqrt()" );
if (this->m_Sign==0) return ;
SelfType a(*this );
TMaxInt sqrExponent=a.m_Exponent.AsInt()/2 ;
a.m_Exponent-=(sqrExponent*2 );
SelfType x(0.0 ,TDigits(a.GetDigitsLength()));
x=1.0/sqrt(a.AsFloat());//初始迭代值
TDigitsLengthAutoCtrl dlCtrl( 2,emLongDoubleDigits-1,(a.m_Digits.size()* TLargeFloat::em10Power));
SelfType ta(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
SelfType temp(0.0 ,TLargeFloat::TDigits(a.GetDigitsLength()));
dlCtrl.add_to_ctrl(& ta);
dlCtrl.add_to_ctrl(& x);
dlCtrl.add_to_ctrl(& temp);
for (long i=0;i<dlCtrl.get_runcount();++ i)
{
ta= a;
dlCtrl.SetNextDigits();
//x=(3-x*x*ta)*x/2;
temp= x;
temp*= temp;
temp*= ta;
temp.Chs();
temp+=3 ;
x*= temp;
x/=2 ;
}
x.m_Exponent-= sqrExponent;
this-> Swap(x);
}
////
//*
void TLargeFloat::MulInt(TMaxInt iValue)
{
if (this->m_Sign==0) return ;
if (iValue==0 )
{
this-> Zero();
return ;
}
else if (iValue<0 )
{
iValue=- iValue;
this-> Chs();
//continue
}
if (iValue> csMaxMuliValue)
{
TLargeFloat y(0.0 );
y.iToLargeFloat(iValue);
(*this)*= y;
return ;
}
//乘以一个整数
TInt32bit Value= (TInt32bit)iValue;
long size= m_Digits.size();
for (long i=size-1;i>=0;-- i)
{
m_Digits[i]*= Value;
}
for (long j=size-1;j>=1;-- j)
{
if (m_Digits[j]>= emBase)
{
m_Digits[j-1]+=m_Digits[j]/ emBase;
m_Digits[j]%= emBase;
}
}
Canonicity();
}
TLargeFloat::SelfType& TLargeFloat::operator *= (long double fValue)
{
TMaxInt iValue= (TMaxInt)fValue;
if (iValue== fValue)
{
MulInt(iValue);
return *this ;
}
else
{
TLargeFloat temp(fValue);
return (*this)*= temp;
}
}
inline void getBestMulSize(const TInt32bit*& x,long& xsize,const TInt32bit*& y,long& ysize)
{
long bxsize= xsize;
long bysize= ysize;
long i;
for (i=xsize-1;i>=0;-- i)
{
if (x[i]==0 )
-- bxsize;
else
break ;
}
for (i=ysize-1;i>=0;-- i)
{
if (y[i]==0 )
-- bysize;
else
break ;
}
if (bxsize< bysize)
{
std::swap(bxsize,bysize);
std::swap(xsize,ysize);
std::swap(x,y);
}
xsize= bxsize;
const long csABigMulSize=1000 ;
if ( (bysize<csABigMulSize)||(bxsize*2>=bysize*3)||(bxsize> ysize) )
ysize= bysize;
else
ysize= bxsize;
}
TLargeFloat::SelfType& TLargeFloat::operator *= (const SelfType& Value)
{
long xsize= m_Digits.size();
long ysize= Value.m_Digits.size();
if ((m_Sign==0)||(Value.m_Sign==0 ))
{
if (m_Sign!=0 )
this-> Zero();
if (xsize< ysize)
m_Digits.resize(ysize,0 );
return *this ;
}
if (xsize< ysize)
m_Digits.resize(ysize,0 );
long rminsize=std::max(xsize,ysize)+2;//乘法结果需要的位数
const TInt32bit* x=&m_Digits[0 ];
const TInt32bit* y=&Value.m_Digits[0 ];
getBestMulSize(x,xsize,y,ysize);
if (rminsize>xsize+ ysize)
rminsize=xsize+ ysize;
TArray tempArray(rminsize);
ArrayMUL(&tempArray[0 ],rminsize,x,xsize,y,ysize);
xsize= m_Digits.size();
long resultsize= std::min(xsize,rminsize);
long i;
for (i=0;i<resultsize;++i) this->m_Digits[i]= tempArray[i];
for (i=resultsize;i<xsize;++i) this->m_Digits[i]=0 ;
m_Exponent+= Value.m_Exponent;
m_Sign*= Value.m_Sign;
Canonicity();
return *this ;
}
// 快速傅立叶变换实现大整数乘法
// FFT Mul
struct TComplex //复数类型
{
double i;
double r;
};
//初始化
void FFTInitial(TComplex* w,long* lst,const long n)
{
//计算W^i , i in [0--n)
const double PI=3.1415926535897932385 ;
const double seta=2.0*PI/ n;
long i,j;
long n2=n>>2 ;
for (i=0;i<=n2;++ i)
{
w[i].i=sin(seta* i);
w[i].r=cos(seta* i);
}
for (j=(n2+1),i=(n2-1); i>=0 ;--i,++ j)
{
w[j].i= w[i].i;
w[j].r=- w[i].r;
}
//计算排序用数组
lst[0]=0 ;
i=1 ;
long m;
for (n2=n>>1,m=2; n2>0 ;n2=n2>>1,m =m<<1 )
{
for (long j=0;i<m;++i,++ j)
{
lst[i]=lst[j]+ n2;
}
}
}
//快速傅立叶变换
void FFT(TComplex* a,const TComplex* w,const long n)
{
long n2=1 ;
long n1=n >> 1 ;
for (long per=1;per< n;)
{
long m=n2; long j=0; long k= n2;
per<<=1 ;
while (k< n)
{
for (long i2=0; j<m ;++j,++k,i2+= n1)
{
TComplex tmpb= a[j];
double tmp1=a[k].r*w[i2].r-a[k].i* w[i2].i;
double tmp2=a[k].r*w[i2].i+a[k].i* w[i2].r;
a[j].r=tmpb.r+ tmp1;
a[j].i=tmpb.i+ tmp2;
a[k].r=tmpb.r- tmp1;
a[k].i=tmpb.i- tmp2;
}
m+= per;
j+= n2;
k+= n2;
}
n2= per;
n1>>=1 ;
}
}
//反向快速傅立叶变换
void InvFFT(TComplex* a,const TComplex* w,const long n)
{
for (long i=0;i<n;++ i)
a[i].i=- a[i].i;
FFT(a,w,n);
}
void FFT_Convolution(const TComplex* a,TComplex* b,const long n)
{
for (long i=0;i<n;++ i)
{
double br=a[i].r*b[i].r - a[i].i* b[i].i;
b[i].i=a[i].r*b[i].i + a[i].i* b[i].r;
b[i].r= br;
}
}
void FFT_IntArrayCopyToComplexArray(const TInt32bit* ACoef,const long ASize,TComplex* result,const long n,const long* lst)
{
for (long i=0;i<n;++ i)
{
long ai= lst[i];
if (ai< ASize)
result[i].r= ACoef[ai];
else
result[i].r =0.0 ;
result[i].i=0.0 ;
}
}
void FFT_ComplexArrayToIntArray(const TComplex* cmx,const long n,TInt32bit* result,const long rMinSize)
{
const double tmpRevN=1.0/ n;
double FFT_int_base;
TLargeFloat::TArray tempResult;
TInt32bit* dst=0 ;
long dstsize=0 ;
{
FFT_int_base=(long )TLargeFloat::emBase;
dstsize= rMinSize;
dst= result;
}
const double tmpRevFFT_int_base=1.0/ FFT_int_base;
double MaxWorstEr=0 ;
double tmp=0.0 ;
for (long i=std::min(n,dstsize)-1;i>=1;-- i)
{
double num =cmx[i-1].r*tmpRevN+ tmp;
tmp=floor((num+0.499)* tmpRevFFT_int_base);
dst[i]=(TInt32bit)(num+0.499-tmp* FFT_int_base);
double newWorstEr=abs(num-tmp*FFT_int_base-dst[i]);//记录最大误差
if (newWorstEr> MaxWorstEr)
MaxWorstEr= newWorstEr;
}
if (dstsize>0 )
dst[0]=(TInt32bit)(tmp+0.1 );
if (MaxWorstEr>=0.499 )
throw TLargeFloat::TException("ERROR:FFT's FFT_ComplexArrayToIntArray(); "); //误差过大
}
//FFT平方
void SquareFFT(const TInt32bit* ACoef,const long ASize,TInt32bit* CCoef,const long CMinSize)
{
long ansize=ASize+ ASize;
long n=1 ;
while (n<ansize) n<<=1 ;
std::vector<TComplex> _w((n>>1)+1 );
std::vector<long> _lst(n);
TComplex* w=&_w[0 ];
long* lst=&_lst[0 ];
FFTInitial(w,lst,n);
std::vector<TComplex> _a(n);
TComplex* a=&_a[0 ];
FFT_IntArrayCopyToComplexArray(ACoef,ASize,a,n,lst);
FFT(a,w, n);
FFT_Convolution(a,a,n);
std::vector<TComplex> _tmpa(n);
_tmpa.swap(_a);
TComplex* tmpa=&_tmpa[0]; a=&_a[0 ];
for (long i=0;i<n;++i) a[i]= tmpa[lst[i]];
_tmpa.clear();
_lst.clear();
InvFFT(a,w,n);
_w.clear();
FFT_ComplexArrayToIntArray(a,n,CCoef,CMinSize);
}
//FFT乘法
void MulFFT(const TInt32bit* ACoef,const long ASize,const TInt32bit* BCoef,const long BSize,TInt32bit* CCoef,const long CMinSize)
{
long absize=(ASize+ BSize);
long n=1 ;
while (n<absize) n<<=1 ;
std::vector<TComplex> _w((n>>1)+1 );
std::vector<long> _lst(n);
TComplex* w=&_w[0 ];
long* lst=&_lst[0 ];
FFTInitial(w,lst,n);
std::vector<TComplex> _a(n);
TComplex* a=&_a[0 ];
FFT_IntArrayCopyToComplexArray(ACoef,ASize,a,n,lst);
std::vector<TComplex> _b(n);
TComplex* b=&_b[0 ];
FFT_IntArrayCopyToComplexArray(BCoef,BSize,b,n,lst);
FFT(b,w, n);
FFT(a,w, n);
FFT_Convolution(a,b,n);
for (long i=0;i<n;++i) a[i]= b[lst[i]];
_b.clear();
_lst.clear();
InvFFT(a,w,n);
_w.clear();
FFT_ComplexArrayToIntArray(a,n,CCoef,CMinSize);
}
/
const long csBestMUL_ExE_size =1024 / TLargeFloat::em10Power;
const long csBestMUL_Dichotomy_size =4096 / TLargeFloat::em10Power;
const long csBestMul_FFT4Max_size =16777216 / TLargeFloat::em10Power;
void ArrayMUL(TInt32bit* result,long rminsize,const TInt32bit* x,long xsize,const TInt32bit* y,long ysize)
{
if (xsize< ysize)
{
std::swap(xsize,ysize);
std::swap(x,y);
}
if (rminsize< ysize)
{
xsize= rminsize;
ysize= rminsize;
}
if (ysize<=csBestMUL_ExE_size) //
TLargeFloat_ArrayMUL_ExE(result,rminsize,x,xsize,y,ysize);
else if (ysize<= csBestMUL_Dichotomy_size)
ArrayMUL_DichotomyPart(result,rminsize,x,xsize,y,ysize);
else if ((xsize+ysize)<=(csBestMul_FFT4Max_size*2 ))
{
if (x== y)
SquareFFT(x,xsize,result,rminsize);
else
MulFFT(x,xsize,y,ysize,result,rminsize);
}
else
ArrayMUL_DichotomyPart(result,rminsize,x,xsize,y,ysize);
}
void LargeFloat_UnitTest()
{
// 单元测试
// 测试先行... 但作者太懒...
//todo:
TLargeFloat x( 200,TLargeFloat::TDigits(100 ));
TLargeFloat y(12345.678987654321,TLargeFloat::TDigits(100 ));
//TLargeFloat z("-12345.678987654321e-100",TLargeFloat::TDigits(100));
TLargeFloat z( "99999999999999999999999999999999999999999999",TLargeFloat::TDigits(200 ));
//
}
main函数，Demo程序
///
// LargeFloat.cpp
//
#include <iostream>
#include "TLargeFloat.h"
//#define _MY_TIME_CLOCK
#ifdef _MY_TIME_CLOCK
#include <windows.h>
#define clock_t __int64
clock_t CLOCKS_PER_SEC =0 ;
inline clock_t clock()
{
__int64 result;
if (CLOCKS_PER_SEC==0 )
{
QueryPerformanceFrequency((LARGE_INTEGER *)& result);
CLOCKS_PER_SEC= (clock_t)result;
}
QueryPerformanceCounter((LARGE_INTEGER *)& result);
return (clock_t)result;
}
#else
#include <time.h>
#endif
//计算圆周率PI
TLargeFloat GetBorweinPI(unsigned long uiDigitsLength);
TLargeFloat GetAGMPI(unsigned long uiDigitsLength);
TLargeFloat GetChudnovskyPI(unsigned long uiDigitsLength);
void Debug_toCout(const std::string& strx,const TLargeFloat& x)//调试输出
{ std::cout<<strx<<std::endl<<x<< std::endl; }
int main()
{
try
{
LargeFloat_UnitTest();
TLargeFloat x( 0.0,TLargeFloat::TDigits(100 ));
x=1 ;
Debug_toCout("1/7:=",x/7 );
x.StrToLargeFloat("12345678987654321" );
Debug_toCout("12345678987654321*12345678987654321 := ",x* x);
x=2 ;
Debug_toCout("2^0.5 := " ,sqrt(x));
//test PI
std::cout<<std::endl<<"请输入需要PI的有效位数:" ;
long pi_length=0; std::cin>>pi_length; std::cout<< std::endl;
clock_t t0= clock();
x=GetAGMPI(pi_length); //
//x=GetBorweinPI(pi_length)
t0=clock()- t0;
Debug_toCout("PI := " ,x);
std::cout<<"PI计算时间:"<<(t0*1.0/CLOCKS_PER_SEC)<<" 秒" ;
}
catch (const TLargeFloatException& lfe)
{
std::cout<<">> LargeFloat运算时发生异常: "<<lfe.what()<< std::endl;
}
catch (const std::exception& e)
{
std::cout<<">> 异常: "<<e.what()<< std::endl;
}
catch (...)
{
std::cout<<">> 未知的异常! "<< std::endl;
}
std::cout<< std::endl;
std::cout<<"...end..."<< std::endl;
char c; std::cin>> c;
return 0 ;
}
//计算圆周率PI
TLargeFloat GetBorweinPI(unsigned long uiDigitsLength)
{
// Borwein四次迭代式：
// 初值： a0=6-4*2^0.5; y0=2^0.5-1;
// 重复计算： y(n+1)=[1-(1-y^4)^0.25]/[1+(1-y^4)^0.25];
// y=y(n+1);
// a(n+1)=a*(1+y)^4-2^(2*n+3)*y*(1+y+y*y);
// 最后计算： PI=1/a;
// 迭代次数和10进制有效精度 每迭代一次有效精度增长4倍
// 0 1 2 3 4 5 6 ...
//0 8 40 170 693 2789 11171 ...
long loop_count;
if (uiDigitsLength<=8 )
loop_count=1 ;
else if (uiDigitsLength<=40 )
loop_count=2 ;
else if (uiDigitsLength<=170 )
loop_count=3 ;
else if (uiDigitsLength<=693 )
loop_count=4 ;
else if (uiDigitsLength<=2789 )
loop_count=5 ;
else
{
loop_count=6 ;
long DigitsLength=11171 ;
while (DigitsLength<(long )uiDigitsLength)
{
DigitsLength*=4;//四阶收敛
++ loop_count;
}
}
std::cout<<" ... 开始计算PI,Borwein四次迭代式, 总循环次数："<<loop_count<<" ... "<< std::endl;
TLargeFloat::TDigits sCount(uiDigitsLength);//计算采用的十进制精度
TLargeFloat a( 0.0,sCount),y(0.0 ,sCount);
TLargeFloat temp(0.0 ,sCount);
TLargeFloat pow(2*2*2,sCount); // 2^(2*n+3); (n=0);
//a0=6-4*2^0.5;
temp=2 ;
temp.Sqrt();
a=6-4* temp;
//y0=2^0.5-1;
y=temp-1 ;
TLargeFloat tmpa(0.0 ,sCount);
for (long i=0;i<loop_count;++ i)
{
std::cout<<" ... 计算PI "<<uiDigitsLength<<" 位的当前循环次数："<<i+1<<"/"<<loop_count<<" ... "<< std::endl;
temp=1- sqr(sqr(y));
temp=revsqrt(revsqrt(temp));//等价于 temp=sqrt(sqrt(temp));
y=(1-temp)/(1+ temp);
temp=sqr(1+ y);
a=a*sqr(temp)-pow*y*(temp- y);
pow*=4 ;
}
std::cout<<" ... 计算PI的循环结束，准备输出 ... "<< std::endl;
return 1/a;//PI=1/a;
}
TLargeFloat GetAGMPI(unsigned long uiDigitsLength)
{
// AGM二次迭代式:
// 初值:a=x=1 b=1/sqrt(2) c=1/4
// 重复计算:y=a a=(a+b)/2 b=sqrt(by) c=c-x(a-y)^2 x=2x
// 最后:pi=(a+b)^2/(4c)
// 迭代次数和10进制有效精度 每迭代一次有效精度增长2倍
// 0 1 2 3 4 5 6 7 8 ...
//1 39 82 169 344 693 1391 2788 5582 ...
long loop_count;
if (uiDigitsLength<=39 )
loop_count=1 ;
else if (uiDigitsLength<=82 )
loop_count=2 ;
else if (uiDigitsLength<=169 )
loop_count=3 ;
else if (uiDigitsLength<=344 )
loop_count=4 ;
else if (uiDigitsLength<=693 )
loop_count=5 ;
else if (uiDigitsLength<=1391 )
loop_count=6 ;
else if (uiDigitsLength<=2788 )
loop_count=7 ;
else
{
loop_count=8 ;
long DigitsLength=5582 ;
while (DigitsLength<(long )uiDigitsLength)
{
DigitsLength*=2;//2阶收敛
++ loop_count;
}
}
std::cout<<" ... 开始计算PI,AGM二次迭代式, 总循环次数："<<loop_count<<" ... "<< std::endl;
TLargeFloat::TDigits sCount(uiDigitsLength);//计算采用的十进制精度
TLargeFloat c( 8,sCount); c.RevSqrt(); c.Chs(); //c=-sqrt(1/8);
TLargeFloat a(c); a*=(-3); a+=1; //a=1-3*c;
TLargeFloat b(a); b.Sqrt(); //b=sqrt(a);
TLargeFloat e("-0.625"); e += b; //e=b-0.625
b *= 2 ;
c += e;
a += e;
long npow=4 ;
for (long i=0;i<loop_count;++ i)
{
std::cout<<" ... 计算PI "<<uiDigitsLength<<" 位的当前循环次数："<<i+1<<"/"<<loop_count<<" ... "<< std::endl;
e = a;
e += b;
e /= 2 ;
b *= a;
b.Sqrt();
e -= b;
b *= 2 ;
c -= e;
a = e;
a += b;
npow *= 2 ;
}
std::cout<<" ... 计算PI的循环结束，准备输出 ... "<< std::endl;
e *= e;
e /= 4 ;
a += b;
c *= a;
c -= e;
c *= npow;
a *= a;
a-= e;
e/=2 ;
a-= e;
a/= c;
return a;
}
//
///
// LargeFloat.cpp
//
#include <iostream>
#include "TLargeFloat.h"
//#define _MY_TIME_CLOCK
#ifdef _MY_TIME_CLOCK
#include <windows.h>
#define clock_t __int64
clock_t CLOCKS_PER_SEC =0 ;
inline clock_t clock()
{
__int64 result;
if (CLOCKS_PER_SEC==0 )
{
QueryPerformanceFrequency((LARGE_INTEGER *)& result);
CLOCKS_PER_SEC= (clock_t)result;
}
QueryPerformanceCounter((LARGE_INTEGER *)& result);
return (clock_t)result;
}
#else
#include <time.h>
#endif
//计算圆周率PI
TLargeFloat GetBorweinPI(unsigned long uiDigitsLength);
TLargeFloat GetAGMPI(unsigned long uiDigitsLength);
TLargeFloat GetChudnovskyPI(unsigned long uiDigitsLength);
void Debug_toCout(const std::string& strx,const TLargeFloat& x)//调试输出
{ std::cout<<strx<<std::endl<<x<< std::endl; }
int main()
{
try
{
LargeFloat_UnitTest();
TLargeFloat x( 0.0,TLargeFloat::TDigits(100 ));
x=1 ;
Debug_toCout("1/7:=",x/7 );
x.StrToLargeFloat("12345678987654321" );
Debug_toCout("12345678987654321*12345678987654321 := ",x* x);
x=2 ;
Debug_toCout("2^0.5 := " ,sqrt(x));
//test PI
std::cout<<std::endl<<"请输入需要PI的有效位数:" ;
long pi_length=0; std::cin>>pi_length; std::cout<< std::endl;
clock_t t0= clock();
x=GetAGMPI(pi_length); //
//x=GetBorweinPI(pi_length)
t0=clock()- t0;
Debug_toCout("PI := " ,x);
std::cout<<"PI计算时间:"<<(t0*1.0/CLOCKS_PER_SEC)<<" 秒" ;
}
catch (const TLargeFloatException& lfe)
{
std::cout<<">> LargeFloat运算时发生异常: "<<lfe.what()<< std::endl;
}
catch (const std::exception& e)
{
std::cout<<">> 异常: "<<e.what()<< std::endl;
}
catch (...)
{
std::cout<<">> 未知的异常! "<< std::endl;
}
std::cout<< std::endl;
std::cout<<"...end..."<< std::endl;
char c; std::cin>> c;
return 0 ;
}
//计算圆周率PI
TLargeFloat GetBorweinPI(unsigned long uiDigitsLength)
{
// Borwein四次迭代式：
// 初值： a0=6-4*2^0.5; y0=2^0.5-1;
// 重复计算： y(n+1)=[1-(1-y^4)^0.25]/[1+(1-y^4)^0.25];
// y=y(n+1);
// a(n+1)=a*(1+y)^4-2^(2*n+3)*y*(1+y+y*y);
// 最后计算： PI=1/a;
// 迭代次数和10进制有效精度 每迭代一次有效精度增长4倍
// 0 1 2 3 4 5 6 ...
//0 8 40 170 693 2789 11171 ...
long loop_count;
if (uiDigitsLength<=8 )
loop_count=1 ;
else if (uiDigitsLength<=40 )
loop_count=2 ;
else if (uiDigitsLength<=170 )
loop_count=3 ;
else if (uiDigitsLength<=693 )
loop_count=4 ;
else if (uiDigitsLength<=2789 )
loop_count=5 ;
else
{
loop_count=6 ;
long DigitsLength=11171 ;
while (DigitsLength<(long )uiDigitsLength)
{
DigitsLength*=4;//四阶收敛
++ loop_count;
}
}
std::cout<<" ... 开始计算PI,Borwein四次迭代式, 总循环次数："<<loop_count<<" ... "<< std::endl;
TLargeFloat::TDigits sCount(uiDigitsLength);//计算采用的十进制精度
TLargeFloat a( 0.0,sCount),y(0.0 ,sCount);
TLargeFloat temp(0.0 ,sCount);
TLargeFloat pow(2*2*2,sCount); // 2^(2*n+3); (n=0);
//a0=6-4*2^0.5;
temp=2 ;
temp.Sqrt();
a=6-4* temp;
//y0=2^0.5-1;
y=temp-1 ;
TLargeFloat tmpa(0.0 ,sCount);
for (long i=0;i<loop_count;++ i)
{
std::cout<<" ... 计算PI "<<uiDigitsLength<<" 位的当前循环次数："<<i+1<<"/"<<loop_count<<" ... "<< std::endl;
temp=1- sqr(sqr(y));
temp=revsqrt(revsqrt(temp));//等价于 temp=sqrt(sqrt(temp));
y=(1-temp)/(1+ temp);
temp=sqr(1+ y);
a=a*sqr(temp)-pow*y*(temp- y);
pow*=4 ;
}
std::cout<<" ... 计算PI的循环结束，准备输出 ... "<< std::endl;
return 1/a;//PI=1/a;
}
TLargeFloat GetAGMPI(unsigned long uiDigitsLength)
{
// AGM二次迭代式:
// 初值:a=x=1 b=1/sqrt(2) c=1/4
// 重复计算:y=a a=(a+b)/2 b=sqrt(by) c=c-x(a-y)^2 x=2x
// 最后:pi=(a+b)^2/(4c)
// 迭代次数和10进制有效精度 每迭代一次有效精度增长2倍
// 0 1 2 3 4 5 6 7 8 ...
//1 39 82 169 344 693 1391 2788 5582 ...
long loop_count;
if (uiDigitsLength<=39 )
loop_count=1 ;
else if (uiDigitsLength<=82 )
loop_count=2 ;
else if (uiDigitsLength<=169 )
loop_count=3 ;
else if (uiDigitsLength<=344 )
loop_count=4 ;
else if (uiDigitsLength<=693 )
loop_count=5 ;
else if (uiDigitsLength<=1391 )
loop_count=6 ;
else if (uiDigitsLength<=2788 )
loop_count=7 ;
else
{
loop_count=8 ;
long DigitsLength=5582 ;
while (DigitsLength<(long )uiDigitsLength)
{
DigitsLength*=2;//2阶收敛
++ loop_count;
}
}
std::cout<<" ... 开始计算PI,AGM二次迭代式, 总循环次数："<<loop_count<<" ... "<< std::endl;
TLargeFloat::TDigits sCount(uiDigitsLength);//计算采用的十进制精度
TLargeFloat c( 8,sCount); c.RevSqrt(); c.Chs(); //c=-sqrt(1/8);
TLargeFloat a(c); a*=(-3); a+=1; //a=1-3*c;
TLargeFloat b(a); b.Sqrt(); //b=sqrt(a);
TLargeFloat e("-0.625"); e += b; //e=b-0.625
b *= 2 ;
c += e;
a += e;
long npow=4 ;
for (long i=0;i<loop_count;++ i)
{
std::cout<<" ... 计算PI "<<uiDigitsLength<<" 位的当前循环次数："<<i+1<<"/"<<loop_count<<" ... "<< std::endl;
e = a;
e += b;
e /= 2 ;
b *= a;
b.Sqrt();
e -= b;
b *= 2 ;
c -= e;
a = e;
a += b;
npow *= 2 ;
}
std::cout<<" ... 计算PI的循环结束，准备输出 ... "<< std::endl;
e *= e;
e /= 4 ;
a += b;
c *= a;
c -= e;
c *= npow;
a *= a;
a-= e;
e/=2 ;
a-= e;
a/= c;
return a;
}
//
///