C++ 1D dalga fonksiyonu kötü çıkışlar (sonlu farklar)

Question

Ben C ve C++ programlama biraz yeniyim, ben zaten Ar bu uygulamış ve şimdi C++ o kadar yazmaya çalışıyorum.

I std::vector<double> ve std::vector<std::vector<double>> kullanılan ve sadece h, k göre boyutlandırılır std::vector<std::vector<double>> u(t.size(),vector<double>(n)), ve toplam çalışma süresi doldurmak için her seferinde bir satır geçmesi gerekir, çünkü değer geçirilir.

I having çıkış veri dalga eksenini kestiği zaman yanlış gibi görünüyor olmasıdır. Mantıksal olarak neyin yanlış olduğunu anlayamadım ama bir şeyleri gözden kaçırmış olabilirdim, bence, std::vector'u yanlış kullanıyorum veya tanıyamadığım bazı veri türü çakışmaları var.

#include <iostream> 
#include<math.h> 
#include<vector> 
#include<fstream> 

using namespace std; 

vector<double> takestep (double h,double k,vector<double> ukm1,vector<double> ukm2){ 

    int n = ukm1.size(); 

    vector<double> uk(n); 

    uk[0]=0; 
    uk[n-1]=0; 

    for(int i = 1; i < (n-1); i++) 
    { 
     uk[i] = (pow(k,2)/pow(h,2))*(ukm1[i+1]-2*ukm1[i]+ukm1[i-1])+2*ukm1[i]-ukm2[i]; 
    } 

    return uk; 
} 

//----------------------------------------------------------------- 
vector<vector<double> > solve1D (double tf, double h, double k, vector<double> ukm1, vector<double> ukm2){ 

    int n = ukm1.size(); 
    vector<double> t((int)tf/k); 

    for(int i = 0; i<t.size(); i++) 
    { 
     t[i] = k*i; 
    } 

    vector<vector<double> > u(t.size(),vector<double>(n)); 

    u[0] = ukm1; 
    u[1] = takestep(k,h,ukm1,ukm2); 

    for(int i = 2;i<t.size();i++) 
    { 
     u[i]= takestep(h,k,u[i-1],u[i-2]); 
    } 

    return u; 
} 

//==================================================================== 
int main(int argc, char** argv) { 

double tf = 12.0; 
double k = .005; 
double h = .01; 

vector<double> x(1.0/h); 

for(int i = 1;i<x.size();i++) 
{ 
    x[i] = i*h; 
} 

vector<double> yo(x.size()); 

yo[0]=0; 
yo[x.size()-1]=0; 

for(int i = 1;i<yo.size()-1;i++) 
{ 
    yo[i] = 0.5*sin(x[i]*M_PI); 
} 

vector<vector<double> > u = solve1D(tf,k,h,yo,yo); 

ofstream myfile; 
myfile.open ("Wave1D_output.txt"); 


for(int i = 0;i<u.size();i++) 
{ 

    for(int j = 0;j<yo.size();j++) 
    { 
     myfile<< u[i][j]<<"\t"; 
    } 

    myfile<<"\n"; 
} 
myfile.close(); 
return 0; 
} 

---

My R komut tamamen işlevseldir ve (endeksleri değişti ile hariç) Ben çoğunlukla aynı kodu kullanıyorum:

Belki birilerinin burada benim kodudur ne yapamam görebilirsiniz. Temel fark, vektörlerin ve 2D dizilerin (bildiğiniz gibi) C++ 'da biraz daha karmaşık olmasıdır. Ben denemek ve OpenMP kullanarak bunu yapmak için gidiyorum bu bitirmek, ama bu (muhtemelen) var sonra

başka bir gün için başka bir soru. Ben boyutunu yazdırıldığı zaman

Answer 1

Yani, böcek .............. Ben ilk çağrısında geriye çözücüye h ve k gönderildiği ortaya çıktı, ben bu öğrendim zaman vektörü ve 2400 yerine 1200 idi. Sorun olmadığı için ham indekslemeyi sürdürdü.

#include <iostream> 
    #include<math.h> 
    #include<vector> 
    #include<fstream> 

    using namespace std; 

vector<double> takestep(double h,double k,vector<double> ukm1,vector<double> ukm2){ 

    int n = ukm1.size();//set n to number of elements in of input array 
    vector<double> uk(n);//new array of same size 
    uk[0]=0; // 
    uk[n-1]=0;//set ends to zero 

    for(int i = 1;i<(n-1);i++){//for i in length of uk 
     uk[i]=(pow(k,2)/pow(h,2))*(ukm1[i+1]-2*ukm1[i]+ukm1[i-1])+2*ukm1[i]-ukm2[i];//finite difference formula 
    } 

    return uk;//returns next time step 
} 
vector<vector<double> > solve1D (double tf, double h, double k, vector<double> ukm1, vector<double> ukm2){ 

    int n = ukm1.size(); //set n to number of elements in input array 
    vector<double> t(round(tf/k));//set size of sime sequence (final time/delta time) 

    for(int i = 0; i<t.size(); i++){ 
     t[i] = k*(i+1);     //fill time array with proper sequence 

    } 

    vector<vector<double> > u(t.size(),vector<double>(n));//create 2D array to store all the time steps 

    u[0] = ukm1;//set initial state 
    u[1] = takestep(k,h,ukm1,ukm2); //set first time step 
    for(int i = 2;i<t.size();i++){ 
     u[i]= takestep(h,k,u[i-1],u[i-2]);//take all the other time steps 
    } 

    return u;//return array with all steps 
} 
int main(int argc, char** argv) { 

double tf = 12.0;//set final time for test 
double k = .005;//set time step 
double h = .01;//set distance for finite difference 
vector<double> x((int)round(1.0/h));//create vector to store x steps 
for(int i = 0;i<x.size();i++){ 
    x[i] = i*h;    //fill with proper distance steps 
} 
vector<double> yo(x.size());//create vector to store wave function 
for(int i = 1;i<yo.size()-2;i++){ 
yo[i] = 0.5*sin(x[i]*M_PI);  //fill with function values 
} 
vector<vector<double> > u = solve1D(tf,h,k,yo,yo);//send to solver