数值分析C++：统计（均值/方差/偏度/峰度），积分，微分，蒙特卡罗

2023-05-16

用C++实现几个简单的数值分析计算，以便深入理解计算机在求解代数问题的过程

原理

以下主要针对普通实数，以及一元代数

统计

算数平均值

$\mu=\frac{1}{n}\sum_{i=1}^{n}x_{i}$

几何平均值

$\eta=\sqrt[n]{\prod_{i=1}^{n}x_{i}}$

方差

$\sigma ^{2}=\frac{1}{n}\sum_{i=1}^{n}\left (x_i - \mu \right )^2$

偏度

$skewness=\frac{1}{n}\sum_{i=1}^{n}\left (\frac{x_i-\mu}{\sigma} \right ) ^3$

峰度

$kurtosis=\left ( \frac{1}{n} \sum_{i=1}^{n}\left (\frac{x_i-\mu}{\sigma} \right )^4 \right )-3$

积分

求解定积分的一般数学描述式

$\int_{a}^{b}f\left ( x \right )dx=F(b)-F(a)$

但是由于原函数一般比较难求，用计算机处理起来可以用离散数值方法来计算近似

trapzoid方法

$\int_{a}^{b}f\left ( x \right )dx\approx \frac{b-a}{n}\left [\frac{f(a)+f(b)}{2}+\sum_{i=2}^{n-1}f(x_i) \right ]$

simpson方法

$\int_{a}^{b}f\left ( x \right )dx\approx\frac{b-a}{6n}\left [ f(a)+4f(\frac{a+b}{2}) +f(b) \right ]$

其他还有两种分别是cotes积分方法和romberg积分方法，代数关系较复杂

微分

计算机求微分有多种方法，一般包括

手动求解法(Manual Differentiation)
数值微分法(Numerical Differentiation)
符号微分法(Symbolic Differentiation)
自动微分法(Automatic Differentiation)

其中，手动求解对于复杂函数不太现实，符号微分和自动微分属于高阶内容，所以只用了易于理解和实现的数值微分法

数值微分法

$f'(x)=\lim_{\Delta x\rightarrow 0}\frac{f(x+\Delta x)-f(x)}{\Delta x}$

蒙特卡罗

蒙特卡罗（Monte Carlo）方法也称统计模拟方法，是按抽样调查法求取统计值来推定未知特性量的计算方法。
又称随机抽样或统计试验方法。当所求解的问题是某种事件出现的概率，或某随机变量的期望值时，可以通过某种“试验”方法求解。

monte carlo可以用来应用到很多领域，比如求积分，求圆周率

π值的计算

构造一个单位正方形和一个单位圆的1/4，往整个区域内随机投入点，根据点到原点的距离判断点是落在1/4的圆内还是在圆外，从而根据落在两个不同区域的点的数目，求出两个落在两个区域点数量的比值，这个比值实际上近似于点落在圆内的概率，也就是两个区域面积之比，根据等式关系从而求出圆周率π

$p=\frac{N_{inside}}{N_{outside}}=\frac{\pi r^2}{4r^2}=\frac{\pi}{4}$

代码

#include <iostream>
#include <cmath>
#include <random>

// --- statistics --- //
template <typename T>
double stats_mean(T data[], int n)
{
    if (n <= 0)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    double mean = 0.0;
    for (int i = 0; i < n; i++)
        mean += data[i];
    mean /= n;

    return mean;
}

template <typename T>
double stats_gmean(T data[], int n)
{
    if (n <= 0)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    double gmean = 1.0;
    for (int i = 0; i < n; i++)
        gmean *= data[i];

    if (gmean < 0)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    gmean = pow(gmean, 1 / double(n));

    return gmean;
}

template <typename T>
double stats_variance(T data[], int n)
{
    if (n <= 0)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    double mean = 0.0;
    for (int i = 0; i < n; i++)
        mean += data[i];
    mean /= n;

    double variance = 0.0;
    for (int i = 0; i < n; i++)
        variance += pow(data[i] - mean, 2);
    variance /= n;

    return variance;
}

