int main(void)
{ int errflag = 0;
double local_7[CHECK_POSITIONS * VAL_NUM];
double local_9[CHECK_POSITIONS * VAL_NUM];
double local_11[CHECK_POSITIONS * VAL_NUM];
double check = 0;
double global_error = 0;
if (errflag == 0)
errflag = runge(&global_error, 1e-7, "data_-7.csv", local_7);
printf("Global error for -7: %e\n", global_error);
if (errflag == 0)
errflag = runge(&global_error, 1e-9, "data_-9.csv", local_9);
printf("Global error for -9: %e\n", global_error);
if (errflag == 0)
errflag = runge(&global_error, 1e-11,"data_-11.csv", local_11);
printf("Global error for -11: %e\n", global_error);
printf("\n Local errors for:\n");
for (int i=0;i<CHECK_POSITIONS*VAL_NUM;i++){
if ((local_7[i] != 0)&&(local_9[i] != 0)&&(local_11[i] != 0)){
printf("%d",i);
check = (local_7[i] - local_9[i])/(local_9[i] - local_11[i]);
printf("local_error = %e\n", check);
}
}
if (errflag == -1) printf("File error!\n");
if (errflag == -2) printf("Default too small step!\n");
if (errflag == -3) printf("Memory error!\n");
return 0;
}
int main(){
int n = 6;
int m = n;
Matrix x = Linspace(-4.0, 4.0, m+1, 1);
Matrix y = Linspace(-4.0, 4.0, n+1, 1);
Matrix f(x.Size(), y.Size());
for(int i = 0; i < x.Size(); i++){
for(int j = 0; j < y.Size(); j++){
f(i, j) = 1/(1+(x(i)*x(i)) + (y(j)*y(j)));
}
}
Matrix a = Linspace(-4.0, 4.0, 201, 1);
a.Write("avals.txt");
Matrix b = Linspace(-4.0, 4.0, 101, 1);
b.Write("bvals.txt");
Matrix p6(a.Size(), b.Size());
for(int i = 0; i < a.Size(); i++){
for(int j = 0; j < b.Size(); j++){
p6(i, j) = Lagrange2D(x, y, f, a(i), b(j));
}
}
p6.Write("p6_uni.txt");
n = 24;
m = n;
x = Linspace(-4.0, 4.0, m+1, 1);
y = Linspace(-4.0, 4.0, n+1, 1);
f = Matrix(x.Size(), y.Size());
for(int i = 0; i < x.Size(); i++){
for(int j = 0; j < y.Size(); j++){
f(i, j) = 1/(1+(x(i)*x(i)) + (y(j)*y(j)));
}
}
Matrix p24(a.Size(), b.Size());
for(int i = 0; i < a.Size(); i++){
for(int j = 0; j < b.Size(); j++){
p24(i, j) = Lagrange2D(x, y, f, a(i), b(j));
}
}
p24.Write("p24_uni.txt");
Matrix runge(201, 101);
for(int i = 0; i < a.Size(); i++){
for(int j = 0; j < b.Size(); j++){
runge(i, j) = 1/(1+(a(i)*a(i)) + (b(j)*b(j)));
}
}
//create runge matrix
runge.Write("Runge.txt");
}
Vector adams()
{
size_t numof_xs = get_numof_xs(h);
Vector runge_ys = runge();
Vector adams_ys;
initVector(&adams_ys, numof_xs);
for (size_t i = 0; i < adams_acc; ++i)
append(&adams_ys, runge_ys.values[i]);
disposeVector(&runge_ys);
Vector etas;
initVector(&etas, numof_xs);
for (size_t i = 0; i < adams_acc; ++i)
append(&etas, eta(i, adams_ys.values[i]));
FiniteDiffTable table = createFiniteDiffTable(&etas);
for (size_t k = 5; k < numof_xs; ++k) {
double yk = adams_next_yk(adams_ys.values[k - 1], &table);
append(&adams_ys, yk);
append(&etas, eta(k, yk));
disposeFiniteDiffTable(&table);
table = createFiniteDiffTable(&etas);
}
printTable(&table, &adams_ys, stdout);
disposeVector(&etas);
disposeFiniteDiffTable(&table);
return adams_ys;
}
Vector print_runge()
{
printf("Runge-Kutta\n");
Vector runge_ys = runge();
printVector(&runge_ys, stdout);
printf("\n\n");
return runge_ys;
}
int main(void) {
int i, j, randam = 0, step = 0/*tane=1*/;
double t, I1, I2, HAKKA;
int N1[neuron] = {1}, N2[neuron] = {1}, count[neuron] = {0};
int spike1[neuron] = {0}, spike2[neuron] = {0};
double I[neuron] = {0.0}, V[neuron] = {0.0};
double w1[neuron] = {1.0};
double Itime[neuron][max]={0.0};
double I1time[neuron] = {0.0};
double I2time[neuron] = {0.0};
double HAKKAtime[neuron][max]= {0.0};
/////////////////////////////////////////////////////////////////////////////////////
// FILE *fp,*fp1,*fp2;
/////////////////////////////////////////////////////////////////////////////////////
// fp = fopen("7bth.txt","w"); //Vtの関係のファイル作成
// fp1 = fopen("Ib.txt","w"); //Iの挙動のファイル作成
// fp2 = fopen("+20.txt","w"); //w1の挙動のファイル作成
/* for(tane=1; tane<=2; tane++){
step=0.0;
for(i=0;i<=neuron;i++){
for(j=0;j<=max;j++){
Itime[i][j]=0.0;
HAKKAtime[i][j]= 0.0;
}
N1[i] = 1; N2[i] = 1; count[i] = 0;
spike1[i] = 0; spike2[i] = 0;
I[i] = 0.0; V[i] = 0.0;
w1[i] = 1.0;
I1time[i] = 0.0;
I2time[i] = 0.0;
}*/
srand(tane);//srand関数
// I2のスパイクが出る時間が決まった
for(i = 0; i < neuron; i++) {
for(j = 0; j < max; j++) {
// ランダムの値を101で割った余り、つまり0から100のどれか
randam = rand() % 101;
// I2のスパイクが出る時間、ノイズを50μsにした
Itime[i][j] = (2.5 * j) + (okure + 0.001 * (randam - 50));
}
}
// 時刻を進める
// t[ms]
for(t = 0.000; t <= tmax + h; t += h) {
step++;
// neuron個のニューロンを考える
for(i = 0; i < neuron; i++) {
spike1[i] = 0;
spike2[i] = 0;
// printf("t:%lf Itime %lf\n",t,Itime[i]);
// 0.001を2500回刻んだときN1をプラス、N1はそれまでに出たスパイクの累計
// I1について
if(step == (N1[i] * 2500)) {
// if((int)(t * 1000) % 2500 == 0) {
N1[i]++;
I1time[i] = t;
spike1[i] = 1;
}
// I2のスパイク数の更新と次のスパイク時間への更新
if(Itime[i][N2[i]] < t) {
I2time[i] = Itime[i][N2[i]];
N2[i]++;
spike2[i] = 1;
}
I1=0.0; I2=0.0;
// printf("M,step=%d,%d\n",N1,step);
I1 = keisanI1(t, N1[i] - 1); // I1を計算
I2 = keisanI2(t, N2[i]-1, Itime[i]); // I2を計算
HAKKA = 0.0;
for(j = 0; j < neuron; j++)
{
if(i!=j){
HAKKA += keisanHakka(t, count, HAKKAtime,j);
}
}
I[i] = w1[i] * I1 + w2 * I2 + 0.75 * HAKKA; // 入力電流の合計
V[i] = runge(V[i], I[i]); // ルンゲクッタ法によるVの更新
// I1もしくはI2のスパイクが出たさいにw1を更新する
if(spike1[i]==1 || spike2[i]==1) {
// この条件のもとでだけ、w1を変化するように条件を設定
if(fabs(I1time[i] - I2time[i]) <= okure + 0.05) {
w1[i] = Wkousin(I1time[i], I2time[i], w1[i]);
}
}
// 頭うち
if(w1[i] >= 2.5) w1[i] = 2.5;
//Vが閾値を超えたら50mVにいく
if(V[i] >= theta) {
V[i] = 50;
HAKKAtime[i][count[i]] = t;
count[i]++;
}
/////////////////////////////////////////////////////////////////////////////////////
// fprintf(fp, "%lf %lf\n", t, V);
// fprintf(fp1, "%lf %lf\n", t, I); // 時刻tと電流Iの電流を出力
// fprintf(fp2, "%lf %lf\n", t, w1);
//50mVに飛ばしたら次には0に戻す
if(V[i] >= theta) V[i] = Vreset;
}
}
// 結果の出力
printf("tane : %d\n", tane);
for(i = 0; i < neuron; i++) {
printf("%d : %d\n", i + 1, count[i]);
}
printf("----------\n");
printf("\a");
// }
/////////////////////////////////////////////////////////////////////////////////////
// fclose(fp);
// fclose(fp1);
// fclose(fp2);
return 0;
}
