100分求离散积分的代码

A[i];//i=0,1,2,3,...,N;S=0;
for(i=0;i<N;i++)
S=S+A[i];拿分来

可能有些朋友没有搞清楚我的问题,就像是9楼的朋友.我说的离散积分,比如8个元素的数组,经过积分之后得到的仍然是一个有8个元素的数组,不是一个数字.
比如,y=sinx这个表达式，根据x不同，可以得到一组y的值，用这些y的值的集合构成一个数组，经过积分之后，结果应该是表达式y=-cosx+c上根据不同x取到的y的值构成的一个数组。并且计算前后数组的元素个数应该是一样的。
不知道我说清楚了没有。

#include "math.h"
#include "vector"
#include "string"
#include "complex"
#include <bitset>
using namespace std;
这些就能满足要求了

我也是刚刚学编程
这是我试着做的：#include <iostream>
int main()
{
int x=1;
std::cin>>x;
const size_t array_size = 100;
int n[array_size];
for(int v1=1;v1<=x;v1++)
{
std::cin>>n[v1-1];
}
int s[array_size]={0};
for(int v2=1;v2<=x;v2++)
{
s[v2]=s[v2-1]+n[v2-1];
std::cout<<s[v2]<<";";
}
std::cin>>x;
return 0;
}先输入数据总个数，然后是具体数据

离散函数x轴间距好像没用的......
只要按顺序将x1,x2...对映的f(x1),f(x2)...输入，就可以得到原函数的F(x1),F(x2)...的值了

#include <iostream>
int main()
{
int x=1;
std::cin>>x;
const size_t array_size = 100;
int n[array_size];
for(int v1=1;v1<=x;v1++)
{
std::cin>>n[v1-1];
}
int s[array_size]={0};
for(int v2=1;v2<=x;v2++)
{
s[v2]=s[v2-1]+n[v2-1];
std::cout<<s[v2]<<";";
}
std::cin>>x;
return 0;
}
原来还有这样的功能，真好玩......

我看了你的这一段，你举的例子y=sinx积到y=-cosx+c这一过程是连续积分...
如果你把“y=sinx这个表达式，根据x不同，可以得到一组y的值，用这些y的值的集合构成一个数组”
这个得到的数组不在y=-cosx+c上，而在你根据取不同x值而得到的一个新的离散型函数上.

#include "iostream.h"//求直角梯形的面积
float area( int x1, int x2, float d1, float d2 )
{
return ( d1 + d2 ) * ( x2 - x1 ) / 2;
}//一共有num组坐标，index存放坐标值，　要求从小到大，　data存放对应的原函数的坐标值，integral存放积分值，这些数组大小都为num
//这里求离散积分就是通过：积分就是求面积　　原来来算的，复杂的就不会了
void discreteIntegral( int* index, float *data, int num, float* integral )
{
integral[ 0 ] = 0;//设C为使积分值第一个函数值为0的值，根据这个，调整C值
float temp = 0;
for( i = 0; i < num - 1; i++ )
{
integral[ i + 1 ] = area( index[ i ], index[ i + 1 ], data[ i ], data[ i + 1 ] ) + temp;
temp = integral[ i + 1 ];
}
}

有点错了，下面是新的
#include "iostream.h"//求直角梯形的面积
float area( int x1, int x2, float d1, float d2 )
{
if( ( d1 >= 0 && d2 >= 0 ) || ( d1 <= 0 && d2 <= 0 ) ) //如果都在X轴的一侧
return ( d1 + d2 ) * ( x2 - x1 ) / 2;
float middlex;//如果在两侧，如下求
middlex = ( d1 * x2 - d2 * x1 )/ ( d1 - d2 );
return ( ( x2 - middlex ) * d2 + ( middlex - x1 ) * d1 ) / 2.0;
}//一共有num组坐标，index存放坐标值，　要求从小到大，　data存放对应的原函数的坐标值，integral存放积分值，这些数组大小都为num
//这里求离散积分就是通过：积分就是求面积　　原来来算的，复杂的就不会了
void discreteIntegral( int* index, float *data, int num, float* integral )
{
integral[ 0 ] = 0;//设C为使积分值第一个函数值为0的值，根据这个，调整C值
float temp = 0;
for( i = 0; i < num - 1; i++ )
{
integral[ i + 1 ] = area( index[ i ], index[ i + 1 ], data[ i ], data[ i + 1 ] ) + temp;
temp = integral[ i + 1 ];
}
}