template <typename T>
double stats_skewness(T data[], int n)
{
    if (n <= 0)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    double mean = 0.0;
    for (int i = 0; i < n; i++)
        mean += data[i];
    mean /= n;

    double variance = 0.0;
    for (int i = 0; i < n; i++)
        variance += pow(data[i] - mean, 2);
    variance /= n;
    double sigma = sqrt(variance);

    double skewness = 0.0;
    for (int i = 0; i < n; i++)
        skewness += pow((data[i] - mean) / sigma, 3);
    skewness /= n;

    return skewness;
}

template <typename T>
double stats_kurtosis(T data[], int n)
{
    if (n <= 0)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    double mean = 0.0;
    for (int i = 0; i < n; i++)
        mean += data[i];
    mean /= n;

    double variance = 0.0;
    for (int i = 0; i < n; i++)
        variance += pow(data[i] - mean, 2);
    variance /= n;
    double sigma = sqrt(variance);

    double kurtosis = 0.0;
    for (int i = 0; i < n; i++)
        kurtosis += pow((data[i] - mean) / sigma, 4);
    kurtosis /= n;
    kurtosis -= 3;

    return kurtosis;
}

// --- quadrature --- //
template <typename T>
double quadrature_trapezoid(T(*func)(T), T a, T b, int n = 1000)
{
    if (n <= 0 || a >= b)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    double res = 0.0;
    double step = double(b - a) / n;
    T x = a;
    for (int i = 1; i < n; i++)
        res += func(x + i * step);
    res += (func(a) + func(b)) / 2.0;

    res *= step;

    return res;
}

template <typename T>
double quadrature_simpson(T(*func)(T), T a, T b, int n = 1000)
{
    if (n <= 0 || a >= b)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    double step = double(b - a) / n;
    double res1 = 0.0;
    double x = a;
    for (int i = 1; i < n; i++)
        res1 += func(x + i * step);
    res1 *= 2;

    double res2 = 0.0;
    x = a + step / 2;
    for (int i = 0; i < n; i++)
    {
        res2 += func(x);
        x += step;
    }

    res2 *= 4;

    double res = res1 + res2 + func(a) + func(b);
    res *= step / 6;

    return res;
}

template <typename T>
double quadrature_cotes(T(*func)(T), T a, T b, int n = 1000)
{
    if (n <= 0 || a >= b)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    double step = double(b - a) / n;
    T x;

    double res1 = 0.0;
    x = a;
    for (int i = 1; i < n; i++)
    {
        x += step;
        res1 += func(x);
    }
    res1 *= 14;

    double res2 = 0.0;
    x = a + step / 2;
    double res3 = 0.0;
    double x1 = a + step / 4;
    double x2 = a + step / 4 * 3;

    for (int i = 0; i < n; i++)
    {
        res2 += func(x);
        res3 += func(x1) + func(x2);
        x += step;
        x1 += step;
        x2 += step;
    }
    res2 *= 12;
    res3 *= 32;

    double res4 = (func(a) + func(b)) * 7;

    double res = res1 + res2 + res3 + res4;
    res *= step / 90;

    return res;
}

template <typename T>
T quadrature_romberg(T(*func)(T), T a, T b, int k = 4)
{
    if (k <= 0 || a >= b)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    int size = k + 1;

    double* matrix = new T[size * size];
    for (int i = 0; i < size * size; i++)
        matrix[i] = 0.0;

    double step = b - a;
    matrix[0] = quadrature_trapezoid(func, a, b, 1);

    for (int i = 1; i < size; i++)
    {
        int n = 0x01 << (i - 1);
        for (int j = 0; j < n; j++)
            matrix[i * size + 0] += func(a + (j + 0.5) * step);
        matrix[i * size + 0] *= step;
        matrix[i * size + 0] += matrix[(i - 1) * size];
        matrix[i * size + 0] /= 2.0;
        step /= 2.0;
    }

    double temp = 1.0;
    double factor1, factor2;
    for (int j = 1; j < size; j++)
    {
        temp *= 4.0;
        factor1 = temp / (temp - 1);
        factor2 = 1 / (temp - 1);
        for (int i = j; i < size; i++)
        {
            matrix[i * size + j] = factor1 * matrix[i * size + j - 1] - factor2 * matrix[(i - 1) * size + j - 1];
        }
    }

    double res = matrix[k * size + k];
    delete[] matrix;

    return res;
}

