- html - 出于某种原因,IE8 对我的 Sass 文件中继承的 html5 CSS 不友好?
- JMeter 在响应断言中使用 span 标签的问题
- html - 在 :hover and :active? 上具有不同效果的 CSS 动画
- html - 相对于居中的 html 内容固定的 CSS 重复背景?
我正尝试在 VS2013 上以 Release x64 模式构建 Quantlib。
我使用 Property Manager 添加了 Boost 库,然后转到解决方案资源管理器并单击“构建”。
最终输出为:构建:18 次成功,1 次失败。 0 个最新,0 个跳过。
当我双击错误时,这个文件打开了 (convolvedstudentt.cpp)
Copyright (C) 2014 Jose Aparicio
This file is part of QuantLib, a free-software/open-source library
for financial quantitative analysts and developers - http://quantlib.org/
QuantLib is free software: you can redistribute it and/or modify it
under the terms of the QuantLib license. You should have received a
copy of the license along with this program; if not, please email
<quantlib-dev@lists.sf.net>. The license is also available online at
<http://quantlib.org/license.shtml>.
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the license for more details.
*/
#include <ql/experimental/math/convolvedstudentt.hpp>
#include <ql/errors.hpp>
#include <ql/math/factorial.hpp>
#include <ql/math/distributions/normaldistribution.hpp>
#include <ql/math/solvers1d/brent.hpp>
#include <boost/function.hpp>
#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#endif
#include <boost/bind.hpp>
#include <boost/math/distributions/students_t.hpp>
#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)) || (__GNUC__ > 4))
#pragma GCC diagnostic pop
#endif
namespace QuantLib {
CumulativeBehrensFisher::CumulativeBehrensFisher(
const std::vector<Integer>& degreesFreedom,
const std::vector<Real>& factors
)
: degreesFreedom_(degreesFreedom), factors_(factors),
polyConvolved_(std::vector<Real>(1, 1.)), // value to start convolution
a_(0.)
{
QL_REQUIRE(degreesFreedom.size() == factors.size(),
"Incompatible sizes in convolution.");
for(Size i=0; i<degreesFreedom.size(); i++) {
QL_REQUIRE(degreesFreedom[i]%2 != 0,
"Even degree of freedom not allowed");
QL_REQUIRE(degreesFreedom[i] >= 0,
"Negative degree of freedom not allowed");
}
for(Size i=0; i<degreesFreedom_.size(); i++)
polynCharFnc_.push_back(polynCharactT((degreesFreedom[i]-1)/2));
// adjust the polynomial coefficients by the factors in the linear
// combination:
for(Size i=0; i<degreesFreedom_.size(); i++) {
Real multiplier = 1.;
for(Size k=1; k<polynCharFnc_[i].size(); k++) {
multiplier *= std::abs(factors_[i]);
polynCharFnc_[i][k] *= multiplier;
}
}
//convolution, here it is a product of polynomials and exponentials
for(Size i=0; i<polynCharFnc_.size(); i++)
polyConvolved_ =
convolveVectorPolynomials(polyConvolved_, polynCharFnc_[i]);
// trim possible zeros that might have arised:
std::vector<Real>::reverse_iterator it = polyConvolved_.rbegin();
while(it != polyConvolved_.rend()) {
if(*it == 0.) {
polyConvolved_.pop_back();
it = polyConvolved_.rbegin();
}else{
break;
}
}
// cache 'a' value (the exponent)
for(Size i=0; i<degreesFreedom_.size(); i++)
a_ += std::sqrt(static_cast<Real>(degreesFreedom_[i]))
* std::abs(factors_[i]);
a2_ = a_ * a_;
}
Disposable<std::vector<Real> >
CumulativeBehrensFisher::polynCharactT(Natural n) const {
Natural nu = 2 * n +1;
std::vector<Real> low(1,1.), high(1,1.);
high.push_back(std::sqrt(static_cast<Real>(nu)));
if(n==0) return low;
if(n==1) return high;
for(Size k=1; k<n; k++) {
std::vector<Real> recursionFactor(1,0.); // 0 coef
recursionFactor.push_back(0.); // 1 coef
recursionFactor.push_back(nu/((2.*k+1.)*(2.*k-1.))); // 2 coef
std::vector<Real> lowUp =
convolveVectorPolynomials(recursionFactor, low);
//add them up:
for(Size i=0; i<high.size(); i++)
lowUp[i] += high[i];
low = high;
high = lowUp;
}
return high;
}
Disposable<std::vector<Real> >
CumulativeBehrensFisher::convolveVectorPolynomials(
const std::vector<Real>& v1,
const std::vector<Real>& v2) const {
#if defined(QL_EXTRA_SAFETY_CHECKS)
QL_REQUIRE(!v1.empty() && !v2.empty(),
"Incorrect vectors in polynomial.");
#endif
const std::vector<Real>& shorter = v1.size() < v2.size() ? v1 : v2;
const std::vector<Real>& longer = (v1 == shorter) ? v2 : v1;
Size newDegree = v1.size()+v2.size()-2;
std::vector<Real> resultB(newDegree+1, 0.);
for(Size polyOrdr=0; polyOrdr<resultB.size(); polyOrdr++) {
for(Size i=std::max<Integer>(0, polyOrdr-longer.size()+1);
i<=std::min(polyOrdr, shorter.size()-1); i++)
resultB[polyOrdr] += shorter[i]*longer[polyOrdr-i];
}
return resultB;
}
Probability CumulativeBehrensFisher::operator()(const Real x) const {
// 1st & 0th terms with the table integration
Real integral = polyConvolved_[0] * std::atan(x/a_);
Real squared = a2_ + x*x;
Real rootsqr = std::sqrt(squared);
Real atan2xa = std::atan2(-x,a_);
if(polyConvolved_.size()>1)
integral += polyConvolved_[1] * x/squared;
for(Size exponent = 2; exponent <polyConvolved_.size(); exponent++) {
integral -= polyConvolved_[exponent] *
Factorial::get(exponent-1) * std::sin((exponent)*atan2xa)
/std::pow(rootsqr, static_cast<Real>(exponent));
}
return .5 + integral / M_PI;
}
Probability
CumulativeBehrensFisher::density(const Real x) const {
Real squared = a2_ + x*x;
Real integral = polyConvolved_[0] * a_ / squared;
Real rootsqr = std::sqrt(squared);
Real atan2xa = std::atan2(-x,a_);
for(Size exponent=1; exponent <polyConvolved_.size(); exponent++) {
integral += polyConvolved_[exponent] *
Factorial::get(exponent) * std::cos((exponent+1)*atan2xa)
/std::pow(rootsqr, static_cast<Real>(exponent+1) );
}
return integral / M_PI;
}
InverseCumulativeBehrensFisher::InverseCumulativeBehrensFisher(
const std::vector<Integer>& degreesFreedom,
const std::vector<Real>& factors,
Real accuracy)
: normSqr_(std::inner_product(factors.begin(), factors.end(),
factors.begin(), 0.)),
accuracy_(accuracy), distrib_(degreesFreedom, factors) { }
Real InverseCumulativeBehrensFisher::operator()(const Probability q) const {
Probability effectiveq;
Real sign;
// since the distrib is symmetric solve only on the right side:
if(q==0.5) {
return 0.;
}else if(q < 0.5) {
sign = -1.;
effectiveq = 1.-q;
}else{
sign = 1.;
effectiveq = q;
}
Real xMin =
InverseCumulativeNormal::standard_value(effectiveq) * normSqr_;
// inversion will fail at the Brent's bounds-check if this is not enough
// (q is very close to 1.), in a bad combination fails around 1.-1.e-7
Real xMax = 1.e6;
return sign *
Brent().solve(boost::bind(std::bind2nd(std::minus<Real>(),
effectiveq), boost::bind<Real>(
&CumulativeBehrensFisher::operator (),
distrib_, _1)), accuracy_, (xMin+xMax)/2., xMin, xMax);
}
}
错误似乎在倒数第三行。这是突出显示的那个。
effectiveq), boost::bind<Real>(
&CumulativeBehrensFisher::operator (),
distrib_, _1)), accuracy_, (xMin+xMax)/2., xMin, xMax);
当我将鼠标悬停在它上面时,它会显示
错误:重载函数“boost::bind”的多个实例与参数列表匹配:函数模板“boost_bi::bind_t”等。请参阅附件截图
我该如何解决这个问题?请帮忙。
最佳答案
这最近在 QuantLib 邮件列表中出现了好几次。简而言之,该代码适用于 Boost 1.57(QuantLib 1.5 发布时的最新版本),但与 Boost 1.58 不兼容。
在 QuantLib master branch on GitHub 中有一个修复程序,但它还没有发布。如果你想(或不得不)使用 Boost 1.58,你可以从那里查看最新的代码。如果您想改用已发布的 QuantLib 版本,解决方法是降级到 Boost 1.57。
关于c++ - 错误 C2668 : 'boost::bind' : ambiguous call to overloaded function,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/30406234/
“过载”/“过载”在编程方面是什么意思? 最佳答案 这意味着您提供了一个具有相同名称但具有不同签名的函数(方法或运算符)。 例如: void doSomething(); int doSomethin
Kotlin 是允许我们轻松定义各种预定义运算符行为的语言之一,该操作名为运算符重载 - https://kotlinlang.org/docs/reference/operator-overload
所以我正在尝试实现 xorshift PRNG 作为来自 random 的参数化 STL 样式类,例如std::mersenne_twister_engine , 所以我可以将它与来自 random
请给我一个具体的答案,为什么函数覆盖会隐藏基类中重载的函数。 class Base{ public: fun(int,int); fun(B); }; class Derived:public
假设我在 Alloy 4.2 中有以下签名声明: sig Target {} abstract sig A { parent: lone A, r: some Target } sig
我正在对API进行建模,其中方法重载将是一个很好的选择。我的幼稚尝试失败了: // fn attempt_1(_x: i32) {} // fn attempt_1(_x: f32) {} // Er
在方法重载中,重载方法是否可以有不同的返回类型? 例如, void foo(int x) ; int foo(int x,int y); double foo(String str); 在一般的面向对
这个问题已经有答案了: Why is implicit conversion from int to Long not possible? (3 个回答) 已关闭 5 年前。 使用包装类重载方法 vo
我正在为一个 API 建模,其中方法重载非常适合。我天真的尝试失败了: // fn attempt_1(_x: i32) {} // fn attempt_1(_x: f32) {} // Error
我正在为一个 API 建模,其中方法重载非常适合。我天真的尝试失败了: // fn attempt_1(_x: i32) {} // fn attempt_1(_x: f32) {} // Error
1、方法的重载 方法名一样,但参数不一样,这就是重载(overload)。 所谓的参数不一样,主要有两点:第一是参数的个数不一样,第二是参数的类型不一样。只要这两方面有其中的一
我正在设计我自己的编程语言(称为 Lima,如果你在 www.btetrud.com 上关心它),我正在努力思考如何实现运算符重载。我决定在特定对象上绑定(bind)运算符(它是一种基于原型(prot
我正在尝试将运算符用于 Wicket,这非常冗长。 我最想要的功能是使用一元“+”到add()一个组件。 但它需要在每个 MarkupContainer 的上下文中工作。后人。 使用应该是这样的: c
运算符重载如何与函数重载相关联。我的意思是我不太明白如何使用自身已重载的函数来重载运算符。 最佳答案 Operator 只是给中缀函数(写在参数之间的函数)的时髦名称。所以,1 + 2 只是一个 +(
是否有可能过载 __cinit__或 __add__ ? 像这样的东西: cdef class Vector(Base): cdef double x, y, z def __cini
我开始使用 smalltalk,我正在尝试添加一个新的赋值运算符 :> . pharo 中使用的当前运算符不是选择器,所以我开始查看下划线 _ 的类 Scanner可以为分配启用。我试图以类似的方式做
假设我有以下类(class): class A { has $.val; method Str { $!val ~ 'µ' } } # Is this the right way
我试图像这样重载>>运算符: class A {} multi sub infix:«>>»(A:D $a, Str() $b) is assoc { dd $a; dd $b } my $x = A
在 C++ 中,您可以创建使用特定运算符的模板类 模板化对象和实例化这些对象的类 必须重载该特定运算符才能使其对象与 模板类。例如,insertion BST实现的方法 可能依赖 Nil ) {
有时,我在未重载的方法后面有“overload”关键字。 除了代码的可读性和可维护性之外,这还有我应该注意的其他影响吗? 最佳答案 最大的区别在于,当方法的参数不正确时,错误消息对于非重载方法来说明显
我是一名优秀的程序员,十分优秀!