我按照你的要求做了一下......
比考高数还累啊......
#include <iostream>
int main()
{
    int n;
    std::cin>>n;
    double x[100];
double y[100];
int v1=1;
    while(v1<=n)
    {
        std::cin>>x[v1];
std::cin>>y[v1];
v1++;
    }
x[v1]=x[v1-1];
x[0]=x[1]; double l[100];
for(int v2=1;v2<=n;v2++)
{
l[v2]=(x[v2+1]-x[v2-1])/2*y[v2];
std::cout<<l[v2];
}
double s[100]={0};
for(int v3=1;v3<=n;v3++)
{
        s[v3]=s[v3-1]+l[v3];
        std::cout<<s[v3]<<";";
}
    std::cin>>n;
    return 0;
}

忘了说明了......
先输入数据总个数，再依次输入x1,y1,x2,y2...得到2n个数字，后n个是F(x1),F(x2)......
累死了，懒得试了，你可以找个函数以较高的精度试一下......

睡不着......
我上面的那个代码对应的是x1,x2,x3...间距不是定值的情况,如果是定值的话,就是浪费资源了.

首先感谢大家参与讨论。
然后再说说这个问题。
看来我还是没有说清楚啊。
phnixpin，你说y=sinx积到y=-cosx+c，是一个连续积分没错。我说的不是这种连续积分。
我的意思是有这么一个数组，数组元素是一个连续函数上的离散点的纵坐标，横坐标是等间隔的。通过离散积分，得到一个新的数组，这个新数组的元素是另外一个函数上的离散点的纵坐标，这个函数是刚才那个函数在连续积分之后的结果(当然要通过初始条件确定积分常数)。还有一点很重要，积分的时候不知道函数的表达式。

你的做法是错误的。你想想，如果被积数组里面的元素是sinx上的点的纵坐标，第一个点是0，第二个是一个接近0的数(横坐标间隔很小)，那么按照你的程序，积分的结果，第一个点应该是一个接近0的数，对吗？那你想想，sinx在连续积分的时候，结果应该是什么？第一个点又应该是什么？

我想这个问题对于大家来说可能有点难了点，因为要用到信号分析里面的知识，这个积分的程序我基本上已经做出来了，要用到FFT、IFFT的，积分的时候需要在频域上进行变换，如果没有学过，可能写代码的时候会按照高数里面讲的去做，也就是求微小矩形面积。刚开始我也想这么做的，后来才发现不对。

#include <iostream>
long double sin(double x1)
{
long double sinx=x1;
int a=1;
double b=1;
double c=x1;
for(int g=1;g<=16;g++)
{
a=a*(-1);
b=b/(2*g*(2*g+1));
c=c*x1*x1;
sinx+=a*b*c;
}
return sinx;
}long double cos(double x1)
{
long double cosx=1;
int a=1;
double b=1;
double c=1;
for(int g=1;g<=16;g++)
{
a=a*(-1);
b=b/((2*g-1)*2*g);
c=c*x1*x1;
cosx+=a*b*c;
}
return cosx;
}
int main()
{
    int n=800;
    //std::cin>>n;
    double x[1000]={0};
double y[1000];
int v1=1;
    while(v1<=n)
    {
        x[v1]=x[v1-1]+0.001;
y[v1]=sin(x[v1]);
v1++;
    }
x[v1]=x[v1-1];
x[0]=x[1]; double l[1000];
for(int v2=1;v2<=n;v2++)
{
l[v2]=(x[v2+1]-x[v2-1])/2*y[v2];
}
double s[1000]={0};
for(int v3=1;v3<=n;v3++)
{
        s[v3]=s[v3-1]+l[v3];
}
for(int v4=1;v4<=n;v4=v4+10)
{
std::cout<<s[v4]<<";"<<1-cos(x[v4])<<"\n";
}
    std::cin>>n;
    return 0;
}积分我积的是对的，上面的代码算出来左列是sinx在0.001,0.002,0.003......处的值，右边是sinx在[o,x]上的积分1-cosx的值.

我现在做的信号程序里，如果积分的话就除以2*PI*f, 如果求导就乘以2*PI*f。(f是频率)
嘿嘿。。

说白了，LZ是把离散积分和连续积分给联系起来，这是不对的，离散积分的值怎么可以与连续积分得到的函数（y=-cosx+c)中的取值拿来对比。多看看离散积分，和连续积分的书吧！

调试易

100分求离散积分的代码

解决方案 »