// --- differentiate --- //
template <typename T>
double differentiate(T(*func)(T), T x, double delta = 1e-8)
{
    if (delta <= 0)
    {
        std::cerr << "wrong parameter!" << std::endl;
        return -1;
    }

    T y_pre = func(x - delta);
    T y = func(x);
    T y_post = func(x + delta);

    double diff_backward = (y - y_pre) / delta;
    double diff_forward = (y_post - y) / delta;

    double diff = (diff_backward + diff_forward) / 2.0;

    return diff;
}

// example algebra function
template <typename T>
double func1(T x)
{
    return x + 2 * x * x + 5;
}

// --- monte carlo --- //
double montecarlo_pi(int epochs = 100000)
{
    double r = 1.0;

    std::default_random_engine random_engine;
    std::uniform_real_distribution<double> distribution(0, 1);

    int count = 0;
    for (int i = 0; i < epochs; i++)
    {
        double x = distribution(random_engine);
        double y = distribution(random_engine);
        double distance = sqrt(x * x + y * y);
        if (distance <= r)
            count++;
    }

    double PI = 4 * (double)count / epochs;

    return PI;
}



int main(int argc, char* argv[])
{
    std::cout << "==== statistic test ====" << std::endl;
    double data[] = { 3.7, 6.5, 4.3, 2.1, 2.3, 5.8, 5.9, 7.2, 8.6 };
    int n = 9;
    std::cout << "data: ";
    for (auto num : data)
        std::cout << num << ' ';
    std::cout << std::endl;

    std::cout << "stats_mean result: " << stats_mean(data, n) << std::endl;
    std::cout << "stats_gmean result: " << stats_gmean(data, n) << std::endl;
    std::cout << "stats_variance result: " << stats_variance(data, n) << std::endl;
    std::cout << "stats_skewness result: " << stats_skewness(data, n) << std::endl;
    std::cout << "stats_kurtosis result: " << stats_kurtosis(data, n) << std::endl;

    std::cout << "==== quadrature test ====" << std::endl;
    std::cout << "f(x) = x + 2x^2 + 5" << std::endl;

    double a = 1;
    double b = 7;
    std::cout << "a = " << a << " b = " << b << std::endl;

    std::cout << "quadrature_manual result: " << 1 / 2.0 * b * b + 2 / 3.0 * b * b * b + 5 * b
        - (1 / 2.0 * a * a + 2 / 3.0 * a * a * a + 5 * a) << std::endl;
    std::cout << "quadrature_trapezoid result: " << quadrature_trapezoid(func1, a, b) << std::endl;
    std::cout << "quadrature_simpson result: " << quadrature_simpson(func1, a, b) << std::endl;
    std::cout << "quadrature_cotes result: " << quadrature_cotes(func1, a, b) << std::endl;
    std::cout << "quadrature_romberg result: " << quadrature_romberg(func1, a, b) << std::endl;

    std::cout << "==== differentiate test ====" << std::endl;
    std::cout << "f(x) = x + 2x^2 + 5" << std::endl;
    double x = 3.0;
    std::cout << "x = " << x << std::endl;

    std::cout << "differentiate label result: " << 1 + 4 * x << std::endl;
    std::cout << "differentiate test result: " << differentiate(func1, x) << std::endl;

    std::cout << "==== monte carlo test ====" << std::endl;
    std::cout << "mathmatic accurate PI: " << 3.1415926 << std::endl;
    std::cout << "montecarlo computed PI: " << montecarlo_pi() << std::endl;

    return 0;
}

输出结果

==== statistic test ====
data: 3.7 6.5 4.3 2.1 2.3 5.8 5.9 7.2 8.6 
stats_mean result: 5.15556
stats_gmean result: 4.67094
stats_variance result: 4.35136
stats_skewness result: -0.0367426
stats_kurtosis result: -1.11829
==== quadrature test ====
f(x) = x + 2x^2 + 5
a = 1 b = 7
quadrature_manual result: 282
quadrature_trapezoid result: 282
quadrature_simpson result: 282
quadrature_cotes result: 282
quadrature_romberg result: 282
==== differentiate test ====
f(x) = x + 2x^2 + 5
x = 3
differentiate label result: 13
differentiate test result: 13
==== monte carlo test ====
mathmatic accurate PI: 3.14159
montecarlo computed PI: 3.14664

