void test3() {
#ifdef MAKE_TEST3
std::cout << "Multidimensional test:" << std::endl;
// Construct data for the IVP
double T = 1;
// Many dimensions
int n = 5;
// Multidimensional rhs
Eigen::VectorXd y0(2*n);
for(int i = 0; i < n; ++i) {
y0(i)=(i+1.)/n;
y0(i+n)=-1;
}
// Multidimensional rhs
auto f = [n] (Eigen::VectorXd y) {
Eigen::VectorXd fy(2*n);
Eigen::VectorXd g(n);
g(0) = y(0)*(y(1)+y(0));
g(n-1) = y(n-1)*(y(n-1)+y(n-2));
for(int i = 1; i < n-1; ++i) {
g(i) = y(i)*(y(i-1)+y(i+1));
}
Eigen::SparseMatrix<double> C(n,n);
C.reserve(3);
for(int i = 0; i < n; ++i) {
C.insert(i,i) = 2;
if(i < n-1) C.insert(i,i+1) = -1;
if(i >= 1) C.insert(i,i-1) = -1;
}
C.makeCompressed();
fy.head(n) = y.head(n);
Eigen::SparseLU< Eigen::SparseMatrix<double> > solver;
solver.analyzePattern(C);
solver.compute(C);
fy.tail(n) = solver.solve(g);
return fy;
};
// Constructor:
ode45<Eigen::VectorXd> O(f);
// Setup options
O.options.do_statistics = true;
// Solve
auto sol = O.solve(y0, T);
// Print info
O.print();
std::cout << "T = " << sol.back().second << std::endl;
std::cout << "y(T) = " << std::endl << sol.back().first << std::endl;
#endif
}
double
yn (int n, double x)
{
int i, sign;
double a, b, tmp;
if (x <= 0)
return (dzero/dzero); /* IEEE machines: invalid operation */
sign = 1;
if (n < 0)
{
n = -n;
if (n%2 == 1)
sign = -1;
}
if (n == 0)
return y0(x);
if (n == 1)
return sign*y1(x);
a = y0(x);
b = y1(x);
for (i = 1; i<n; i++)
{
tmp = b;
b = (2.0*i / x) * b - a;
a = tmp;
}
return sign*b;
}
KUKADU_SHARED_PTR<Dmp> GeneralDmpLearner::fitTrajectories() {
int dataPointsNum = joints.n_rows;
vec g(degFreedom);
vec y0(degFreedom);
vec dy0(degFreedom);
vec ddy0(degFreedom);
vector<vec> dmpCoeffs;
vector<vec> sampleYs;
vector<vec> fitYs;
vector<mat> designMatrices;
vec timeVec = joints.col(0);
mat all_y;
mat all_dy;
mat all_ddy;
// retrieve all columns for different degrees of freedom
vector<vec> trajectories;
for(int i = 1; i <= degFreedom; ++i) {
vec trajectory = joints.col(i);
trajectories.push_back(trajectory);
vec vec_dy = computeDiscreteDerivatives(timeVec, trajectory);
vec vec_ddy = computeDiscreteDerivatives(timeVec, vec_dy);
all_y = join_rows(all_y, trajectory);
all_dy = join_rows(all_dy, vec_dy);
all_ddy = join_rows(all_ddy, vec_ddy);
}
vector<trajectory_learner_internal> dmpResAll = fitTrajectory(timeVec, all_y, all_dy, all_ddy);
for(int i = 0; i < dmpResAll.size(); ++i) {
trajectory_learner_internal dmpRes = dmpResAll.at(i);
vec dmpCoeff = dmpRes.coeff;
vec fity = dmpRes.fity;
g(i) = (all_y.col(i))(dataPointsNum - 1);
y0(i) = all_y.col(i)(0);
dy0(i) = all_dy.col(i)(0);
ddy0(i) = all_ddy.col(i)(0);
dmpCoeffs.push_back(dmpCoeff);
fitYs.push_back(fity);
designMatrices.push_back(dmpRes.desMat);
}
for (int i = 0; i < all_y.n_cols; ++i) sampleYs.push_back(all_y.col(i));
return createDmpInstance(timeVec, sampleYs, fitYs, dmpCoeffs, dmpBase, designMatrices, tau, az, bz, ax);
}
double
yn(int n, double x)
{
int i, sign;
double a, b, temp;
/* Y(n,NaN), Y(n, x < 0) is NaN */
if (x <= 0 || isnan(x))
if (_IEEE && x < 0) return zero/zero;
else if (x < 0) return (infnan(EDOM));
else if (_IEEE) return -one/zero;
else return(infnan(-ERANGE));
else if (!finite(x)) return(0);
sign = 1;
if (n<0){
n = -n;
sign = 1 - ((n&1)<<2);
}
if (n == 0) return(y0(x));
if (n == 1) return(sign*y1(x));
if(_IEEE && x >= 8.148143905337944345e+090) { /* x > 2**302 */
/* (x >> n**2)
* Jn(x) = cos(x-(2n+1)*pi/4)*sqrt(2/x*pi)
* Yn(x) = sin(x-(2n+1)*pi/4)*sqrt(2/x*pi)
* Let s=sin(x), c=cos(x),
* xn=x-(2n+1)*pi/4, sqt2 = sqrt(2),then
*
* n sin(xn)*sqt2 cos(xn)*sqt2
* ----------------------------------
* 0 s-c c+s
* 1 -s-c -c+s
* 2 -s+c -c-s
* 3 s+c c-s
*/
switch (n&3) {
case 0: temp = sin(x)-cos(x); break;
case 1: temp = -sin(x)-cos(x); break;
case 2: temp = -sin(x)+cos(x); break;
case 3: temp = sin(x)+cos(x); break;
}
b = invsqrtpi*temp/sqrt(x);
} else {
a = y0(x);
b = y1(x);
/* quit if b is -inf */
for (i = 1; i < n && !finite(b); i++){
temp = b;
b = ((double)(i+i)/x)*b - a;
a = temp;
}
}
if (!_IEEE && !finite(b))
return (infnan(-sign * ERANGE));
return ((sign > 0) ? b : -b);
}
void OpenSMOKE_SolidRegression::ModelOdeRegression(int model, int ex, BzzVector &b, BzzVector &x, BzzVector &y)
{
int i;
for(i=1;i<=nCases;i++)
if(ex == indices[i])
{
cout << "Initialize " << i << "(" << ex << ")" << endl;
kOde[1] = b[1];
kOde[2] = b[2]/experiments[i].temperature;
kOde[3] = pow(experiments[i].pressureO2, b[3]);
o.Deinitialize();
BzzVector y0(1, initialconditions_y[i]);
o.SetInitialConditions(y0, initialconditions_x[i], BzzOdeModel_01);
o.SetMinimumConstraints(&yMin);
//break;
}
for(i=1;i<=nCases;i++)
if(ex == indices[i])
{
cout << "Calculating " << i << "(" << ex << ")" << endl;
for(int j=1;j<=experiments[i].nPoints;j++)
{
cout << indices[i]+j-1 << "\t" << experiments[i].x[j] << endl;
yy = o(experiments[i].x[j]);
YY.SetRow(indices[i]+j-1,yy);
}
break;
}
YY.GetRow(ex, &y);
}
int main() {
double x = 1.0;
double y = 1.0;
int i = 1;
acosh(x);
asinh(x);
atanh(x);
cbrt(x);
expm1(x);
erf(x);
erfc(x);
isnan(x);
j0(x);
j1(x);
jn(i,x);
ilogb(x);
logb(x);
log1p(x);
rint(x);
y0(x);
y1(x);
yn(i,x);
# ifdef _THREAD_SAFE
gamma_r(x,&i);
lgamma_r(x,&i);
# else
gamma(x);
lgamma(x);
# endif
hypot(x,y);
nextafter(x,y);
remainder(x,y);
scalb(x,y);
return 0;
}
/**
* returns the spherical Bessel function of the second kind
* needed for continuum states
\param l = order of the function (orbital angular momentum)
\param rho = independent variable (rho = k * r)
*/
double sphericalB::y(int l, double rho)
{
switch (l)
{
case 0:
return y0(rho);
case 1:
return y1(rho);
case 2:
return y2(rho);
case 3:
return y3(rho);
case 4:
return y4(rho);
case 5:
return y5(rho);
case 6:
return y6(rho);
case 7:
return y7(rho);
default:
cout << "no l>6 programed in sphericalB" << endl;
return 0.;
}
}
void MyWidget::process()
{
ui->plainTextEdit->clear();
variant = ui->comboBox->currentIndex();
print(QString("Variant %1").arg(variant));
print(QString("[%1; %2]").arg(x0(), 0, 'g', 5).arg(xFinish(), 0, 'g', 3));
//calc
qreal x = x0(), y = y0(), z = z0();
for (int i = 1; x < xFinish() || qFuzzyCompare(x, xFinish()); ++i)
{
qreal k1 = h() * f(x, y, z);
qreal q1 = h() * g(x, y, z);
qreal k2 = h() * f(x + h() / 2.0, y + k1 / 2.0, z + q1 / 2.0);
qreal q2 = h() * g(x + h() / 2.0, y + k1 / 2.0, z + q1 / 2.0);
qreal k3 = h() * f(x + h() / 2.0, y + k2 / 2.0, z + q2 / 2.0);
qreal q3 = h() * g(x + h() / 2.0, y + k2 / 2.0, z + q2 / 2.0);
qreal k4 = h() * f(x + h(), y + k3, z + q3);
qreal q4 = h() * g(x + h(), y + k3, z + q3);
print(QString("#%1").arg(i));
print(QString("y(%1) = %2").arg(x, 0, 'g', 5).arg(y, 0, 'g', 5));
print(QString("y_ex(%1) = %2").arg(x, 0, 'g',5).arg(yt(x), 0, 'g', 5));
print(QString("error(%1) = %2").arg(x, 0, 'g',5).arg(ypo(y, x), 0, 'g', 5));
x += h();
y += (k1 + 2.0 * k2 + 2.0 * k3 + k4) / 6.0;
z += (q1 + 2.0 * q2 + 2.0 * q3 + q4) / 6.0;
}
}
void cofdm_map::set_data(ivec x)
{
cvec qv;
bvec ce;
int K = x.length();
int i;
ce.set_length(K); ce.ones();
#if (DEBUG_LEVEL == 3)
cout << "***** cofdm_map::set_data *****" << endl;
cout << "K=" << K << endl;
cout << "ce=" << ce << endl;
cout << "x=" << x << endl;
cout << "data_carriers=" << data_carriers << endl;
#endif
if( K == data_carriers.length() ) {
qv = qammod.process(ce,x);
#if (DEBUG_LEVEL == 3)
cout << "qv=" << qv << endl;
#endif
for (i=0; i<K; i++) {
y0(data_carriers(i))=qv(i);
}
}
else {
throw sci_exception("cofdm_map::set_data - x.size() <> data_carriers.size()=", data_carriers.length());
}
#if (DEBUG_LEVEL == 3)
cout << "y0(piltos) y0(zeros) migh have rubbish" << endl;
cout << "y0=" << y0 << endl;
cout << "+++++ cofdm_map::set_data +++++" << endl;
#endif
}
TEST(generateExpression, integrate_ode) {
static const bool user_facing = true;
std::stringstream msgs;
stan::lang::integrate_ode so; // null ctor should work and not raise error
std::string integration_function_name = "bar";
std::string system_function_name = "foo";
stan::lang::variable y0("y0_var_name");
y0.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable t0("t0_var_name");
t0.set_type(stan::lang::double_type());
stan::lang::variable ts("ts_var_name");
ts.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable theta("theta_var_name");
theta.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable x("x_var_name");
x.set_type(stan::lang::bare_array_type(stan::lang::double_type()));
stan::lang::variable x_int("x_int_var_name");
x.set_type(stan::lang::bare_array_type(stan::lang::int_type()));
stan::lang::integrate_ode so2(integration_function_name, system_function_name,
y0, t0, ts, theta, x, x_int);
stan::lang::expression e1(so2);
generate_expression(e1, user_facing, msgs);
EXPECT_EQ(msgs.str(),
"bar(foo_functor__(), y0_var_name, t0_var_name, ts_var_name, "
"theta_var_name, x_var_name, x_int_var_name, pstream__)");
}
//..
// Our verification program simply instantiate several 'MyGenericContainer'
// templates with the two test types above, and checks that the allocator
// slot is as expected:
//..
int usageExample()
{
bslma::TestAllocator ta0;
bslma::TestAllocator ta1;
//..
// With 'MyTestTypeWithNoBslmaAllocatorTraits', the slot should never be set.
//..
MyTestTypeWithNoBslmaAllocatorTraits x;
allocSlot = &ta0;
MyGenericContainer<MyTestTypeWithNoBslmaAllocatorTraits> x0(x);
ASSERT(&ta0 == allocSlot);
allocSlot = &ta0;
MyGenericContainer<MyTestTypeWithNoBslmaAllocatorTraits> x1(x, &ta1);
ASSERT(&ta0 == allocSlot);
//..
// With 'MyTestTypeWithBslmaAllocatorTraits', the slot should be set to the
// allocator argument, or to 0 if not specified:
//..
MyTestTypeWithBslmaAllocatorTraits y;
allocSlot = &ta0;
MyGenericContainer<MyTestTypeWithBslmaAllocatorTraits> y0(y);
ASSERT(0 == allocSlot);
allocSlot = &ta0;
MyGenericContainer<MyTestTypeWithBslmaAllocatorTraits> y1(y, &ta1);
ASSERT(&ta1 == allocSlot);
return 0;
}
void MainWindow::plot2(QCustomPlot *customPlot)
{
QVector<double> x0(pts), y0(pts);
update_w(w,1.0);
double y_inc = 1.0;
for (int i=0; i<pts; ++i) {
x0[i] = (double)0.5*i/pts;
y0[i] = y_inc*(w[i]);
}
order = get_order();
ui->order->setText(QApplication::translate("MainWindow", std::to_string(order).c_str(), 0));
ui->ripple->setText(QApplication::translate("MainWindow", std::to_string(ripple()).c_str(), 0));
ui->fc->setText(QApplication::translate("MainWindow", std::to_string(fc()).c_str(), 0));
customPlot->graph()->setData(x0, y0);
customPlot->graph()->setLineStyle(QCPGraph::lsLine); //(QCPGraph::LineStyle)(rand()%5+1));
customPlot->graph()->setScatterStyle(QCPScatterStyle::ssNone); // (QCP::ScatterStyle)(rand()%9+1));
QPen graphPen;
// graphPen.setColor(QColor(rand()%245+10, rand()%245+10, rand()%245+10));
//graphPen.setWidthF(rand()/(double)RAND_MAX*2+1);
graph_counter++;
graph_counter = graph_counter%9;
graphPen.setColor(QColor(Qt::GlobalColor(5+graph_counter)));
graphPen.setWidthF(2);
customPlot->graph()->setPen(graphPen);
customPlot->xAxis->setRange(0,0.5);
customPlot->yAxis->setRange(-90,10);
customPlot->legend->setVisible(true);
// customPlot->setInteraction(QCustomPlot::iSelectPlottables);
customPlot->graph()->setName(QString(shape.c_str()));
customPlot->replot();
}
void MainWindow::plot3(QCustomPlot *customPlot)
{
QVector<double> x0(pts), y0(pts);
update_w(w,1.0);
double y_inc = 1.0;
for (int i=0; i<pts; ++i) {
x0[i] = (double)0.5*i/pts;
y0[i] = y_inc*(w[i]);
}
customPlot->graph()->setData(x0, y0);
customPlot->graph()->setLineStyle(QCPGraph::lsLine);
customPlot->graph()->setScatterStyle(QCPScatterStyle::ssNone); // (QCP::ScatterStyle)(rand()%9+1));
QPen graphPen;
graphPen.setColor(QColor(Qt::GlobalColor(5+graph_counter)));
graphPen.setWidthF(2);
customPlot->graph()->setPen(graphPen);
customPlot->xAxis->setRange(0,0.5);
customPlot->yAxis->setRange(-90,10);
customPlot->legend->setVisible(true);
// customPlot->setInteraction(QCustomPlot::iSelectPlottables);
customPlot->graph()->setName(QString(shape.c_str()));
customPlot->replot();
}
void Foam::equationReader::evalDimsY0DimCheck
(
const equationReader * eqnReader,
const label index,
const label i,
const label storageOffset,
label& storeIndex,
dimensionSet& xDims,
dimensionSet sourceDims
) const
{
if
(
!xDims.dimensionless() && dimensionSet::debug
)
{
WarningIn("equationReader::evalDimsY0DimCheck")
<< "Dimension error thrown for operation ["
<< equationOperation::opName
(
operator[](index)[i].operation()
)
<< "] in equation " << operator[](index).name()
<< ", given by:" << token::NL << token::TAB
<< operator[](index).rawText();
}
dimensionedScalar ds("temp", xDims, 1.0);
xDims.reset(y0(ds).dimensions());
operator[](index)[i].assignOpDimsFunction
(
&Foam::equationReader::evalDimsY0
);
}
int main() {
// Dimension of state space
unsigned int d = 2;
// Final time for model
double T = 10.;
// Initial value for model
Eigen::VectorXd y0(d);
y0 << 100, 5;
// Array of number of steps (for convergence study)
std::vector<unsigned int> N = {128, 256, 512, 1024, 2048, 4096, 8192, 16384};
// Exact value y(10) at final time T = 10 (approximated)
Eigen::VectorXd yex(d);
yex << 0.319465882659820, 9.730809352326228;
// Coefficients and handle for prey/predator model
double alpha1 = 3.;
double alpha2 = 2.;
double beta1 = 0.1;
double beta2 = 0.1;
// TODO: implement functor f for rhs of y(t)' = f(y(t))
// Constructor
TaylorIntegrator<Eigen::VectorXd> tint;
// Start convergence study
std::cout << std::setw(15) << "N" << std::setw(15) << "error" << std::setw(15) << "rate" << std::endl;
// TODO: tabulate error for each N
}
ExecStatus
MultPlusDom<VA,VB,VC>::propagate(Space& home, const ModEventDelta& med) {
if (VA::me(med) != ME_INT_DOM) {
GECODE_ES_CHECK((prop_mult_plus_bnd<VA,VB,VC>(home,*this,x0,x1,x2)));
return home.ES_FIX_PARTIAL(*this,VA::med(ME_INT_DOM));
}
IntView y0(x0.varimp()), y1(x1.varimp()), y2(x2.varimp());
return prop_mult_dom<IntView>(home,*this,y0,y1,y2);
}
Type Foam::interpolation2DTable<Type>::operator()
(
const scalar valueX,
const scalar valueY
) const
{
// Considers all of the list in Y being equal
label nX = this->size();
const table& t = *this;
if (nX == 0)
{
WarningIn
(
"Type Foam::interpolation2DTable<Type>::operator()"
"("
"const scalar, "
"const scalar"
") const"
)
<< "cannot interpolate a zero-sized table - returning zero" << endl;
return pTraits<Type>::zero;
}
else if (nX == 1)
{
// only 1 column (in X) - interpolate to find Y value
return interpolateValue(t.first().second(), valueY);
}
else
{
// have 2-D data, interpolate
// find low and high indices in the X range that bound valueX
label x0i = Xi(lessOp<scalar>(), valueX, false);
label x1i = Xi(greaterOp<scalar>(), valueX, true);
if (x0i == x1i)
{
return interpolateValue(t[x0i].second(), valueY);
}
else
{
Type y0(interpolateValue(t[x0i].second(), valueY));
Type y1(interpolateValue(t[x1i].second(), valueY));
// gradient in X
scalar x0 = t[x0i].first();
scalar x1 = t[x1i].first();
Type mX = (y1 - y0)/(x1 - x0);
// interpolate
return y0 + mX*(valueX - x0);
}
}
}
/* Our C definition of the function bessely0 declared in Bessel.java */
JNIEXPORT jdouble JNICALL
Java_concolic_Bessel_bessely0(JNIEnv *env, jobject obj, jdouble x)
{
double y;
/* Call the Y0(x) Bessel function from the
standard C mathematical library */
y = y0(x);
return y;
}
void cofdm_map::set_pilots(bvec x)
{
int K = x.length();
complex<double> p1 ( PA , 0.0);
complex<double> p0 (-PA , 0.0);
int L = zero_carriers.length();
complex<double> c0 (0.0 , 0.0);
int i;
if( K == pilots_carriers.length() ) {
for (i=0; i<K; i++) {
y0(pilots_carriers(i))=x(i)?p1:p0;
}
for (i=0; i<L; i++) {
y0(zero_carriers(i))=c0;
}
}
else {
throw sci_exception("cofdm_map::set_pilots - x.size() <> pilots_carriers.size()=", pilots_carriers.length());
}
}
cvec cofdm_sel::get_sel( )
{
cvec cv;
int K = sel_carriers.length();
int i;
cv.set_length(K);
for (i=0; i<K; i++) {
cv(i)= y0(sel_carriers(i));
}
return (cv);
}
void Foam::equationReader::evalScalarFieldY0
(
const equationReader * eqnReader,
const label index,
const label i,
const label storageOffset,
label& storeIndex,
scalarField& x,
const scalarField& source
) const
{
y0(x, x);
}
void FirstOrderNonLinearODErEx1::Main(int argc, char **argv)
{
FirstOrderNonLinearODErEx1 nnl;
unsigned int N = 100;
unsigned int M = nnl.count();
double h = 0.01;
nnl.setDimension(Dimension(h, 0, static_cast<int>(N)));
DoubleVector y0(M);
for (unsigned int r=0; r<M; r++)
{
y0[r] = nnl.x(PointNodeODE(0.0, 0), r+1);
}
std::vector<DoubleVector> x;
nnl.cauchyProblem(0.0, y0, x, OdeSolverMethod::RK4);
for (unsigned int m=0; m<M; m++)
{
for (unsigned int n=0; n<=N; n++)
{
if (n%(N/10)==0) printf("%14.10f ", x[n][m]);
}
puts("");
}
IPrinter::printSeperatorLine();
for (unsigned int m=0; m<M; m++)
{
for (unsigned int n=0; n<=N; n++)
{
if (n%(N/10)==0) printf("%14.10f ", nnl.x(n*h, m+1));
}
puts("");
}
IPrinter::printSeperatorLine();
double norm[] = {0.0, 0.0, 0.0};
for (unsigned int m=0; m<M; m++)
{
norm[m] = 0.0;
for (unsigned int n=0; n<=N; n++)
{
norm[m] += (x[n][m]-nnl.x(n*h, m+1))*(x[n][m]-nnl.x(n*h, m+1));
}
norm[m] = sqrt(norm[m]);
}
printf("Norms: %.10f %.10f %.10f\n", norm[0], norm[1], norm[2]);
}
Simple_OPBuf1<INT,INT> *
FoncATrou_OPB_Comp<Type>::dup_comp()
{
return new
FoncATrou_OPB_Comp<Type>
(
_l,
x0(),
x1(),
y0(),
y1()
);
}
mp_int<A,T> pow(const mp_int<A,T>& x, const mp_int<A,T>& y)
{
if (y.size() == 1)
return pow(x, y[0]);
mp_int<A,T> y0(y);
y0.divide_by_2();
mp_int<A,T> y1(y0);
if (y.is_odd())
++y1;
return pow(x, y0) * pow(x, y1);
}
SEXP lnoResiduals(SEXP sp, SEXP excludeRadius){
if(!(isNumeric(excludeRadius) && LENGTH(excludeRadius) == 1))
Rf_error("Exclude radius must be a scalar");
if(R_ExternalPtrTag(sp) != install("covafillPointer"))
Rf_error("The pointer must be to a covafill object");
covafill<double>* ptr=(covafill<double>*)R_ExternalPtrAddr(sp);
double er = asDouble(excludeRadius);
MatrixXd x0 = ptr->coordinates;
vector y0 = ptr->observations;
vector res(y0.size());
for(int i = 0; i < x0.rows(); ++i)
res.row(i) = ptr->operator()((vector)x0.row(i),er) - y0(i);
return asSEXP(res);
}
void planner::graphInit(){
line=0;
// add two new graphs and set their look:
ui->plot->addGraph();
ui->plot->graph(0)->setPen(QPen(Qt::blue)); // line color blue for first graph
ui->plot->graph(0)->setBrush(QBrush(QColor(0, 0, 255, 20))); // first graph will be filled with translucent blue
ui->plot->addGraph();
ui->plot->graph(1)->setPen(QPen(Qt::green)); // line color red for second graph
fermatSpiral1 = new QCPCurve(ui->plot->xAxis, ui->plot->yAxis);
ui->plot->addPlottable(fermatSpiral1);
fermatSpiral1->setPen(QPen(Qt::red));
fermatSpiral1->setBrush(QBrush(QColor(255, 0, 0, 20)));
//viuslaize robot triangle instead of trajectory
trajectoryLine = new QCPCurve(ui->plot->xAxis, ui->plot->yAxis);
ui->plot->addPlottable(trajectoryLine);
trajectoryLine->setPen(QPen(Qt::black));
trajectoryLine->setBrush(QBrush(QColor(0, 0, 0, 20)));
// generate some points of data (y0 for first, y1 for second graph):
QVector<double> x(250), y0(250), y1(250);
for (int i=0; i<250; ++i)
{
x[i] = i;
y0[i] = qExp(-i/150.0)*qCos(i/10.0); // exponentially decaying cosine
y1[i] = qExp(-i/150.0); // exponential envelope
}
ui->plot->xAxis2->setVisible(true);
ui->plot->xAxis2->setTickLabels(false);
ui->plot->yAxis2->setVisible(true);
ui->plot->yAxis2->setTickLabels(false);
// make left and bottom axes always transfer their ranges to right and top axes:
connect(ui->plot->xAxis, SIGNAL(rangeChanged(QCPRange)), ui->plot->xAxis2, SLOT(setRange(QCPRange)));
connect(ui->plot->yAxis, SIGNAL(rangeChanged(QCPRange)), ui->plot->yAxis2, SLOT(setRange(QCPRange)));
// pass data points to graphs:
ui->plot->graph(0)->setData(x, y0);
ui->plot->graph(1)->setData(x, y1);
ui->plot->graph(0)->rescaleAxes();
ui->plot->graph(1)->rescaleAxes(true);
ui->plot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables);
}
void MathPlot::setupTextureBrushDemo(QCustomPlot *customPlot)
{
// add two graphs with a textured fill:
customPlot->addGraph();
QPen redDotPen;
redDotPen.setStyle(Qt::DotLine);
redDotPen.setColor(QColor(170, 100, 100, 180));
redDotPen.setWidthF(2);
customPlot->graph(0)->setPen(redDotPen);
customPlot->graph(0)->setBrush(QBrush(QPixmap("://skin/images/balboa.jpg"))); // fill with texture of specified image
customPlot->addGraph();
customPlot->graph(1)->setPen(QPen(Qt::red));
// activate channel fill for graph 0 towards graph 1:
customPlot->graph(0)->setChannelFillGraph(customPlot->graph(1));
// generate data:
QVector<double> x(250);
QVector<double> y0(250), y1(250);
for (int i=0; i<250; ++i)
{
// just playing with numbers, not much to learn here
x[i] = 3*i/250.0;
y0[i] = 1+exp(-x[i]*x[i]*0.8)*(x[i]*x[i]+x[i]);
y1[i] = 1-exp(-x[i]*x[i]*0.4)*(x[i]*x[i])*0.1;
}
// pass data points to graphs:
customPlot->graph(0)->setData(x, y0);
customPlot->graph(1)->setData(x, y1);
// activate top and right axes, which are invisible by default:
customPlot->xAxis2->setVisible(true);
customPlot->yAxis2->setVisible(true);
// make tick labels invisible on top and right axis:
customPlot->xAxis2->setTickLabels(false);
customPlot->yAxis2->setTickLabels(false);
// set ranges:
customPlot->xAxis->setRange(0, 2.5);
customPlot->yAxis->setRange(0.9, 1.6);
// assign top/right axes same properties as bottom/left:
customPlot->axisRect()->setupFullAxesBox();
}
void BasicGraph::Demo()
{
QCustomPlot* customPlot = ui.basicGraph;
// add two new graphs and set their look:
customPlot->addGraph();
customPlot->graph(0)->setPen(QPen(Qt::blue)); // line color blue for first graph
customPlot->graph(0)->setBrush(QBrush(QColor(0, 0, 255, 20))); // first graph will be filled with translucent blue
customPlot->addGraph();
customPlot->graph(1)->setPen(QPen(Qt::red)); // line color red for second graph
// generate some points of data (y0 for first, y1 for second graph):
QVector<double> x(250), y0(250), y1(250);
for (int i = 0; i<250; ++i)
{
x[i] = i;
y0[i] = exp(-i / 150.0)*cos(i / 10.0); // exponentially decaying cosine
y1[i] = exp(-i / 150.0); // exponential envelope
}
// configure right and top axis to show ticks but no labels:
// (see QCPAxisRect::setupFullAxesBox for a quicker method to do this)
customPlot->xAxis2->setVisible(true);
customPlot->xAxis2->setTickLabels(false);
customPlot->yAxis2->setVisible(true);
customPlot->yAxis2->setTickLabels(false);
// make left and bottom axes always transfer their ranges to right and top axes:
connect(customPlot->xAxis, SIGNAL(rangeChanged(QCPRange)), customPlot->xAxis2, SLOT(setRange(QCPRange)));
connect(customPlot->yAxis, SIGNAL(rangeChanged(QCPRange)), customPlot->yAxis2, SLOT(setRange(QCPRange)));
// pass data points to graphs:
customPlot->graph(0)->setData(x, y0);
customPlot->graph(1)->setData(x, y1);
// let the ranges scale themselves so graph 0 fits perfectly in the visible area:
customPlot->graph(0)->rescaleAxes();
// same thing for graph 1, but only enlarge ranges (in case graph 1 is smaller than graph 0):
customPlot->graph(1)->rescaleAxes(true);
// Note: we could have also just called customPlot->rescaleAxes(); instead
// Allow user to drag axis ranges with mouse, zoom with mouse wheel and select graphs by clicking:
customPlot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom | QCP::iSelectPlottables);
ExternalReplot();
}
void MainWindow::setupPlot()
{
// The following plot setup is mostly taken from the plot demos:
ui->plot->addGraph();
ui->plot->graph()->setPen(QPen(Qt::blue));
ui->plot->graph()->setBrush(QBrush(QColor(0, 0, 255, 20)));
ui->plot->addGraph();
ui->plot->graph()->setPen(QPen(Qt::red));
QVector<double> x(500), y0(500), y1(500);
for (int i=0; i<500; ++i)
{
x[i] = (i/499.0-0.5)*10;
y0[i] = qExp(-x[i]*x[i]*0.25)*qSin(x[i]*5)*5;
y1[i] = qExp(-x[i]*x[i]*0.25)*5;
}
ui->plot->graph(0)->setData(x, y0);
ui->plot->graph(1)->setData(x, y1);
ui->plot->axisRect()->setupFullAxesBox(true);
ui->plot->setInteractions(QCP::iRangeDrag | QCP::iRangeZoom);
}
_WMRTLINK double yn( int n, double x )
/**************************/
{
int j;
double by, bym, byp, tox;
if( x < 0.0 ) {
return __math1err( FP_FUNC_YN | M_DOMAIN | V_NEG_HUGEVAL, &x );
}
bym = y0( x );
if( n == 0 )
return( bym );
tox = PDIV( 2.0, x );
by = y1( x );
for( j = 1; j < n; j++ ) {
byp = j * tox * by - bym;
bym = by;
by = byp;
}
return( by );
}
