[C++] runge kutty felberg — błąd kompilacji

[makosia15]

Nie wiem co jest w tym kodzie źle. Jeśli ktoś jest wstanie rozwiązać tą zagadkę, proszę o pomoc. Błąd przy kompilacji
[error] a function-definition is not allowed here before '{' token
[error] expected '}' at and of input.

Kod: Zaznacz cały

#include <iostream>
#include <iomanip>
#include <ctime>
#include <stdio.h>
#include <math.h>
#include <fstream>
#include <stdlib.h>
#include <conio.h>

using namespace std;
#define C 0.000001
#define R 0.2
#define L 0.00000005
#define V 1000
int main (int argc, char* argv[])
{
double f(int x[], int y[])
{
int k[6];
int x[100];
int y[100]
int h=0.1;
y[0]=0;
x[0]=0;
for (int i=0; i<=100-1; i++)
{
x[i]=x[0]+i*h;
k[1]=h*f(x[i],y[i]);
k[2]=h*f(x[i]+(h/4),y[i]+(k[1]/4));
k[3]=h*f(x[i]+(3*h/8), y[i]+(3*k[1]/33)+(9*k[2]/32));
k[4]=h*f(x[i]+(12*h/13), y[i]+(1932*k[1]/2197)-(7200*k[2]/2197)+(7296*k[3]/2197));
k[5]=h*f(x[i]+h,y[i]+(439*(k[1]/216)-8*k[2]+(3680*k[3]/513)-(845*k[4]/4104));
k[6]=h*(x[i]+(h/2), y[i]-(8*k[1]/27)+2*k[2]-(3544*k[3]/2565)+(1859*k[4]/414)-(11*k[5]/40));
y[i+1]=y[i]+(25*k[1]/216)+(1408*k[3]/2565)+(2197*k[4]/414)-(k[5]/5);
ynext[i+1]=y[i]+(16*k[1]/135)+(6656*k[3]/12852)+(28561*k[4]/56430)-(9*k[5]/50)+(2*k[6]/55));
return ynext;
}}}
double rkf(int x[], int y[], int z[], int w[])
{
for (int i=0;i<=100-1;i++)
{
int y[100];
int x[100];
int z[100];
int w[100];
int h=0.1;
y[0]=0;
x[0]=0;
z[0]=0;
w[0]=0;
z[i]=(y[i]*(x[i]-x[0])-y[0])/h;
w[i]=(z[i]*(x[i]-x[0])-z[0])/h;

return (w[i]+(R/L)*z[i]+(y[i]/(L*C)));
}
ofstream os;
os.open("'out.dat'");
if(not os) cout<<"Unable to oen/write file 'out.dat'."<<endl;
}

[Santiago A]

To nie Python, definicja funkcji (f) w innej funkcji (main) jest zabroniona przez Twój kompilator.

[makosia15]

Rozumiem, dzięki. Powinnam napisać przed główną funkcją
double f(int x[], int y[]);
?-- 26 sie 2016, o 12:53 --Jak zdefiniować funkcję z tablicami ze zwróconą wartością przed (int main)?

[athame]

Najprościej jako void. Potem w return dajesz tablicę.

[kalwi]

Uh, ten kod, aż oczy bolą jak brzydki on jest.
Zero formatowania, piszesz C++ a używasz stdio.h czy - co nawet gorsze - conio.h.
Poza tym dyrektywy #define też się nie używa już do stałych.
Zanim zaczniesz brać się za takie rzeczy przeczytaj chociaż o podstawach języka - i jak to robisz to sięgnij po książkę z przynajmniej 2012 roku lub nowszą.

Kod: Zaznacz cały

#include<iostream>
#include <iomanip>
#include <ctime>
#include <stdio.h>
#include <math.h>
#include <fstream>
#include <stdlib.h>
#include <conio.h>

#define C 0.000001
#define R 0.2
#define L 0.00000005
#define V 1000
using namespace std;