从结果可以看出

几种定积分计算的求解精度差不多
微分计算的精度还可以
蒙特卡洛模拟求的圆周率随着模拟的次数多增大而越来越精确

当然这里只是简单的用C++实现了几个基本数值算法，如果要在学术或者工程实践中做大量的准确数值计算，还是推荐用开源和稳定的数值计算库

c++ 用eigen和gsl
python用numpy和scipy

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

数值分析

蒙特卡罗

数值分析C++：统计（均值/方差/偏度/峰度），积分，微分，蒙特卡罗的相关文章

[数值计算-15]：函数近似值的线性与非线性拟合的原理与Python代码示例

作者主页文火冰糖的硅基工坊 https blog csdn net HiWangWenBing 本文网址 https blog csdn net HiWangWenBing article details 119973082 目录第1章
MATLAB实现列主元高斯消去法

列主元高斯消去法 function x gauss column A b 输入矩阵A和列向量b 返回解向量x ni nj size b if rank A rank A b 若系数矩阵秩和增广矩阵秩不相等则无解 fprintf 无解 n
数值作业:顺序消去法解线性方程组之C语言代码

实际上后面的Guass列主选主元全选主元都是由顺序高斯消元法稍加改动变化而来的但是顺序消元会出现一个问题如果我们要保留的那个元的系数很小那么在消元过程中势必会用很大的数字乘以次方程后再加到别的方程上消去别的方程中的改元这样就会
数值分析实验（二）迭代法的应用

目录实验名称数值分析实验二迭代法的应用实验题目实验原理 1 高斯消去法 2 Jacobi迭代法 3 G S迭代法 4 SOR迭代法实验数据记录及处理实验内容及步骤 1 高斯消元法 2 Jacobi迭代法 3 G S迭代法 4
基于蒙特卡洛的强化学习方法【附带代码实现】

基于蒙特卡洛的强化学习方法蒙特卡洛方法 Monte Carlo methods 也被称为统计模拟方法是一种基于概率统计的数值计算方法运用蒙特卡洛方法时我们通常使用重复随机抽样然后运用概率统计方法来从抽样结果中归纳出我们想求的目标的
强化学习入门笔记

强化学习相关概念我们先回忆一下童年来看看超级玛丽这款游戏在这款游戏里面的我们需要控制超级玛丽进行左右行走跳攻击等动作来躲避或攻击小动物吃金币以及各种类型的增益道具最终获得的金币数量的多少以及通关代表我们玩游戏玩的好不好
楚列斯基分解法、求矩阵范数的C++实现

这次的作业如下随机生成一个 n n n 阶方阵与 n n n 阶向量构成 A
数值分析第一章：绪论

第一章绪论 1 2误差基础知识 1 2 1误差来源 1 2 2误差度量 1 2 3初值误差传播 1 3 舍入误差分析及数值稳定性 1 2误差基础知识 1 2 1误差来源数学模型与实际问题的差异称为模型误差数学模型中常常还包含有一些参数
matlab实现牛顿下山法

说起牛顿下山法首先要提牛顿法牛顿法是求解非线性方程的一个重要方法具体可以点击牛顿法虽然牛顿法作为一个二阶的迭代收敛方法但是其对于函数和初始点的要求都比较高而牛顿下山法则是有效降低这些要求的一种技巧牛顿下山法的迭代公式如下 x
周志华《Machine Learning》学习笔记（17）--强化学习

上篇主要介绍了概率图模型首先从生成式模型与判别式模型的定义出发引出了概率图模型的基本概念即利用图结构来表达变量之间的依赖关系接着分别介绍了隐马尔可夫模型马尔可夫随机场条件随机场精确推断方法以及LDA话题模型 HMM主要围绕着评
矩阵列主元三角分解

一列主元三角分解定理如果A为非奇异矩阵则存在排列矩阵P使 PA LU 其中L为下三角矩阵 U为上三角矩阵即A P 1LU 二列主元三角分解Python代码自己原创 def pivot lu decomposition coeff
矩阵LU分解

