#包括“logicle.h”
#包括“mex.h”
#包括< memory.h >
#因为包括<字符串>
#包括< cstdio >
#包括< cmath >
#包括<规定>
常量双Logicle:: DEFAULT_DECADES = 4.5;
常量双重Logicle:: LN_10 =日志(10)。;
常量双Logicle::ε= std:: numeric_limits <二>::ε();
常量双Logicle::南= std:: numeric_limits <二>::quiet_NaN ();
常量int Logicle: TAYLOR_LENGTH = 16;
Logicle::例外::异常()
{
缓冲= 0;
}
Logicle::例外::异常(const Logicle:异常& e)
{
缓冲=第6行的e.buffer);
}
Logicle::例外::异常(const char * const消息)
{
缓冲=第6行的(消息);
}
Logicle::例外::~异常()
{
删除缓冲区;
}
常量char * Logicle::例外::消息()常量
{
返回缓冲区;
}
Logicle: IllegalArgument:: IllegalArgument(双值)
{
缓冲= new char [128];
sprintf(缓冲区,“非法参数值% .17g”、价值);
}
Logicle: IllegalArgument:: IllegalArgument (int值)
{
缓冲= new char [128];
sprintf(缓冲区,“非法参数值% d”、价值);
}
Logicle: IllegalParameter: IllegalParameter (const char * const消息):异常(消息)
{}
Logicle: DidNotConverge: DidNotConverge (const char * const消息):异常(消息)
{}
无效Logicle::初始化(双T,双W,双,双,int垃圾箱)
{
/ /分配参数结构
p =新logicle_params;
泰勒p - > = 0;
如果(T < = 0)
扔“IllegalParameter: T是不积极”;
/ /把IllegalParameter (“T不积极”);
如果(W < 0)
扔“IllegalParameter: W是不积极”;
/ /把IllegalParameter (“W不是积极的”);
如果(M < = 0)
扔“IllegalParameter: M不是积极的”;
/ /把IllegalParameter (“M不积极”);
如果(2 * W > M)
扔“IllegalParameter: W太大”;
/ /把IllegalParameter (“W”太大);
如果(——> W | | + W > M - W)
扔“IllegalParameter:太大”;
/ /把IllegalParameter (“太大”);
/ /如果我们会本数据确保
/ / 0本边界通过调整
如果(垃圾箱> 0)
{
双零= (W + A) / (M + 1);
0 =地板(零*箱+ 5)/箱;
= (M * 0 - W) / (1 - 0);
}
/ /标准参数
p - > T = T;
p - > M = M;
p - > W = W;
p - > =一个;
/ /实际参数
/ /公式biexponential纸
p - > w = w / (M + 1);
p - > x2 = / (M + A);
p - > x1 = p - > x2 + p - > w;
p - > x0 = p - > x2 + 2 * p - > w;
p - > b = (M + 1) * LN_10;
p - > d =解决(p - > b、p - > w);
双c_a = exp (p - > x0 * (p - > b + p - > d));
双mf_a = exp (p - > b * p - > x1) - c_a / exp (p - > d * p - > x1);
p - > = T / ((exp (p - > b) - mf_a) - c_a / exp (p - > d));
p - > c = c_a * p - >;
p - > f = -mf_a * p - >;
/ /使用泰勒系列x1附近,即、数据0到
/ /避免轮正式定义的问题
p - > xTaylor = p - > x1 + p - > w / 4;
/ /计算系数泰勒级数的
双posCoef = p - > * exp (p - > b * p - > x1);
双negCoef = - p - > c / exp (p - > d * p - > x1);
/ / 16够充分典型天平的精度
泰勒p - > = new双(TAYLOR_LENGTH);
为(int i = 0;我< TAYLOR_LENGTH;+ + i)
{
posCoef * = p - > b / (i + 1);
negCoef * = - p - > d / (i + 1);
(p - >泰勒)[我]= posCoef + negCoef;
}
p - >泰勒[1]= 0;/ /准确的结果Logicle条件
}
Logicle:: Logicle(双T,双W,双,双)
{
初始化(T, W, M, 0);
}
Logicle:: Logicle(双T,双W,双,双,int垃圾箱)
{
初始化(T, W, M,垃圾箱);
}
Logicle: Logicle (const Logicle & Logicle)
{
p =新logicle_params;
logicle memcpy (p。p, sizeof (logicle_params));
泰勒p - > = new双(TAYLOR_LENGTH);
memcpy (p - >泰勒logicle。p - >泰勒TAYLOR_LENGTH * sizeof(双));
}
Logicle:: ~ Logicle ()
{
删除泰勒p - >;
删除p;
}
/ / f (w, b) = 2 * (ln (d) - ln (b)) + w * (b + d)
双logicle_fn(双x, void *信息){
结构体sfun_info * p = (struct sfun_info *)信息;
双B = 2 * (log (x) - log (p - > B)) + p - > w * (p - > B + x);
返回(B);
}
/ *
*根仪从统计/ src / zeroin.c例程被复制
* /
双Logicle:: R_zeroin(/ *估计根* /
双斧头,/ *左边界的|范围* /
双bx,/ *右边界|根被查找* /
双(*)(双x, void *信息),/ *功能调查* /
无效*信息/ *添加的信息传递给f* /
双*托尔,/ *可接受的公差* /
int麦克斯特)/ * *马克斯#的迭代* /
{
双足总= f (*) (ax,信息);
双fb = f (*) (bx,信息);
返回R_zeroin2 (ax, bx、fa、fb, f,信息,托尔,麦克斯特);
}
/ * R_zeroin2 ()更快的“昂贵的”f (),在典型情况下的
* f (ax)和f (bx)可用:* /
双Logicle:: R_zeroin2(/ *估计根* /
双斧头,/ *左边界的|范围* /
双bx,/ *右边界|根被查找* /
双足总、双神奇动物/ * f (a), f (b) * /
双(*)(双x, void *信息),/ *功能调查* /
无效*信息/ *添加的信息传递给f* /
双*托尔,/ *可接受的公差* /
int麦克斯特)/ * *马克斯#的迭代* /
{
双a, b, c,足球俱乐部;/ * Abscissae,备注说明。见上图,f (c) * /
双托尔;
int麦克斯特;
= ax;b = bx;
c =;fc =足总;
麦克斯特麦克斯特+ = * 1;托尔= *托尔;
/ *第一个测试如果我们有发现了一根在端点* /
如果(fa = = 0.0) {
* Tol = 0.0;
*麦克斯特= 0;
返回一个;
}
如果(fb = = 0.0) {
* Tol = 0.0;
*麦克斯特= 0;
返回b;
}
而麦克斯特——()/ *主要迭代循环* /
{
双prev_step = b;/ *距离倒数第二
最后一个近似* /
双tol_act;/ *实际公差* /
双p;/ *插值一步是计算- * /
双问;/ *迟来的p / q形式;红利,
*锡安操作延迟
直到最后一刻* / *
双new_step;在这个迭代* / / *步骤
如果(晶圆厂(fc) <晶圆厂(fb))
{/ *交换数据为b是* /
a = b;b = c;c =;/ *最佳逼近* /
fa = fb;fb = fc;fc =足总;
}
tol_act = 2 *ε*晶圆厂(b) +托尔/ 2;
new_step = (cb) / 2;
如果(晶圆厂(new_step) < = tol_act | | fb = = 0)(双)
{
麦克斯特- * =麦克斯特;
* Tol =晶圆厂(cb);
返回b;/ *接受的约。被发现* /
}
/ *决定如果插值可以试着* /
如果(晶圆厂(prev_step) > = tol_act / * prev_step是不是足够大* /
& &晶圆厂(fa) >晶圆厂(fb)){/ *,在真正的方向,
*插值可能被审判* /
注册双t1、cb、t2;
cb = cb;
如果(= = c){/ *如果我们只有两个截然不同的* /
/ *点线性插值* /
t1 = fb / fa;/ *只能被应用* /
p = cb * t1;
q = 1.0 - t1;
}
其他的{/ *逆二次曲面插值* /
q = fa / fc;t1 = fb / fc;t2 = fb / fa;
p = t2 * (cb * q * (q-t1)——(b) * (t1 - 1.0));
q = (q - 1.0) * (t1 - 1.0) * (t2 - 1.0);
}
如果(p >(双)0)/ * p计算* /
q = - q;/ *相反的迹象;使p积极* /
其他的/ *和分配可能的-* /
p = - p;/ * * /
如果(p < (0.75 * cb * q-fabs (tol_act * q) / 2) / *如果b + p / q [b, c] * /
& & p <晶圆厂(prev_step * q / 2)) / *也不是大* /
new_step = p / q;/ *这是接受
*如果p / q太大的
*二等分的过程可以
*减少[b, c]范围更多的
*程度* /
}
如果(晶圆厂(new_step) < tol_act){/ *调整步骤少不是* /
如果(new_step >(双)0)/ *比宽容* /
new_step = tol_act;
其他的
new_step = -tol_act;
}
a = b;fa = fb;/ *保存以前的约。* /
b+ = new_step;fb = f (*) (b,信息);/ *做一步到一个新的approxim。* /
如果((神奇动物> 0 & & fc > 0) | | (fb < 0 & & fc < 0)) {
/ *调整c有一个符号相反的b * /
c =;fc =足总;
}
}
/ *失败!* /
* Tol =晶圆厂(cb);
*麦克斯特= 1;
返回b;
}
/ *
*使用R内置的根器API: R_zeroin
* /
双Logicle::解决(双b,双w)
{
/ / w = = 0意味着它真的arcsinh
如果(w = = 0)
返回b;
/ /精度b的一样
双公差= 2 * b *ε;
结构体sfun_info参数;
params.b = b;
params.w = w;
/ /支架根
双d_lo = 0;
双d_hi = b;
int麦克斯特= 20;
双d;
d = R_zeroin (d_lo d_hi、logicle_fn (void *)参数,宽容,麦克斯特);
返回d;
}
双Logicle:斜率(双尺度)常量
{
/ /反映负面规模地区
如果(规模< p - > x1)
规模= 2 * p - > x1 -规模;
/ /计算的斜率biexponential
返回p - > * p - > b * exp (p - > b *规模)+ p - > c * p - > d / exp (p - > d *规模);
}
双Logicle: seriesBiexponential(双尺度)常量
{
/ /泰勒级数在x1
双x = - p - > x1规模;
/ /注意,泰勒称[1]应该等于零
/ / Logicle条件这里跳过它
双= p - >和泰勒(TAYLOR_LENGTH - 1) * x;
为(int i = TAYLOR_LENGTH - 2;我> = 2;——我)
金额=(总和+ p - >泰勒[我])* x;
返回(金额* x + p - >泰勒[0])* x;
}
双Logicle:规模(双精度值)常量
{
/ /分别处理真正的零
如果(值= = 0)
返回p - > x1;
/ /反映负值
bool- =值< 0;
如果(负面)
值=价值;
/ /初始猜测在解决方案
双x;
如果(< p - > f值)
/ /使用线性在准线性近似
x = p - > x1 +价值/ p - >泰勒[0];
其他的
/ /否则使用普通的对数
x =日志(价值/ p - >) / p - > b;
/ /尝试双精度除非在扩展范围
双公差= 3 *ε;
如果(x > 1)
公差= 3 * x *ε;
为(int i = 0;我< 10;+ + i)
{
/ /计算函数和它的前两个衍生品
双ae2bx = p - > * exp (p - > b * x);
双ce2mdx = p - > c / exp (p - > d * x);
双y;
如果(x < p - > xTaylor)
/ /接近于零利用泰勒级数
y = seriesBiexponential (x)值;
其他的
/ /这个配方有更好的舍入行为
y = f (ae2bx + p - >) - (ce2mdx +价值);
双* ae2bx abe2bx = p - > b;
双cde2mdx = p - > d * ce2mdx;
双dy = abe2bx + cde2mdx;
双ddy = p - > b * abe2bx - p - > d * cde2mdx;
/ /这是哈雷与立方收敛的方法
双δ= y / (dy * (1 - y * ddy / (2 * dy * (dy)));
x- =δ;
/ /如果我们已经达到了所需的精度我们做完了
如果(std:: abs(δ)<公差){
/ /处理负参数
如果(负面)
返回2 * p - > x1 - x);
其他的
返回x;
}
}
扔“DidNotConverge:规模()没有收敛”;
/ /把DidNotConverge (“规模()没有收敛”);
}
双Logicle:逆(双尺度)常量
{
/ /反映负面规模地区
bool消极= < p - > x1规模;
如果(负面)
规模= 2 * p - > x1 -规模;
/ /计算biexponential
双逆;
如果(< p - > xTaylor规模)
/ /附近x1,即。、数据0用级数展开
逆= seriesBiexponential(规模);
其他的
/ /这个配方有更好的舍入行为
逆= (p - > * exp (p - > b *规模)+ p - > f) - p - > c / exp (p - > d *规模);
/ /处理规模对于负
如果(负面)
返回逆;
其他的
返回逆;
}
双const Logicle:动态范围()
{
返回斜率(1)/斜率(p - > x1);
}
intPullInMyLibrary(){返回0;}