int main(int argc, char* argv[])
{

    ofstream os;
    os.open("'out.dat'");
    if (not os)
        cout << "Unable to oen/write file 'out.dat'." << endl;
}

double f(int x[], int y[])
{
    int k[6];
    int x[100];
    int y[100] int h = 0.1;
    y[0] = 0;
    x[0] = 0;
    for (int i = 0; i <= 100 - 1; i++) {
        x[i] = x[0] + i * h;
        k[1] = h * f(x[i], y[i]);
        k[2] = h * f(x[i] + (h / 4), y[i] + (k[1] / 4));
        k[3] = h * f(x[i] + (3 * h / 8), y[i] + (3 * k[1] / 33) + (9 * k[2] / 32));
        k[4] = h * f(x[i] + (12 * h / 13), y[i] + (1932 * k[1] / 2197) - (7200 * k[2] / 2197) + (7296 * k[3] / 2197));
        k[5] = h * f(x[i] + h, y[i] + (439 * (k[1] / 216) - 8 * k[2] + (3680 * k[3] / 513) - (845 * k[4] / 4104));
                       k[6] = h * (x[i] + (h / 2), y[i] - (8 * k[1] / 27) + 2 * k[2] - (3544 * k[3] / 2565) + (1859 * k[4] / 414) - (11 * k[5] / 40));
                       y[i + 1] = y[i] + (25 * k[1] / 216) + (1408 * k[3] / 2565) + (2197 * k[4] / 414) - (k[5] / 5);
                       ynext[i + 1] = y[i] + (16 * k[1] / 135) + (6656 * k[3] / 12852) + (28561 * k[4] / 56430) - (9 * k[5] / 50) + (2 * k[6] / 55));
    }
        return ynext;
}

double rkf(int x[], int y[], int z[], int w[])
{
    for (int i = 0; i <= 100 - 1; i++) {
        int y[100];
        int x[100];
        int z[100];
        int w[100];
        int h = 0.1;
        y[0] = 0;
        x[0] = 0;
        z[0] = 0;
        w[0] = 0;
        z[i] = (y[i] * (x[i] - x[0]) - y[0]) / h;
        w[i] = (z[i] * (x[i] - x[0]) - z[0]) / h;
   }
   return (w[i] + (R / L) * z[i] + (y[i] / (L * C)));
}

Po wstępnym przeformatowaniu tak to wygląda i oczywiście nie ma prawa zadziałać.
Poza tym nie widzę, aby zmienna ynext była gdziekolwiek zadeklarowana.

-- 26 sie 2016, o 13:51 --

To nie Python, definicja funkcji (f) w innej funkcji (main) jest zabroniona przez Twój kompilator.

Nie przez kompilator, a przez standard.

[athame]

Kod jest paskudny, nawet po dodaniu wcięć. Mieszanie C i C++, #define? Serio? Wróć tu z tym kodem w Mathematica. bo perspektywa poprawiania tego wygląda zniechęcająco.

PS. kompilator czy IDE czasami dopuszcza odstępstwa od standardu lub też jest niezgodne ze standardem (vide kompilatory MS).

[kalwi]

O popatrz, nawet nie wiedziałem. Rzeczywiście tak jest (vide )

[makosia15]

Dzięki:)))))))))))))
Spróbuję :0)
Moim zadaniem jest napisać oscylator harmoniczny tłumiony, z odpowiednimi stałymi na podstawie równania:
\(\displaystyle{ q''+\frac{R}{L}\cdot q'+\frac{q}{L\cdot C}=0}\)
Dawno temu pisałam w C++, stąd ten kod.
Poniżej znajduje się link algorytmu Runge Kutta Felberg w Mathematica.
... bc864.html
Pozdrawiam.

[kalwi]

1) nic mi się nie otwiera z tego pliku
2) wrzuć to na jakiś dropbox czy google drive, nikt nie będzie czekał 20s aż będzie można pobrać plik

[makosia15]

Okey , wstawiam link pliku z dropbox

Kod: Zaznacz cały

https://www.dropbox.com/s/yqlbwhrltz12l72/rkf.odt?dl=0