一矩阵LU分解定理设A为n阶矩阵如果A的顺序主子式Di 0 i 1 2 n 1 则A可以分解为一个单位下三角矩阵L和一个上三角矩阵U的乘积且这种分解是唯一的即A LU 二矩阵LU分解Python代码自己原创 def lu de
计算方法实验（二）：龙贝格积分法

Romberg积分法数学原理利用复化梯形求积公式复化辛普生求积公式复化柯特斯求积公式的误差估计式计算积分 a b f x
高斯—赛德尔迭代法解线性方程组（C语言）

高斯赛德尔迭代法解线性方程组参考教材数值分析李乃成梅立泉科学出版社计算方法教程第二版凌永祥陈明逵 include
雅可比（jacobi）迭代法 matlab实现

clc clear n input 请输入矩阵阶数 n for i 1 n fprintf 请输入矩阵第 d行 n i A i input end A B 1 input 请输入B向量 n B for i 1 n x i 0 x2 i 0
高等数值计算方法学习笔记第4章第二部分【数值积分（数值微分）】

高等数值计算方法学习笔记第4章第二部分数值积分数值微分四龙贝格求积公式第三次课 1 梯形法的递推化变步长求积法 2 龙贝格算法五高斯求积公式 1 一般理论 1定义1例题 2 构造高斯求积公式方法二定理加证明 5 Gaus
高等数值计算方法学习笔记第6章【解线性代数方程组的迭代方法（高维稀疏矩阵）】

高等数值计算方法学习笔记第6章解线性代数方程组的迭代方法高维稀疏矩阵一引言 1 例题说明迭代法的收敛性研究的重要性 2 定义迭代法迭代法收敛解误差二基本迭代法 1 雅可比迭代法 2 高斯塞德尔迭代法 Gauss Sei
迭代法求解线性方程组（C++实现）

本系列是数值分析相关算法的文章这次用迭代法求解线性方程组不同于上次用高斯消元法之类的求解迭代法对于稀疏矩阵方程组的运算会大大提高而如果用高斯相关的算法求解会浪费大量资源计算无用的东西所以有必要研究此算法本文章主要使用了3个算
正交多项式-勒让德多项式，两类切比雪夫多项式及零点，拉盖尔多项式，埃尔米特多项式

1 正交多项式设 n x 是 a
计算方法实验（四）：牛顿迭代法

Newton迭代法数学原理求非线性方程 f x 0 f x 0 f x 0的根

随机推荐

Linux查看线程的堆栈信息

1 使用top命令 xff0c 查找pid 2 显示线程 xff0c 查找线程tid ps mp pid o THREAD tid time sort rn 3 将线程id转化为16进制0xtid printf 34 x n 34 tid
MPU6050 简介

目录关于MPU6050芯片关于小板关于厂家和DATASHEET 关于漂移关于角加速度还是角速度关于精度和量程 xff08 可调 xff0c 可选 xff09 关于功耗 xff0c 陀螺仪 43 加速器工作电流 xff1a 3 8m
银河麒麟V10操作系统安装putty和cutecom和网络调试助手（mNetAssist）

银河麒麟V10操作系统安装putty和cutecom和网络调试助手 xff08 mNetAssist xff09 安装Putty 需要连接网络 sudo apt get install putty 安装Cutecom 需要连接网络 sudo
STM32串口中断接收和中断发送

STM32串口USART1中断接收和中断发送先贴出中断函数 void USART1 IRQHandler void if USART GetITStatus USART1 USART IT RXNE 61 RESET USART Clea
ICP（Iterative Closest Point迭代最近点）算法学习笔记

背景 xff1a 博主从百度百科开始学习icp算法 xff0c 主要是后期加得学习笔记 xff08 红色部分 xff09 ICP算法 xff1a 以点集对点集 xff08 PSTPS xff09 配准方法为基础 xff0c 他们阐述了一种曲
linux设备上的Onvif 实现21：解决大华摄像头无法使用问题

好长时间没有再写该系列文章了 xff0c 最近刚好摸索着解决了大华摄像头无法使用问题 xff0c 记录下来 xff0c 应该对其他博友有所帮助之前虽然写了一大堆文章说明了如何使用gsoap连接摄像头 xff0c 但这是针对一台海康的摄像头
NRF24L01工作原理（发送接收通道地址）解读图示

NRF24L01工作原理 xff08 发送接收通道地址 xff09 解读图示 NRF24l01工作原理 xff08 发送接收通道地址 xff09 网上说明不清晰 xff0c 特制作本说明 xff0c xff08 制作 xff1a 流浪的蛙
Realsense D435i 使用

工作之后才发现问题不是单线程地来找你 xff0c 而是多线程并发地涌向你 D435i是一款良心传感器 xff0c 美中不足的是你拿不到广角图像虽然现在不负责传感器测试了 xff08 老大布置什么 xff0c 打工的就去做什么就好了 xff
Kalibr标定d435i

figure it out 最近准备使用realsense d435i xff0c 先对其进行标定整体环境是基于ROS的 xff0c 因为Kalibr是在ROS环境下大致过程如下 xff1a imu标定 gt 双目标定 gt 双目 43
cout函数未定义问题和函数隐形类型转换

cout函数未定义的一些问题 xff1a 看上面的图片 xff0c 有个朋友说 xff0c 按照上面using和修改了iostream为什么还是显示未定呢 xff1f 到底怎么办呢 xff1f 解决 xff1a include lt ios
C++ primer plus

https github com lilinxiong cppPrimerPlus six https github com lilinxiong cppPrimerPlus six 最近在看C 43 43 primer plus这本书 x
ROS编译过程中的错误

一 catkin make编译错误 xff08 1 xff09 Could not find a package configuration file provided by 34 gazebo ros control 34 with an
算法导论学习笔记-2

第二章 xff1a 函数的增长 2 1渐近记号记号定义 xff1a g n 61 f n 存在正常数c1 c2和n0 xff0c 使对所有n n0 xff0c 有0 c1 g n f n c2 g n xff1b 满足该定义 xff0c
C++理论复习之运算符重载

C 43 43 运算符重载重载操作符的一般格式 xff1a Type operator 43 Type A Type B 可重载与不可重载的操作符列表操作符重载的注意事项重载操作符必须有一个类类型的操作数 xff0c 不能重载内置类型
计算机网络概述

OSI参考模型国际标准化组织 I S O 开发了开放式系统互联 O S I 参考模型 xff0c 以促进计算机系统的开放互联开放式互联就是可在多个厂家的环境中支持互联很少有产品是完全的O S I 模式 xff1b 相反 xff0c 其
PCL：如何自定义一个点云PointT类型

1 xff0c 使用基础点云类型 include 34 pcl point types h 34 include 34 pcl impl instantiate hpp 34 include 34 foo h 34 include 34 i
IP地址

ip地址的分类 A类地址设计IPv4 A类地址的目的是支持巨型网络 xff0c 因为对规模巨大网络的需求很小 xff0c 因此开发了这种结构使主机地址数很大 xff0c 而严格限制可被定义为A类网络的数量一个A类I P地址仅使用第一个8
数据存储大端小端模式的理解

Big Endian和Little Endian的定义如下 xff1a 1 Little Endian就是低位字节排放在内存的低地址端 xff0c 高位字节排放在内存的高地址端 2 Big Endian 就是高位字节排放在内存的低地址端 x
cocos2dx实例开发之经典坦克

小时候红白机上玩的的经典90坦克 xff0c 看起来简单 xff0c 做起来其实有点复杂 xff0c 这里用原版素材还原了一个简版预览工程结构游戏架构包括场景 xff1a 欢迎界面 xff0c 主菜单游戏场景步骤菜单场景对于图
数值分析C++：统计（均值/方差/偏度/峰度），积分，微分，蒙特卡罗

用C 43 43 实现几个简单的数值分析计算 xff0c 以便深入理解计算机在求解代数问题的过程原理以下主要针对普通实数 xff0c 以及一元代数统计算数平均值几何平均值方差偏度峰度积分求解定积分的一般数学描述式但是由

数值分析C++：统计（均值/方差/偏度/峰度），积分，微分，蒙特卡罗

原理

统计

积分

微分

蒙特卡罗

代码

数值分析C++：统计（均值/方差/偏度/峰度），积分，微分，蒙特卡罗 的相关文章

随机推荐

热门标签

数值分析C++：统计（均值/方差/偏度/峰度），积分，微分，蒙特卡罗的相关文章