小编OSE*_*OSE的帖子

假设我想表示int作为向量向量的二维矩阵:

std::vector<std::vector<int> > myVec;

内部尺寸是常数,比如5,外部尺寸小于或等于N.为了尽量减少重新分配,我想保留空间:

myVec.reserve(N);

内部向量的大小是多少？这纯粹依赖于实现吗？这如何影响数据的空间局部性？由于内部维度是常量,有没有办法告诉编译器使用这个常量大小？如果内部向量的大小发生变化,这些答案如何变化？

我在 Boost 中使用 odeint 库。使用integrate_adaptive函数时，结果符合预期。但是，使用Integrate_times 时，ODE 会在非常不同的时间进行计算，这些时间超出了积分范围。这对我来说是一个问题，因为我的 ODE 没有针对某些正在评估的值进行定义。

下面的代码演示了这个问题。计算 ODE 的 x 值将打印到屏幕上。

#include <iostream>
#include <complex>
#include <vector>
#include <boost/numeric/odeint.hpp>

struct observe
{
    std::vector<std::vector<std::complex<double> > > & y;
    std::vector<double>& x_ode;

    observe(std::vector<std::vector<std::complex<double> > > &p_y, std::vector<double> &p_x_ode) : y(p_y), x_ode(p_x_ode) { };

    void operator()(const std::vector<std::complex<double> > &y_temp, double x_temp)
    {
        y.push_back(y_temp);
        x_ode.push_back(x_temp);
    }
};

class Direct
{
    std::complex<double> alpha;
    std::complex<double> beta;
    std::complex<double> R;
    std::vector<std::vector<std::complex<double> > > H0_create(const double y);

public:
    Direct(std::complex<double> p_alpha, std::complex<double> p_beta, double p_R) : alpha(p_alpha), beta(p_beta), …

我已经按照这里的例子使用gnuplot生成填充轮廓图.gnuplot命令和输出是:

reset
f(x,y)=sin(1.3*x)*cos(.9*y)+cos(.8*x)*sin(1.9*y)+cos(y*.2*x)
set xrange [-5:5]
set yrange [-5:5]
set isosample 250, 250
set table 'test.dat'
splot f(x,y)
unset table

set contour base
set cntrparam level incremental -3, 0.5, 3
unset surface
set table 'cont.dat'
splot f(x,y)
unset table

reset
set xrange [-5:5]
set yrange [-5:5]
unset key
set palette rgbformulae 33,13,10
p 'test.dat' with image, 'cont.dat' w l lt -1 lw 1.5

该方法生成非常平滑的填充等高线图.如何修改此方法以使轮廓线之间的颜色恒定？例如,我希望它看起来类似于这个MATLAB脚本的输出:

clc; clear all; close all;

Nx = 250;
Ny = 250;
x = linspace(-5,5,Nx); …

在C++ 11中有没有办法实现一个sqrt适用于正double输入值和负输入值的函数？std::complex<double>如果输入是负数,我希望返回类型,如果是正数,我想double.我意识到简单的解决方案是永远返回,std::complex<double>但这不是我想要的.

下面我有一个我第一次尝试的例子,但由于a返回类型的存在,这不会编译:

inline decltype((a > 0)?(double):(std::complex<double>)) sqrt(const double& a)
{
    if(a > 0)
    {
        return std::sqrt(a);
    }
    else
    {
        return ((std::complex<double>(0.0,1.0))*std::sqrt(-a));
    }
}

我不确定我是否正确地重载了<<运算符.以下代码编译没有问题但不产生预期的输出.

#include <iostream>
#include "Matrix.h"

template<class T>
std::ostream& operator<<(std::ostream &out, const matrix<T> &A)
{
    for(int ii = 0; ii << A.size(1); ii++)
    {
        for(int jj = 0; jj < A.size(2); jj++)
        {
            out << A(ii,jj) << " ";
        }
        out << std::endl;
    }
    return out;
}

int main(int argc, char** argv)
{
    matrix<double> A = {{1.0, 2.0},{1.0,-1.0}};
    cout << "\"" << A << "\"\n";

    return 0;
}

唯一的输出是: ""

Matrix.h

template<class T>
class matrix
{
public:
    matrix(int rows, …