Pozdrawiam.

[athame]

Kod z programu Mathematica w wersji C++ może wyglądać tak jak poniżej (żadnych optymalizacji, nienajlepsze techniki zapisu - starałem się przygotować tak by każda linijka była zrozumiała nie tylko dla programisty, a kompilator nie zgłaszał ostrzeżeń):

Kod: Zaznacz cały

#include <iostream>

using namespace std;

const double h=0.1;

double delta[5] = {0.1157407407, 0.0, 0.5489278752, 0.5353313840, -0.2};
double gamma[6] = {0.1185185185, 0.0, 0.5189863548, 0.5061314903, -0.18, 0.0363636364};

int i, j;
double x[6], y[7], y2[7], c[6], k[7];
double delsum=0, gamsum=0;

void rkf();
double f(double a, double b);

int main(int argc, char* argv[]) {
    rkf();
    return 0;
}

void rkf() {
    x[0] = 0.0;
    y[0] = 1.0;
    
    for (i=0; i<=4; i++) {
        x[i] = x[0] + i*h;
        cout << "Krok: " << i+1 << ':' << endl << endl;
        
        k[1] = h * f(x[i], y[i]);
        k[2] = h * f(x[i] + (h/4), y[i] + (k[1]/4));
        k[3] = h * f(x[i] + (3*h/8), y[i] + (3*k[1]/32) + (9*k[2]/32));
        k[4] = h * f(x[i] + (12*h/13), y[i] + (1932*k[1]/2197) - (7200*k[2]/2197) + (7296*k[3]/2197));
        k[5] = h * f(x[i] + h, y[i] + (439*k[1]/216) - 8*k[2] + (3680*k[3]/513) - (845*k[4]/4104));
        k[6] = h * f(x[i] + (h/2), y[i] - (8*k[1]/27) + 2*k[2] - (3544*k[3]/2565) + (1859*k[4]/4104) - (11*k[5]/40));
       
        for (j=1; j<=5; j++)
            delsum+=delta[j-1]*k[j];
        
        for (j=1; j<=6; j++) {
            cout << "k[" << j << "] = "<< k[j] << endl;
            gamsum+=gamma[j-1]*k[j];
        }
        
        y[i+1] = y[i] + delsum;
        y2[i+1] = y[i] + gamsum;
        c[i+1] = y2[i+1] - y[i+1];

        cout << endl << x[i] << "   " << y[i+1] << "   " << y2[i+1] << "   " << c[i+1] << endl << endl;
    }
}

double f(double a, double b) {
   return a*b + b*b;
} 

[makosia15]

wow, super, dzięki wielkie, widzę parę swoich błędów:0)

[kalwi]

Ten kod też nie jest idealny, ale to już trochę czepianie się na siłę by było (aczkolwiek wydaje mi się, że athame specjalnie użył zmiennych globalnych).

Ukryta treść:    

- niepotrzebnie użyte zmienne globalne
- double delta, double gamma - tutaj można by użyć const
- zamiast i++ lepiej używać ++i - niby kompilator powinien to zoptymalizować, ale mogą być przypadki, kiedy tego nie zrobi

[athame]

Wg konwencji: zmienne deklarowane osobno, w funkcjach tylko operacje. Const. w sumie może być lub nie - dotyczy to także \(\displaystyle{ h}\). Co do trzeciej uwagi, to pierwsze słyszę - sprawdziłem i nie potwierdzam (GCC 6.1.1).

[kalwi]

No to to jest zła konwencja, bo używania zmiennych globalnych należy unikać, jeśli tego można - czyli niemalże zawsze. Aczkolwiek w przypadku programów wieloplikowych wygodnie jest sobie zdefiniować stałe (globalne) w osobnym pliku. Tutaj to oczywiście nie ma znaczenia - ale chodzi po prostu o praktykę.
Const może być lub może nie być - ale dobrą praktyką jest go dać przy stałych.
Co do inkrementacji - odpowiedź jest tu: