| 情報学部 | 菅沼ホーム | 目次 | 索引 |
/************************************/
/* Hopfieldネットワーク（連想記憶） */
/* Coded by Y.Suganuma) */
/************************************/
#include <stdio.h>
#include <time.h>
#include "MT.h"
int main()
{
int a[3][36] = {{0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0},
{0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1}};
int W[36][36], n = 36, p = 3;
// 重みの設定（学習）
for (int i1 = 0; i1 < n-1; i1++) {
for (int i2 = i1+1; i2 < n; i2++) {
W[i1][i2] = 0;
for (int i3 = 0; i3 < p; i3++)
W[i1][i2] += (2 * a[i3][i1] - 1) * (2 * a[i3][i2] - 1);
W[i2][i1] = W[i1][i2];
}
}
for (int i1 = 0; i1 < n; i1++)
W[i1][i1] = 0;
// 初期状態
init_genrand((unsigned)time(NULL));
int u[36], m, pn;
printf("パターン番号と修正ユニット数 ");
scanf ("%d %d", &pn, &m);
for (int i1 = 0; i1 < n; i1++)
u[i1] = a[pn][i1];
for (int i1 = 0; i1 < m; i1++) {
int k = (int)(genrand_real3() * n);
if (k >= n)
k = n - 1;
if (u[k] > 0)
u[k] = 0;
else
u[k] = 1;
}
printf("初期状態：\n");
int k = 0;
for (int i1 = 0; i1 < 6; i1++) {
for (int i2 = 0; i2 < 6; i2++) {
printf("%2d", u[k]);
k++;
}
printf("\n");
}
// 更新
int count1 = 0, count2 = 0, count3 = 0;
while (count1 < 100) {
count2++;
bool sw = false;
k = (int)(genrand_real3() * n);
if (k >= n)
k = n - 1;
int s = 0;
for (int i1 = 0; i1 < n; i1++)
s += W[k][i1] * u[i1];
if (s >= 0) {
if (u[k] == 0) {
sw = true;
u[k] = 1;
}
}
else {
if (u[k] > 0) {
sw = true;
u[k] = 0;
}
}
if (sw) {
count1 = 0;
count3++;
}
else
count1++;
}
// 結果
printf("試行回数 = %d，更新回数 = %d\n", count2, count3);
k = 0;
for (int i1 = 0; i1 < 6; i1++) {
for (int i2 = 0; i2 < 6; i2++) {
printf("%2d", u[k]);
k++;
}
printf("\n");
}
return 0;
}
//---------------------MT.h---------------------------
// A C-program for MT19937, with initialization improved 2002/1/26.
// Coded by Takuji Nishimura and Makoto Matsumoto.
//
// Before using, initialize the state by using init_genrand(seed)
// or init_by_array(init_key, key_length).
//
// Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. The names of its contributors may not be used to endorse or promote
// products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//
// Any feedback is very welcome.
// http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
// email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
// The original version of http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c was modified by Takahiro Omi as
// - delete line 47 "#include<stdio.h>"
// - delete line 174 int main(void){...}
// - change N -> MT_N
// - change N -> MT_N
// - change the file name "mt19937ar.c" -> "MT.h"
/*
// Period parameters
#define MT_N 624
#define MT_M 397
#define MATRIX_A 0x9908b0dfUL // constant vector a
#define UPPER_MASK 0x80000000UL // most significant w-r bits
#define LOWER_MASK 0x7fffffffUL // least significant r bits
static unsigned long mt[MT_N]; // the array for the state vector
static int mti=MT_N+1; // mti==MT_N+1 means mt[MT_N] is not initialized
// initializes mt[MT_N] with a seed
void init_genrand(unsigned long s)
{
mt[0]= s & 0xffffffffUL;
for (mti=1; mti<MT_N; mti++) {
mt[mti] =
(1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
// See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier.
// In the previous versions, MSBs of the seed affect
// only MSBs of the array mt[].
// 2002/01/09 modified by Makoto Matsumoto
mt[mti] &= 0xffffffffUL;
// for >32 bit machines
}
}
// initialize by an array with array-length
// init_key is the array for initializing keys
// key_length is its length
// slight change for C++, 2004/2/26
void init_by_array(unsigned long init_key[], int key_length)
{
int i, j, k;
init_genrand(19650218UL);
i=1; j=0;
k = (MT_N>key_length ? MT_N : key_length);
for (; k; k--) {
mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
+ init_key[j] + j; // non linear
mt[i] &= 0xffffffffUL; // for WORDSIZE > 32 machines
i++; j++;
if (i>=MT_N) { mt[0] = mt[MT_N-1]; i=1; }
if (j>=key_length) j=0;
}
for (k=MT_N-1; k; k--) {
mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
- i; // non linear
mt[i] &= 0xffffffffUL; // for WORDSIZE > 32 machines
i++;
if (i>=MT_N) { mt[0] = mt[MT_N-1]; i=1; }
}
mt[0] = 0x80000000UL; // MSB is 1; assuring non-zero initial array
}
// generates a random number on [0,0xffffffff]-interval
unsigned long genrand_int32(void)
{
unsigned long y;
static unsigned long mag01[2]={0x0UL, MATRIX_A};
// mag01[x] = x * MATRIX_A for x=0,1
if (mti >= MT_N) { // generate N words at one time
int kk;
if (mti == MT_N+1) // if init_genrand() has not been called,
init_genrand(5489UL); // a default initial seed is used
for (kk=0;kk<MT_N-MT_M;kk++) {
y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk] = mt[kk+MT_M] ^ (y >> 1) ^ mag01[y & 0x1UL];
}
for (;kk<MT_N-1;kk++) {
y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk] = mt[kk+(MT_M-MT_N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
}
y = (mt[MT_N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
mt[MT_N-1] = mt[MT_M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
mti = 0;
}
y = mt[mti++];
// Tempering
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return y;
}
// generates a random number on [0,0x7fffffff]-interval
long genrand_int31(void)
{
return (long)(genrand_int32()>>1);
}
// generates a random number on [0,1]-real-interval
double genrand_real1(void)
{
return genrand_int32()*(1.0/4294967295.0);
// divided by 2^32-1
}
// generates a random number on [0,1)-real-interval
double genrand_real2(void)
{
return genrand_int32()*(1.0/4294967296.0);
// divided by 2^32
}
// generates a random number on (0,1)-real-interval
double genrand_real3(void)
{
return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0);
// divided by 2^32
}
// generates a random number on [0,1) with 53-bit resolution
double genrand_res53(void)
{
unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
return(a*67108864.0+b)*(1.0/9007199254740992.0);
}
// These real versions are due to Isaku Wada, 2002/01/09 added
*/
/*********************************/
/* Hopfieldネットワーク（ TSP ） */
/* Coded by Y.Suganuma) */
/*********************************/
#include <stdio.h>
#include <time.h>
#include <math.h>
#include "MT.h"
double out(double);
void snx(double, double *, double *);
double rkg(double, double, double *, double *, double **, int, void (*)(double, double *, double *));
int n = 4;
double A = 10.0, B = 10.0, C = 10.0, D = 2.0, d[4][4];
int main()
{
// 距離
double r = sqrt(2.0);
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++) {
if (i1 == i2)
d[i1][i2] = 0.0;
else
d[i1][i2] = 1.0;
}
}
d[0][2] = r;
d[1][3] = r;
d[2][0] = r;
d[3][1] = r;
// 初期状態
double u[4][4];
init_genrand((unsigned)time(NULL));
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++)
u[i1][i2] = 0.1 * genrand_real3() - 0.05;
}
printf("初期状態（出力）：\n");
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++)
printf("%6.3f", out(u[i1][i2]));
printf("\n");
}
// 更新
double time = 0.0, dx[16], **g = new double * [4];
for (int i1 = 0; i1 < 4; i1++)
g[i1] = new double [16];
for (int i1 = 0; i1 < 100; i1++)
time = rkg(time, 1, &u[0][0], dx, g, n*n, snx);
printf("最終状態（出力）：\n");
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++)
printf("%6.3f", out(u[i1][i2]));
printf("\n");
}
return 0;
}
/******************/
/* ユニットの出力 */
/******************/
double out(double x)
{
return 0.5 * (1.0 + tanh(x));
// return 1.0 / (1.0 + exp(-x));
}
/****************/
/* 微係数の計算 */
/****************/
void snx(double time, double *u, double *du)
{
for (int x = 0; x < n; x++) {
for (int i = 0; i < n; i++) {
int k = n * x + i;
du[k] = 0.0;
for (int j = 0; j < n; j++) {
if (j != i)
du[k] -= A * out(u[n*x+j]);
}
for (int y = 0; y < n; y++) {
if (y != x)
du[k] -= B * out(u[n*y+i]);
}
double N = 0.0;
for (int xx = 0; xx < n; xx++) {
for (int ii = 0; ii < n; ii++)
N += out(u[n*xx+ii]);
}
du[k] -= C * (N - n);
for (int y = 0; y < n; y++) {
int m1 = (i + 1) % n;
int m2 = i - 1;
if (m2 < 0)
m2 = n - 1;
du[k] -= D * d[x][y] * (out(u[n*y+m1]) + out(u[n*y+m2]));
}
}
}
}
/*******************************************/
/* ルンゲ・クッタ法 dx/dt=f(t,x) */
/* time : 現在の時間 */
/* h : 時間刻み幅 */
/* x : 現在の状態 */
/* dx : 微係数（f(t,x):snxで計算する）*/
/* g : 作業域（g[4][n]） */
/* n : 微分方程式の次数 */
/* sub : 微係数を計算する関数の名前 */
/* return : time+h */
/*******************************************/
double rkg(double time, double h, double *x, double *dx, double **g,
int n, void (*sub)(double, double *, double *))
{
int i1;
double h2;
h2 = 0.5 * h;
(*sub)(time, x, dx);
for (i1 = 0; i1 < n; i1++)
g[0][i1] = h * dx[i1];
time += h2;
for (i1 = 0; i1 < n; i1++)
g[1][i1] = x[i1] + 0.5 * g[0][i1];
(*sub)(time, g[1], dx);
for (i1 = 0; i1 < n; i1++)
g[1][i1] = h * dx[i1];
for (i1 = 0; i1 < n; i1++)
g[2][i1] = x[i1] + 0.5 * g[1][i1];
(*sub)(time, g[2], dx);
for (i1 = 0; i1 < n; i1++)
g[2][i1] = h * dx[i1];
time += h2;
for (i1 = 0; i1 < n; i1++)
g[3][i1] = x[i1] + g[2][i1];
(*sub)(time, g[3], dx);
for (i1 = 0; i1 < n; i1++)
g[3][i1] = h * dx[i1];
for (i1 = 0; i1 < n; i1++)
x[i1] = x[i1] + (g[0][i1] + 2.0 * g[1][i1] + 2.0 * g[2][i1] + g[3][i1]) / 6.0;
return time;
}
//---------------------MT.h---------------------------
// A C-program for MT19937, with initialization improved 2002/1/26.
// Coded by Takuji Nishimura and Makoto Matsumoto.
//
// Before using, initialize the state by using init_genrand(seed)
// or init_by_array(init_key, key_length).
//
// Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. The names of its contributors may not be used to endorse or promote
// products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
//
// Any feedback is very welcome.
// http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
// email: m-mat @ math.sci.hiroshima-u.ac.jp (remove space)
// The original version of http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/CODES/mt19937ar.c was modified by Takahiro Omi as
// - delete line 47 "#include<stdio.h>"
// - delete line 174 int main(void){...}
// - change N -> MT_N
// - change N -> MT_N
// - change the file name "mt19937ar.c" -> "MT.h"
/*
// Period parameters
#define MT_N 624
#define MT_M 397
#define MATRIX_A 0x9908b0dfUL // constant vector a
#define UPPER_MASK 0x80000000UL // most significant w-r bits
#define LOWER_MASK 0x7fffffffUL // least significant r bits
static unsigned long mt[MT_N]; // the array for the state vector
static int mti=MT_N+1; // mti==MT_N+1 means mt[MT_N] is not initialized
// initializes mt[MT_N] with a seed
void init_genrand(unsigned long s)
{
mt[0]= s & 0xffffffffUL;
for (mti=1; mti<MT_N; mti++) {
mt[mti] =
(1812433253UL * (mt[mti-1] ^ (mt[mti-1] >> 30)) + mti);
// See Knuth TAOCP Vol2. 3rd Ed. P.106 for multiplier.
// In the previous versions, MSBs of the seed affect
// only MSBs of the array mt[].
// 2002/01/09 modified by Makoto Matsumoto
mt[mti] &= 0xffffffffUL;
// for >32 bit machines
}
}
// initialize by an array with array-length
// init_key is the array for initializing keys
// key_length is its length
// slight change for C++, 2004/2/26
void init_by_array(unsigned long init_key[], int key_length)
{
int i, j, k;
init_genrand(19650218UL);
i=1; j=0;
k = (MT_N>key_length ? MT_N : key_length);
for (; k; k--) {
mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525UL))
+ init_key[j] + j; // non linear
mt[i] &= 0xffffffffUL; // for WORDSIZE > 32 machines
i++; j++;
if (i>=MT_N) { mt[0] = mt[MT_N-1]; i=1; }
if (j>=key_length) j=0;
}
for (k=MT_N-1; k; k--) {
mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941UL))
- i; // non linear
mt[i] &= 0xffffffffUL; // for WORDSIZE > 32 machines
i++;
if (i>=MT_N) { mt[0] = mt[MT_N-1]; i=1; }
}
mt[0] = 0x80000000UL; // MSB is 1; assuring non-zero initial array
}
// generates a random number on [0,0xffffffff]-interval
unsigned long genrand_int32(void)
{
unsigned long y;
static unsigned long mag01[2]={0x0UL, MATRIX_A};
// mag01[x] = x * MATRIX_A for x=0,1
if (mti >= MT_N) { // generate N words at one time
int kk;
if (mti == MT_N+1) // if init_genrand() has not been called,
init_genrand(5489UL); // a default initial seed is used
for (kk=0;kk<MT_N-MT_M;kk++) {
y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk] = mt[kk+MT_M] ^ (y >> 1) ^ mag01[y & 0x1UL];
}
for (;kk<MT_N-1;kk++) {
y = (mt[kk]&UPPER_MASK)|(mt[kk+1]&LOWER_MASK);
mt[kk] = mt[kk+(MT_M-MT_N)] ^ (y >> 1) ^ mag01[y & 0x1UL];
}
y = (mt[MT_N-1]&UPPER_MASK)|(mt[0]&LOWER_MASK);
mt[MT_N-1] = mt[MT_M-1] ^ (y >> 1) ^ mag01[y & 0x1UL];
mti = 0;
}
y = mt[mti++];
// Tempering
y ^= (y >> 11);
y ^= (y << 7) & 0x9d2c5680UL;
y ^= (y << 15) & 0xefc60000UL;
y ^= (y >> 18);
return y;
}
// generates a random number on [0,0x7fffffff]-interval
long genrand_int31(void)
{
return (long)(genrand_int32()>>1);
}
// generates a random number on [0,1]-real-interval
double genrand_real1(void)
{
return genrand_int32()*(1.0/4294967295.0);
// divided by 2^32-1
}
// generates a random number on [0,1)-real-interval
double genrand_real2(void)
{
return genrand_int32()*(1.0/4294967296.0);
// divided by 2^32
}
// generates a random number on (0,1)-real-interval
double genrand_real3(void)
{
return (((double)genrand_int32()) + 0.5)*(1.0/4294967296.0);
// divided by 2^32
}
// generates a random number on [0,1) with 53-bit resolution
double genrand_res53(void)
{
unsigned long a=genrand_int32()>>5, b=genrand_int32()>>6;
return(a*67108864.0+b)*(1.0/9007199254740992.0);
}
// These real versions are due to Isaku Wada, 2002/01/09 added
*/
/************************************/
/* Hopfieldネットワーク（連想記憶） */
/* Coded by Y.Suganuma) */
/************************************/
import java.io.*;
import java.util.StringTokenizer;
import java.util.Random;
public class Test1 {
public static void main(String args[])
{
int a[][] = {{0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0},
{0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1}};
int W[][] = new int [36][36], n = 36, p = 3;
// 重みの設定（学習）
for (int i1 = 0; i1 < n-1; i1++) {
for (int i2 = i1+1; i2 < n; i2++) {
W[i1][i2] = 0;
for (int i3 = 0; i3 < p; i3++)
W[i1][i2] += (2 * a[i3][i1] - 1) * (2 * a[i3][i2] - 1);
W[i2][i1] = W[i1][i2];
}
}
for (int i1 = 0; i1 < n; i1++)
W[i1][i1] = 0;
// 初期状態
Random rn = new Random();
Console con = System.console();
String line = con.readLine("パターン番号と修正ユニット数 ");
StringTokenizer str = new StringTokenizer(line, " ");
int pn = Integer.parseInt(str.nextToken());
int m = Integer.parseInt(str.nextToken());
int u[] = new int [36];
for (int i1 = 0; i1 < n; i1++)
u[i1] = a[pn][i1];
for (int i1 = 0; i1 < m; i1++) {
int k = (int)(rn.nextDouble() * n);
if (k >= n)
k = n - 1;
if (u[k] > 0)
u[k] = 0;
else
u[k] = 1;
}
con.printf("初期状態：\n");
int k = 0;
for (int i1 = 0; i1 < 6; i1++) {
for (int i2 = 0; i2 < 6; i2++) {
con.printf("%2d", u[k]);
k++;
}
con.printf("\n");
}
// 更新
int count1 = 0, count2 = 0, count3 = 0;
while (count1 < 100) {
count2++;
boolean sw = false;
k = (int)(rn.nextDouble() * n);
if (k >= n)
k = n - 1;
int s = 0;
for (int i1 = 0; i1 < n; i1++)
s += W[k][i1] * u[i1];
if (s >= 0) {
if (u[k] == 0) {
sw = true;
u[k] = 1;
}
}
else {
if (u[k] > 0) {
sw = true;
u[k] = 0;
}
}
if (sw) {
count1 = 0;
count3++;
}
else
count1++;
}
// 結果
con.printf("試行回数 = %d，更新回数 = %d\n", count2, count3);
k = 0;
for (int i1 = 0; i1 < 6; i1++) {
for (int i2 = 0; i2 < 6; i2++) {
con.printf("%2d", u[k]);
k++;
}
con.printf("\n");
}
}
}
/*********************************/
/* Hopfieldネットワーク（ TSP ） */
/* Coded by Y.Suganuma) */
/*********************************/
import java.io.*;
import java.util.StringTokenizer;
import java.util.Random;
public class Test2 {
static int n = 4;
static double A = 10.0, B = 10.0, C = 10.0, D = 2.0, d[][] = new double [n][n];
public static void main(String args[])
{
// 距離
double r = Math.sqrt(2.0);
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++) {
if (i1 == i2)
d[i1][i2] = 0.0;
else
d[i1][i2] = 1.0;
}
}
d[0][2] = r;
d[1][3] = r;
d[2][0] = r;
d[3][1] = r;
// 初期状態
double u[][] = new double [n][n];
Random rn = new Random();
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++)
u[i1][i2] = 0.1 * rn.nextDouble() - 0.05;
}
Console con = System.console();
con.printf("初期状態（出力）：\n");
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++)
con.printf("%6.3f", out(u[i1][i2]));
con.printf("\n");
}
// 更新
double time = 0.0;
double dx[] = new double[n*n];
double uu[] = new double[n*n];
double g[][] = new double [4][n*n];
int k = 0;
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++) {
uu[k] = u[i1][i2];
k++;
}
}
for (int i1 = 0; i1 < 100; i1++)
time = rkg(time, 1, uu, dx, g, n*n);
con.printf("最終状態（出力）：\n");
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++)
con.printf("%6.3f", out(uu[i1*n+i2]));
con.printf("\n");
}
}
/******************/
/* ユニットの出力 */
/******************/
static double out(double x)
{
return 0.5 * (1.0 + Math.tanh(x));
// return 1.0 / (1.0 + Math.exp(-x));
}
/****************/
/* 微係数の計算 */
/****************/
static void snx(double time, double u[], double du[])
{
for (int x = 0; x < n; x++) {
for (int i = 0; i < n; i++) {
int k = n * x + i;
du[k] = 0.0;
for (int j = 0; j < n; j++) {
if (j != i)
du[k] -= A * out(u[n*x+j]);
}
for (int y = 0; y < n; y++) {
if (y != x)
du[k] -= B * out(u[n*y+i]);
}
double N = 0.0;
for (int xx = 0; xx < n; xx++) {
for (int ii = 0; ii < n; ii++)
N += out(u[n*xx+ii]);
}
du[k] -= C * (N - n);
for (int y = 0; y < n; y++) {
int m1 = (i + 1) % n;
int m2 = i - 1;
if (m2 < 0)
m2 = n - 1;
du[k] -= D * d[x][y] * (out(u[n*y+m1]) + out(u[n*y+m2]));
}
}
}
}
/*************************************************/
/* ルンゲ・クッタ法 dx/dt=f(t,x) */
/* time : 現在の時間 */
/* h : 時間刻み幅 */
/* x : 現在の状態 */
/* dx : 微係数（f(t,x):snxで計算する） */
/* g : 作業域（g[4][n]） */
/* n : 微分方程式の次数 */
/* return : time+h */
/*************************************************/
static double rkg(double time, double h, double x[], double dx[], double g[][], int n)
{
int i1;
double h2;
h2 = 0.5 * h;
snx(time, x, dx);
for (i1 = 0; i1 < n; i1++)
g[0][i1] = h * dx[i1];
time += h2;
for (i1 = 0; i1 < n; i1++)
g[1][i1] = x[i1] + 0.5 * g[0][i1];
snx(time, g[1], dx);
for (i1 = 0; i1 < n; i1++)
g[1][i1] = h * dx[i1];
for (i1 = 0; i1 < n; i1++)
g[2][i1] = x[i1] + 0.5 * g[1][i1];
snx(time, g[2], dx);
for (i1 = 0; i1 < n; i1++)
g[2][i1] = h * dx[i1];
time += h2;
for (i1 = 0; i1 < n; i1++)
g[3][i1] = x[i1] + g[2][i1];
snx(time, g[3], dx);
for (i1 = 0; i1 < n; i1++)
g[3][i1] = h * dx[i1];
for (i1 = 0; i1 < n; i1++)
x[i1] = x[i1] + (g[0][i1] + 2.0 * g[1][i1] + 2.0 * g[2][i1] + g[3][i1]) / 6.0;
return time;
}
}
<!DOCTYPE HTML>
<HTML>
<HEAD>
<TITLE>Hopfieldネットワーク（連想記憶）</TITLE>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
<SCRIPT TYPE="text/javascript">
function main()
{
res = "";
let n = 36, p = 3;
let a = new Array(3);
a[0] = new Array(0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0);
a[1] = new Array(0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0);
a[2] = new Array(1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1);
let W = new Array(n);
for (let i1 = 0; i1 < n; i1++)
W[i1] = new Array(n);
// 重みの設定（学習）
for (let i1 = 0; i1 < n-1; i1++) {
for (let i2 = i1+1; i2 < n; i2++) {
W[i1][i2] = 0;
for (let i3 = 0; i3 < p; i3++)
W[i1][i2] += (2 * a[i3][i1] - 1) * (2 * a[i3][i2] - 1);
W[i2][i1] = W[i1][i2];
}
}
for (let i1 = 0; i1 < n; i1++)
W[i1][i1] = 0;
// 初期状態
let pn = parseInt(document.getElementById("pn").value);
let m = parseInt(document.getElementById("m").value);
let u = new Array(n);
for (let i1 = 0; i1 < n; i1++)
u[i1] = a[pn][i1];
let k;
for (let i1 = 0; i1 < m; i1++) {
k = Math.floor(Math.random() * n);
if (k >= n)
k = n - 1;
if (u[k] > 0)
u[k] = 0;
else
u[k] = 1;
}
res += "初期状態：\n";
k = 0;
for (let i1 = 0; i1 < 6; i1++) {
for (let i2 = 0; i2 < 6; i2++) {
res += (" " + u[k]);
k++;
}
res += "\n";
}
// 更新
let count1 = 0, count2 = 0, count3 = 0;
while (count1 < 100) {
count2++;
let sw = 0;
k = Math.floor(Math.random() * n);
if (k >= n)
k = n - 1;
let s = 0;
for (let i1 = 0; i1 < n; i1++)
s += W[k][i1] * u[i1];
if (s >= 0) {
if (u[k] == 0) {
sw = 1;
u[k] = 1;
}
}
else {
if (u[k] > 0) {
sw = 1;
u[k] = 0;
}
}
if (sw > 0) {
count1 = 0;
count3++;
}
else
count1++;
}
// 結果
res += ("試行回数 = " + count2 + "，更新回数 = " + count3 + "\n");
k = 0;
for (let i1 = 0; i1 < 6; i1++) {
for (let i2 = 0; i2 < 6; i2++) {
res += (" " + u[k]);
k++;
}
res += "\n";
}
document.getElementById("result").value = res;
}
</SCRIPT>
</HEAD>
<BODY STYLE="font-size: 130%; text-align:center; background-color: #eeffee;">
<H2><B>Hopfieldネットワーク（連想記憶）</B></H2>
パターン番号(0～2)：<INPUT ID="pn" STYLE="font-size: 100%" TYPE="text" SIZE="2" VALUE="0">
修正ユニット数：<INPUT ID="m" STYLE="font-size: 100%" TYPE="text" SIZE="2" VALUE="5">
<BUTTON STYLE="font-size: 100%; background-color: pink" onClick="return main()">実行</BUTTON><BR>
<DIV STYLE="text-align:center">結果</DIV>
<TEXTAREA ID="result" COLS="50" ROWS="10" STYLE="font-size: 100%;"></TEXTAREA>
</BODY>
</HTML>
<!DOCTYPE HTML>
<HTML>
<HEAD>
<TITLE>Hopfieldネットワーク（ TSP ）</TITLE>
<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
<SCRIPT TYPE="text/javascript">
res = "";
n = 4;
A = 10.0;
B = 10.0;
C = 10.0;
D = 2.0;
d = null;
/****************/
/* main program */
/****************/
function main()
{
d = new Array(n);
for (let i1 = 0; i1 < n; i1++)
d[i1] = new Array(n);
// 距離
let r = Math.sqrt(2.0);
for (let i1 = 0; i1 < n; i1++) {
for (let i2 = 0; i2 < n; i2++) {
if (i1 == i2)
d[i1][i2] = 0.0;
else
d[i1][i2] = 1.0;
}
}
d[0][2] = r;
d[1][3] = r;
d[2][0] = r;
d[3][1] = r;
// 初期状態
let u = new Array(n);
for (let i1 = 0; i1 < n; i1++) {
u[i1] = new Array(n);
for (let i2 = 0; i2 < n; i2++)
u[i1][i2] = 0.1 * Math.random() - 0.05;
}
res = "初期状態（出力）：\n";
for (let i1 = 0; i1 < n; i1++) {
for (let i2 = 0; i2 < n; i2++)
res += (" " + out_u(u[i1][i2]));
res += "\n";
}
document.getElementById("init").value = res;
// 更新
let time = 0.0;
let nn = n * n;
let dx = new Array(nn);
let uu = new Array(nn);
let g = new Array(4);
for (let i1 = 0; i1 < 4; i1++)
g[i1] = new Array(nn);
let k = 0;
for (let i1 = 0; i1 < n; i1++) {
for (let i2 = 0; i2 < n; i2++) {
uu[k] = u[i1][i2];
k++;
}
}
for (let i1 = 0; i1 < 100; i1++)
time = rkg(time, 1, uu, dx, g, (nn), snx);
res = "最終状態（出力）：\n";
for (let i1 = 0; i1 < n; i1++) {
for (let i2 = 0; i2 < n; i2++)
res += (" " + out_u(uu[i1*n+i2]));
res += "\n";
}
document.getElementById("result").value = res;
}
/******************/
/* ユニットの出力 */
/******************/
function out_u(x)
{
return 0.5 * (1.0 + Math.tanh(x));
// return 1.0 / (1.0 + Math.exp(-x)); // tanh が使用できない場合（IE など）
}
/****************/
/* 関数値の計算 */
/****************/
function snx(time, u, du)
{
for (let x = 0; x < n; x++) {
for (let i = 0; i < n; i++) {
let k = n * x + i;
du[k] = 0.0;
for (let j = 0; j < n; j++) {
if (j != i)
du[k] -= A * out_u(u[n*x+j]);
}
for (let y = 0; y < n; y++) {
if (y != x)
du[k] -= B * out_u(u[n*y+i]);
}
let N = 0.0;
for (let xx = 0; xx < n; xx++) {
for (let ii = 0; ii < n; ii++)
N += out_u(u[n*xx+ii]);
}
du[k] -= C * (N - n);
for (let y = 0; y < n; y++) {
let m1 = (i + 1) % n;
let m2 = i - 1;
if (m2 < 0)
m2 = n - 1;
du[k] -= D * d[x][y] * (out_u(u[n*y+m1]) + out_u(u[n*y+m2]));
}
}
}
}
/********************************************/
/* ルンゲ・クッタ法 dx/dt=f(t,x) */
/* time : 現在の時間 */
/* h : 時間刻み幅 */
/* x : 現在の状態 */
/* dx : 微係数（f(t,x):snxで計算する） */
/* g : 作業域（g[4][n]） */
/* n : 微分方程式の次数 */
/* fn : 関数値を計算する関数 */
/* return : time+h */
/********************************************/
function rkg(time, h, x, dx, g, n, fn)
{
let h2 = 0.5 * h;
fn(n, x, dx);
for (let i1 = 0; i1 < n; i1++)
g[0][i1] = h * dx[i1];
time += h2;
for (let i1 = 0; i1 < n; i1++)
g[1][i1] = x[i1] + 0.5 * g[0][i1];
fn(n, g[1], dx);
for (let i1 = 0; i1 < n; i1++)
g[1][i1] = h * dx[i1];
for (let i1 = 0; i1 < n; i1++)
g[2][i1] = x[i1] + 0.5 * g[1][i1];
fn(n, g[2], dx);
for (let i1 = 0; i1 < n; i1++)
g[2][i1] = h * dx[i1];
time += h2;
for (let i1 = 0; i1 < n; i1++)
g[3][i1] = x[i1] + g[2][i1];
fn(n, g[3], dx);
for (let i1 = 0; i1 < n; i1++)
g[3][i1] = h * dx[i1];
for (let i1 = 0; i1 < n; i1++)
x[i1] = x[i1] + (g[0][i1] + 2.0 * g[1][i1] + 2.0 * g[2][i1] + g[3][i1]) / 6.0;
return time;
}
</SCRIPT>
</HEAD>
<BODY STYLE="font-size: 130%; text-align:center; background-color: #eeffee;">
<H2><B>Hopfieldネットワーク（ TSP ）</B></H2>
<BUTTON STYLE="font-size: 100%; background-color: pink" onClick="return main()">実行</BUTTON><BR>
<DIV STYLE="width: 800px; margin-right: auto; margin-left: auto">
<DIV STYLE="text-align:center; float: right; width: 400px">
<DIV STYLE="text-align:center">最終状態</DIV>
<TEXTAREA ID="result" COLS="35" ROWS="10" STYLE="font-size: 100%; width: 380px">
</TEXTAREA>
</DIV>
<DIV STYLE="text-align:center; width: 400px">
<DIV STYLE="text-align:center">初期状態</DIV>
<TEXTAREA ID="init" COLS="35" ROWS="10" STYLE="font-size: 100%; width: 380px">
</TEXTAREA>
</DIV>
</DIV>
</BODY>
</HTML>
<?php
/************************************/
/* Hopfieldネットワーク（連想記憶） */
/* Coded by Y.Suganuma) */
/************************************/
$a = array(3);
$a[0] = array(0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0);
$a[1] = array(0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0);
$a[2] = array(1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1);
$n = 36;
$p = 3;
// 重みの設定（学習）
$W = array($n);
for ($i1 = 0; $i1 < $n; $i1++)
$W[$i1] = array($n);
for ($i1 = 0; $i1 < $n-1; $i1++) {
for ($i2 = $i1+1; $i2 < $n; $i2++) {
$W[$i1][$i2] = 0;
for ($i3 = 0; $i3 < $p; $i3++)
$W[$i1][$i2] += (2 * $a[$i3][$i1] - 1) * (2 * $a[$i3][$i2] - 1);
$W[$i2][$i1] = $W[$i1][$i2];
}
}
for ($i1 = 0; $i1 < $n; $i1++)
$W[$i1][$i1] = 0;
// 初期状態
mt_srand();
$u = array(36);
printf("パターン番号(0～1)と修正ユニット数 ");
fscanf(STDIN, "%d %d", $pn, $m);
for ($i1 = 0; $i1 < $n; $i1++)
$u[$i1] = $a[$pn][$i1];
for ($i1 = 0; $i1 < $m; $i1++) {
$k = intval(mt_rand() / mt_getrandmax() * $n);
if ($k >= $n)
$k = $n - 1;
if ($u[$k] > 0)
$u[$k] = 0;
else
$u[$k] = 1;
}
printf("初期状態：\n");
$k = 0;
for ($i1 = 0; $i1 < 6; $i1++) {
for ($i2 = 0; $i2 < 6; $i2++) {
printf("%2d", $u[$k]);
$k++;
}
printf("\n");
}
// 更新
$count1 = 0;
$count2 = 0;
$count3 = 0;
while ($count1 < 100) {
$count2++;
$sw = false;
$k = intval(mt_rand() / mt_getrandmax() * $n);
if ($k >= $n)
$k = $n - 1;
$s = 0;
for ($i1 = 0; $i1 < $n; $i1++)
$s += $W[$k][$i1] * $u[$i1];
if ($s >= 0) {
if ($u[$k] == 0) {
$sw = true;
$u[$k] = 1;
}
}
else {
if ($u[$k] > 0) {
$sw = true;
$u[$k] = 0;
}
}
if ($sw) {
$count1 = 0;
$count3++;
}
else
$count1++;
}
// 結果
printf("試行回数 = %d，更新回数 = %d\n", $count2, $count3);
$k = 0;
for ($i1 = 0; $i1 < 6; $i1++) {
for ($i2 = 0; $i2 < 6; $i2++) {
printf("%2d", $u[$k]);
$k++;
}
printf("\n");
}
?>
<?php
/*********************************/
/* Hopfieldネットワーク（ TSP ） */
/* Coded by Y.Suganuma) */
/*********************************/
$n = 4;
$A = 10.0;
$B = 10.0;
$C = 10.0;
$D = 2.0;
$d = array(4);
for ($i1 = 0; $i1 < 4; $i1++)
$d[$i1] = array(4);
// 距離
$r = sqrt(2.0);
for ($i1 = 0; $i1 < $n; $i1++) {
for ($i2 = 0; $i2 < $n; $i2++) {
if ($i1 == $i2)
$d[$i1][$i2] = 0.0;
else
$d[$i1][$i2] = 1.0;
}
}
$d[0][2] = $r;
$d[1][3] = $r;
$d[2][0] = $r;
$d[3][1] = $r;
// 初期状態
mt_srand();
$u = array(16);
for ($i1 = 0; $i1 < $n; $i1++) {
for ($i2 = 0; $i2 < $n; $i2++)
$u[$i1*$n+$i2] = 0.1 * (mt_rand() / mt_getrandmax()) - 0.05;
}
printf("初期状態（出力）：\n");
for ($i1 = 0; $i1 < $n; $i1++) {
for ($i2 = 0; $i2 < $n; $i2++)
printf("%6.3f", out($u[$i1*$n+$i2]));
printf("\n");
}
// 更新
$time = 0.0;
$dx = array(16);
$g = array(4);
for ($i1 = 0; $i1 < 4; $i1++)
$g[$i1] = array(16);
for ($i1 = 0; $i1 < 100; $i1++)
$time = rkg($time, 1, $u, $dx, $g, $n*$n, "snx");
printf("最終状態（出力）：\n");
for ($i1 = 0; $i1 < $n; $i1++) {
for ($i2 = 0; $i2 < $n; $i2++)
printf("%6.3f", out($u[$i1*$n+$i2]));
printf("\n");
}
/******************/
/* ユニットの出力 */
/******************/
function out($x)
{
return 0.5 * (1.0 + tanh($x));
// return 1.0 / (1.0 + exp(-$x));
}
/****************/
/* 微係数の計算 */
/****************/
function snx($time, $u, &$du)
{
global $n, $A, $B, $C, $D, $d;
for ($x = 0; $x < $n; $x++) {
for ($i = 0; $i < $n; $i++) {
$k = $n * $x + $i;
$du[$k] = 0.0;
for ($j = 0; $j < $n; $j++) {
if ($j != $i)
$du[$k] -= $A * out($u[$n*$x+$j]);
}
for ($y = 0; $y < $n; $y++) {
if ($y != $x)
$du[$k] -= $B * out($u[$n*$y+$i]);
}
$N = 0.0;
for ($xx = 0; $xx < $n; $xx++) {
for ($ii = 0; $ii < $n; $ii++)
$N += out($u[$n*$xx+$ii]);
}
$du[$k] -= $C * ($N - $n);
for ($y = 0; $y < $n; $y++) {
$m1 = ($i + 1) % $n;
$m2 = $i - 1;
if ($m2 < 0)
$m2 = $n - 1;
$du[$k] -= $D * $d[$x][$y] * (out($u[$n*$y+$m1]) + out($u[$n*$y+$m2]));
}
}
}
}
/*******************************************/
/* ルンゲ・クッタ法 dx/dt=f(t,x) */
/* time : 現在の時間 */
/* h : 時間刻み幅 */
/* x : 現在の状態 */
/* dx : 微係数（f(t,x):snxで計算する）*/
/* g : 作業域（g[4][n]） */
/* n : 微分方程式の次数 */
/* sub : 微係数を計算する関数の名前 */
/* return : time+h */
/*******************************************/
function rkg($time, $h, &$x, $dx, $g, $n, $sub)
{
$h2 = 0.5 * $h;
$sub($time, $x, $dx);
for ($i1 = 0; $i1 < $n; $i1++)
$g[0][$i1] = $h * $dx[$i1];
$time += $h2;
for ($i1 = 0; $i1 < $n; $i1++)
$g[1][$i1] = $x[$i1] + 0.5 * $g[0][$i1];
$sub($time, $g[1], $dx);
for ($i1 = 0; $i1 < $n; $i1++)
$g[1][$i1] = $h * $dx[$i1];
for ($i1 = 0; $i1 < $n; $i1++)
$g[2][$i1] = $x[$i1] + 0.5 * $g[1][$i1];
$sub($time, $g[2], $dx);
for ($i1 = 0; $i1 < $n; $i1++)
$g[2][$i1] = $h * $dx[$i1];
$time += $h2;
for ($i1 = 0; $i1 < $n; $i1++)
$g[3][$i1] = $x[$i1] + $g[2][$i1];
$sub($time, $g[3], $dx);
for ($i1 = 0; $i1 < $n; $i1++)
$g[3][$i1] = $h * $dx[$i1];
for ($i1 = 0; $i1 < $n; $i1++)
$x[$i1] = $x[$i1] + ($g[0][$i1] + 2.0 * $g[1][$i1] + 2.0 * $g[2][$i1] + $g[3][$i1]) / 6.0;
return $time;
}
?>
#####################################
# Hopfieldネットワーク（連想記憶）
# Coded by Y.Suganuma
#####################################
a = [[0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0],
[1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1]]
w = Array.new(36)
for i1 in 0 ... 36
w[i1] = Array.new(36)
end
n = 36
p = 3
# 重みの設定（学習）
for i1 in 0 ... n-1
for i2 in i1+1 ... n
w[i1][i2] = 0
for i3 in 0 ... p
w[i1][i2] += (2 * a[i3][i1] - 1) * (2 * a[i3][i2] - 1)
end
w[i2][i1] = w[i1][i2]
end
end
for i1 in 0 ... n
w[i1][i1] = 0
end
# 初期状態
srand();
u = Array.new(36)
print("パターン番号と修正ユニット数 ")
s = gets().split(" ")
pn = Integer(s[0]);
m = Integer(s[1])
for i1 in 0 ... n
u[i1] = a[pn][i1]
end
for i1 in 0 ... m
k = Integer(rand(0) * n)
if k >= n
k = n - 1
end
if u[k] > 0
u[k] = 0
else
u[k] = 1
end
end
print("初期状態：\n")
k = 0
for i1 in 0 ... 6
for i2 in 0 ... 6
print(" " + String(u[k]))
k += 1
end
print("\n")
end
# 更新
count1 = 0
count2 = 0
count3 = 0
while count1 < 100
count2 += 1
sw = 0
k = Integer(rand(0) * n)
if k >= n
k = n - 1
end
s = 0
for i1 in 0 ... n
s += (w[k][i1] * u[i1])
end
if s >= 0
if u[k] == 0
sw = 1
u[k] = 1
end
else
if u[k] > 0
sw = 1
u[k] = 0
end
end
if sw > 0
count1 = 0
count3 += 1
else
count1 += 1
end
end
# 結果
print("試行回数 = " + String(count2) + "，更新回数 = " + String(count3) + "\n")
k = 0
for i1 in 0 ... 6
for i2 in 0 ... 6
print(" " + String(u[k]))
k += 1
end
print("\n")
end
##################################
# Hopfieldネットワーク（ TSP ）
# Coded by Y.Suganuma
##################################
##################
# ユニットの出力
##################
def out(x)
return 0.5 * (1.0 + Math.tanh(x))
# return 1.0 / (1.0 + Math.exp(-x))
end
#***************/
# 微係数の計算 */
#***************/
snx = Proc.new { |time, u, du|
for x in 0 ... $n
for i in 0 ... $n
k = $n * x + i
du[k] = 0.0
for j in 0 ... $n
if j != i
du[k] -= $aa * out(u[$n*x+j])
end
end
for y in 0 ... $n
if y != x
du[k] -= $bb * out(u[$n*y+i])
end
end
nn = 0.0
for xx in 0 ... $n
for ii in 0 ... $n
nn += out(u[$n*xx+ii])
end
end
du[k] -= $cc * (nn - $n)
for y in 0 ... $n
m1 = (i + 1) % $n
m2 = i - 1
if m2 < 0
m2 = $n - 1
end
du[k] -= $dd * $d[x][y] * (out(u[$n*y+m1]) + out(u[$n*y+m2]))
end
end
end
}
#******************************************/
# ルンゲ・クッタ法 dx/dt=f(t,x) */
# time : 現在の時間 */
# h : 時間刻み幅 */
# x : 現在の状態 */
# dx : 微係数（f(t,x):snxで計算する）*/
# g : 作業域（g[4][n]） */
# n : 微分方程式の次数 */
# snx : 微係数を計算する関数の名前 */
# return : time+h */
#******************************************/
def rkg(time, h, x, dx, g, n, &sub)
h2 = 0.5 * h
sub.call(time, x, dx)
for i1 in 0 ... n
g[0][i1] = h * dx[i1]
end
time += h2
for i1 in 0 ... n
g[1][i1] = x[i1] + 0.5 * g[0][i1]
end
sub.call(time, g[1], dx)
for i1 in 0 ... n
g[1][i1] = h * dx[i1]
end
for i1 in 0 ... n
g[2][i1] = x[i1] + 0.5 * g[1][i1]
end
sub.call(time, g[2], dx)
for i1 in 0 ... n
g[2][i1] = h * dx[i1]
end
time += h2
for i1 in 0 ... n
g[3][i1] = x[i1] + g[2][i1]
end
sub.call(time, g[3], dx)
for i1 in 0 ... n
g[3][i1] = h * dx[i1]
end
for i1 in 0 ... n
x[i1] = x[i1] + (g[0][i1] + 2.0 * g[1][i1] + 2.0 * g[2][i1] + g[3][i1]) / 6.0
end
return time
end
$n = 4
$nn = $n * $n
$aa = 10.0
$bb = 10.0
$cc = 10.0
$dd = 2.0
$d = Array.new($n)
for i1 in 0 ... $n
$d[i1] = Array.new($n)
end
# 距離
r = Math.sqrt(2.0)
for i1 in 0 ... $n
for i2 in 0 ... $n
if i1 == i2
$d[i1][i2] = 0.0
else
$d[i1][i2] = 1.0
end
end
end
$d[0][2] = r
$d[1][3] = r
$d[2][0] = r
$d[3][1] = r
# 初期状態
srand()
u = Array.new($n)
for i1 in 0 ... $n
u[i1] = Array.new($n)
for i2 in 0 ... $n
u[i1][i2] = 0.1 * rand(0) - 0.05
end
end
print("初期状態（出力）：\n")
for i1 in 0 ... $n
for i2 in 0 ... $n
print(" " + String(out(u[i1][i2])))
end
print("\n")
end
# 更新
time = 0.0
dx = Array.new(16)
g = Array.new(4)
for i1 in 0 ... 4
g[i1] = Array.new(16)
end
k = 0
uu = Array.new(16)
for i1 in 0 ... 4
for i2 in 0 ... 4
uu[k] = u[i1][i2]
k += 1
end
end
for i1 in 0 ... 100
time = rkg(time, 1, uu, dx, g, $n*$n, &snx)
end
print("最終状態（出力）：\n")
k = 0
for i1 in 0 ... $n
for i2 in 0 ... $n
print(" " + String(out(uu[k])))
k += 1
end
print("\n")
end
# -*- coding: UTF-8 -*-
import numpy as np
import sys
from math import *
from random import *
#####################################
# Hopfieldネットワーク（連想記憶）
# Coded by Y.Suganuma
#####################################
a = np.array([[0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0],
[0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0],
[1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1]], np.int)
W = np.empty((36, 36), np.int)
n = 36
p = 3
# 重みの設定（学習）
for i1 in range(0, n-1) :
for i2 in range(i1+1, n) :
W[i1][i2] = 0
for i3 in range(0, p) :
W[i1][i2] += (2 * a[i3][i1] - 1) * (2 * a[i3][i2] - 1)
W[i2][i1] = W[i1][i2]
for i1 in range(0, n) :
W[i1][i1] = 0
# 初期状態
seed();
u = np.empty(36, np.int)
s = input("パターン番号と修正ユニット数 ").split()
pn = int(s[0]);
m = int(s[1])
for i1 in range(0, n) :
u[i1] = a[pn][i1]
for i1 in range(0, m) :
k = int(random() * n)
if k >= n :
k = n - 1
if u[k] > 0 :
u[k] = 0
else :
u[k] = 1
print("初期状態：")
k = 0
for i1 in range(0, 6) :
for i2 in range(0, 6) :
print(" " + str(u[k]), end="")
k += 1
print()
# 更新
count1 = 0
count2 = 0
count3 = 0
while count1 < 100 :
count2 += 1
sw = 0
k = int(random() * n)
if k >= n :
k = n - 1
s = 0
for i1 in range(0, n) :
s += (W[k][i1] * u[i1])
if s >= 0 :
if u[k] == 0 :
sw = 1
u[k] = 1
else :
if u[k] > 0 :
sw = 1
u[k] = 0
if sw > 0 :
count1 = 0
count3 += 1
else :
count1 += 1
# 結果
print("試行回数 = " + str(count2) + "，更新回数 = " + str(count3))
k = 0
for i1 in range(0, 6) :
for i2 in range(0, 6) :
print(" " + str(u[k]), end="")
k += 1
print("")
# -*- coding: UTF-8 -*-
import numpy as np
import sys
from math import *
from random import *
############################################
# ルンゲ・クッタ法 dx/dt=f(t,x)
# time : 現在の時間
# h : 時間刻み幅
# x : 現在の状態
# dx : 微係数（f(t,x):subで計算する）
# g : 作業域（g[4][n]）
# n : 微分方程式の次数
# sub : 微係数を計算する関数の名前
# return : time+h
# coded by Y.Suganuma
############################################
def rkg(time, h, x, dx, g, n, sub) :
h2 = 0.5 * h
sub(time, x, dx)
for i1 in range(0, n) :
g[0][i1] = h * dx[i1]
time += h2
for i1 in range(0, n) :
g[1][i1] = x[i1] + 0.5 * g[0][i1]
sub(time, g[1], dx)
for i1 in range(0, n) :
g[1][i1] = h * dx[i1]
for i1 in range(0, n) :
g[2][i1] = x[i1] + 0.5 * g[1][i1]
sub(time, g[2], dx)
for i1 in range(0, n) :
g[2][i1] = h * dx[i1]
time += h2
for i1 in range(0, n) :
g[3][i1] = x[i1] + g[2][i1]
sub(time, g[3], dx)
for i1 in range(0, n) :
g[3][i1] = h * dx[i1]
for i1 in range(0, n) :
x[i1] = x[i1] + (g[0][i1] + 2.0 * g[1][i1] + 2.0 * g[2][i1] + g[3][i1]) / 6.0
return time
##################################
# Hopfieldネットワーク（ TSP ）
# Coded by Y.Suganuma
##################################
##################
# ユニットの出力
##################
def out(x) :
return 0.5 * (1.0 + tanh(x))
# return 1.0 / (1.0 + exp(-x))
################
# 微係数の計算
################
def snx(time, u, du) :
for x in range(0, n) :
for i in range(0, n) :
k = n * x + i
du[k] = 0.0
for j in range(0, n) :
if j != i :
du[k] -= A * out(u[n*x+j])
for y in range(0, n) :
if y != x :
du[k] -= B * out(u[n*y+i])
N = 0.0
for xx in range(0, n) :
for ii in range(0, n) :
N += out(u[n*xx+ii])
du[k] -= C * (N - n)
for y in range(0, n) :
m1 = (i + 1) % n
m2 = i - 1
if m2 < 0 :
m2 = n - 1
du[k] -= D * d[x][y] * (out(u[n*y+m1]) + out(u[n*y+m2]))
n = 4
A = 10.0
B = 10.0
C = 10.0
D = 2.0
d = np.empty((4, 4), np.float)
# 距離
r = sqrt(2.0)
for i1 in range(0, n) :
for i2 in range(0, n) :
if i1 == i2 :
d[i1][i2] = 0.0
else :
d[i1][i2] = 1.0
d[0][2] = r
d[1][3] = r
d[2][0] = r
d[3][1] = r
# 初期状態
seed()
u = np.empty((4, 4), np.float)
for i1 in range(0, n) :
for i2 in range(0, n) :
u[i1][i2] = 0.1 * random() - 0.05
print("初期状態（出力）：")
for i1 in range(0, n) :
for i2 in range(0, n) :
print(" " + str(out(u[i1][i2])), end="")
print("")
# 更新
time = 0.0
dx = np.empty(16, np.float)
g = np.empty((4, 16), np.float)
uu = np.reshape(u, 16)
for i1 in range(0, 100) :
time = rkg(time, 1, uu, dx, g, n*n, snx)
print("最終状態（出力）：")
for i1 in range(0, n) :
for i2 in range(0, n) :
print(" " + str(out(u[i1][i2])), end="")
print("")
/************************************/
/* Hopfieldネットワーク（連想記憶） */
/* Coded by Y.Suganuma) */
/************************************/
using System;
class Program
{
static void Main()
{
int n = 36, p = 3;
int[][] a = new int [3][];
a[0] = new int[] {0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0};
a[1] = new int[] {0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0};
a[2] = new int[] {1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1};
int[][] W = new int [n][];
for (int i1 = 0; i1 < n; i1++)
W[i1] = new int [n];
// 重みの設定（学習）
for (int i1 = 0; i1 < n-1; i1++) {
for (int i2 = i1+1; i2 < n; i2++) {
W[i1][i2] = 0;
for (int i3 = 0; i3 < p; i3++)
W[i1][i2] += (2 * a[i3][i1] - 1) * (2 * a[i3][i2] - 1);
W[i2][i1] = W[i1][i2];
}
}
for (int i1 = 0; i1 < n; i1++)
W[i1][i1] = 0;
// 初期状態
Random rn = new Random();
Console.Write("パターン番号と修正ユニット数 ");
string[] str = Console.ReadLine().Split(' ');
int pn = int.Parse(str[0]);
int m = int.Parse(str[1]);
int[] u = new int [n];
for (int i1 = 0; i1 < n; i1++)
u[i1] = a[pn][i1];
int k;
for (int i1 = 0; i1 < m; i1++) {
k = (int)(rn.NextDouble() * n);
if (k >= n)
k = n - 1;
if (u[k] > 0)
u[k] = 0;
else
u[k] = 1;
}
Console.WriteLine("初期状態：");
k = 0;
for (int i1 = 0; i1 < 6; i1++) {
for (int i2 = 0; i2 < 6; i2++) {
Console.Write(" " + u[k]);
k++;
}
Console.WriteLine();
}
// 更新
int count1 = 0, count2 = 0, count3 = 0;
while (count1 < 100) {
count2++;
bool sw = false;
k = (int)(rn.NextDouble() * n);
if (k >= n)
k = n - 1;
int s = 0;
for (int i1 = 0; i1 < n; i1++)
s += W[k][i1] * u[i1];
if (s >= 0) {
if (u[k] == 0) {
sw = true;
u[k] = 1;
}
}
else {
if (u[k] > 0) {
sw = true;
u[k] = 0;
}
}
if (sw) {
count1 = 0;
count3++;
}
else
count1++;
}
// 結果
Console.WriteLine("試行回数 = " + count2 + "，更新回数 = " + count3);
k = 0;
for (int i1 = 0; i1 < 6; i1++) {
for (int i2 = 0; i2 < 6; i2++) {
Console.Write(" " + u[k]);
k++;
}
Console.WriteLine();
}
}
}
/*********************************/
/* Hopfieldネットワーク（ TSP ） */
/* Coded by Y.Suganuma) */
/*********************************/
using System;
class Program
{
static void Main()
{
Test1 ts = new Test1();
}
}
class Test1
{
int n = 4;
double A = 10.0, B = 10.0, C = 10.0, D = 2.0;
double[][] d;
public Test1()
{
d = new double [n][];
for (int i1 = 0; i1 < n; i1++)
d[i1] = new double [n];
// 距離
double r = Math.Sqrt(2.0);
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++) {
if (i1 == i2)
d[i1][i2] = 0.0;
else
d[i1][i2] = 1.0;
}
}
d[0][2] = r;
d[1][3] = r;
d[2][0] = r;
d[3][1] = r;
// 初期状態
double[][] u = new double [n][];
Random rn = new Random();
for (int i1 = 0; i1 < n; i1++) {
u[i1] = new double [n];
for (int i2 = 0; i2 < n; i2++)
u[i1][i2] = 0.1 * rn.NextDouble() - 0.05;
}
Console.WriteLine("初期状態（出力）：");
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++)
Console.Write(" " + out_u(u[i1][i2]));
Console.WriteLine();
}
// 更新
double time = 0.0;
double[] dx = new double[n*n];
double[] uu = new double[n*n];
double[][] g = new double [4][];
for (int i1 = 0; i1 < 4; i1++)
g[i1] = new double [n*n];
int k = 0;
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++) {
uu[k] = u[i1][i2];
k++;
}
}
for (int i1 = 0; i1 < 100; i1++)
time = rkg(time, 1, uu, dx, g, n*n, snx);
Console.WriteLine("最終状態（出力）：");
for (int i1 = 0; i1 < n; i1++) {
for (int i2 = 0; i2 < n; i2++)
Console.Write(" " + out_u(uu[i1*n+i2]));
Console.WriteLine();
}
}
/******************/
/* ユニットの出力 */
/******************/
double out_u(double x)
{
return 0.5 * (1.0 + Math.Tanh(x));
// return 1.0 / (1.0 + Math.Exp(-x));
}
/****************/
/* 微係数の計算 */
/****************/
int snx(double time, double[] u, double[] du)
{
for (int x = 0; x < n; x++) {
for (int i = 0; i < n; i++) {
int k = n * x + i;
du[k] = 0.0;
for (int j = 0; j < n; j++) {
if (j != i)
du[k] -= A * out_u(u[n*x+j]);
}
for (int y = 0; y < n; y++) {
if (y != x)
du[k] -= B * out_u(u[n*y+i]);
}
double N = 0.0;
for (int xx = 0; xx < n; xx++) {
for (int ii = 0; ii < n; ii++)
N += out_u(u[n*xx+ii]);
}
du[k] -= C * (N - n);
for (int y = 0; y < n; y++) {
int m1 = (i + 1) % n;
int m2 = i - 1;
if (m2 < 0)
m2 = n - 1;
du[k] -= D * d[x][y] * (out_u(u[n*y+m1]) + out_u(u[n*y+m2]));
}
}
}
return 0;
}
/********************************************/
/* ルンゲ・クッタ法 dx/dt=f(t,x) */
/* time : 現在の時間 */
/* h : 時間刻み幅 */
/* x : 現在の状態 */
/* dx : 微係数（f(t,x):snxで計算する） */
/* g : 作業域（g[4][n]） */
/* n : 微分方程式の次数 */
/* fn : 関数値を計算する関数 */
/* return : time+h */
/********************************************/
double rkg(double time, double h, double[] x, double[] dx, double[][] g,
int n, Func fn)
{
double h2 = 0.5 * h;
fn(time, x, dx);
for (int i1 = 0; i1 < n; i1++)
g[0][i1] = h * dx[i1];
time += h2;
for (int i1 = 0; i1 < n; i1++)
g[1][i1] = x[i1] + 0.5 * g[0][i1];
fn(time, g[1], dx);
for (int i1 = 0; i1 < n; i1++)
g[1][i1] = h * dx[i1];
for (int i1 = 0; i1 < n; i1++)
g[2][i1] = x[i1] + 0.5 * g[1][i1];
fn(time, g[2], dx);
for (int i1 = 0; i1 < n; i1++)
g[2][i1] = h * dx[i1];
time += h2;
for (int i1 = 0; i1 < n; i1++)
g[3][i1] = x[i1] + g[2][i1];
fn(time, g[3], dx);
for (int i1 = 0; i1 < n; i1++)
g[3][i1] = h * dx[i1];
for (int i1 = 0; i1 < n; i1++)
x[i1] = x[i1] + (g[0][i1] + 2.0 * g[1][i1] + 2.0 * g[2][i1] + g[3][i1]) / 6.0;
return time;
}
}
'**********************************'
' Hopfieldネットワーク（連想記憶） '
' Coded by Y.Suganuma) '
'**********************************'
Imports System.Text.RegularExpressions
Module Test
Sub Main()
Dim n As Integer = 36
Dim p As Integer = 3
Dim a(,) As Integer =
{{0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0,
0, 0, 1, 1, 0, 0},
{0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1,
0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0},
{1, 1, 0, 0, 0, 0,
1, 1, 1, 0, 0, 0,
0, 1, 1, 1, 0, 0,
0, 0, 1, 1, 1, 0,
0, 0, 0, 1, 1, 1,
0, 0, 0, 0, 1, 1}}
Dim W(n,n) As Integer
' 重みの設定（学習）
For i1 As Integer = 0 To n-2
For i2 As Integer = i1+1 To n-1
W(i1,i2) = 0
For i3 As Integer = 0 To p-1
W(i1,i2) += (2 * a(i3,i1) - 1) * (2 * a(i3,i2) - 1)
Next
W(i2,i1) = W(i1,i2)
Next
Next
For i1 As Integer = 0 To n-1
W(i1,i1) = 0
Next
' 初期状態
Dim MS As Regex = New Regex("\s+")
Dim rn As Random = new Random()
Console.Write("パターン番号と修正ユニット数 ")
Dim str() As String = MS.Split(Console.ReadLine().Trim())
Dim pn As Integer = Integer.Parse(str(0))
Dim m As Integer = Integer.Parse(str(1))
Dim u(n) As Integer
For i1 As Integer = 0 To n-1
u(i1) = a(pn,i1)
Next
Dim k As Integer
For i1 As Integer = 0 To m-1
k = Math.Floor(rn.NextDouble() * n)
If k >= n
k = n - 1
End If
If u(k) > 0
u(k) = 0
Else
u(k) = 1
End If
Next
Console.WriteLine("初期状態：")
k = 0
For i1 As Integer = 0 To 5
For i2 As Integer = 0 To 5
Console.Write(" " & u(k))
k += 1
Next
Console.WriteLine()
Next
' 更新
Dim count1 As Integer = 0
Dim count2 As Integer = 0
Dim count3 As Integer = 0
Do While count1 < 100
count2 += 1
Dim sw As Boolean = False
k = Math.Floor(rn.NextDouble() * n)
If k >= n
k = n - 1
End If
Dim s As Integer = 0
For i1 As Integer = 0 To n-1
s += W(k,i1) * u(i1)
Next
If s >= 0
If u(k) = 0
sw = True
u(k) = 1
End If
Else
If u(k) > 0
sw = True
u(k) = 0
End If
End If
If sw
count1 = 0
count3 += 1
Else
count1 += 1
End If
Loop
' 結果
Console.WriteLine("試行回数 = " & count2 & "，更新回数 = " & count3)
k = 0
For i1 As Integer = 0 To 5
For i2 As Integer = 0 To 5
Console.Write(" " & u(k))
k += 1
Next
Console.WriteLine()
Next
End Sub
End Module
'*******************************'
' Hopfieldネットワーク（ TSP ） '
' Coded by Y.Suganuma) '
'*******************************'
Module Test
Dim n As Integer = 4
Dim A As Double = 10.0
Dim B As Double = 10.0
Dim C As Double = 10.0
Dim D As Double = 2.0
Dim dd(n,n) As Double
Sub Main()
' 微係数の計算
Dim snx = Function(tm, v, dv)
For x As Integer = 0 To n-1
For i As Integer = 0 To n-1
Dim kk As Integer = n * x + i
dv(kk) = 0.0
For j As Integer = 0 To n-1
If j <> i
dv(kk) -= A * out_u(v(n*x+j))
End If
Next
For y As Integer = 0 To n-1
If y <> x
dv(kk) -= B * out_u(v(n*y+i))
End If
Next
Dim NN As Double = 0.0
For xx As Integer = 0 To n-1
For ii As Integer = 0 To n-1
NN += out_u(v(n*xx+ii))
Next
Next
dv(kk) -= C * (NN - n)
For y As Integer = 0 To n-1
Dim m1 As Integer = (i + 1) Mod n
Dim m2 As Integer = i - 1
If m2 < 0
m2 = n - 1
End If
dv(kk) -= D * dd(x,y) * (out_u(v(n*y+m1)) + out_u(v(n*y+m2)))
Next
Next
Next
Return 0
End Function
' 距離
Dim r As Double = Math.Sqrt(2.0)
For i1 As Integer = 0 To n-1
For i2 As Integer = 0 To n-1
If i1 = i2
dd(i1,i2) = 0.0
Else
dd(i1,i2) = 1.0
End If
Next
Next
dd(0,2) = r
dd(1,3) = r
dd(2,0) = r
dd(3,1) = r
' 初期状態
Dim u(n,n) As Double
Dim rn As Random = new Random()
For i1 As Integer = 0 To n-1
For i2 As Integer = 0 To n-1
u(i1,i2) = 0.1 * rn.NextDouble() - 0.05
Next
Next
Console.WriteLine("初期状態（出力）：")
For i1 As Integer = 0 To n-1
For i2 As Integer = 0 To n-1
Console.Write(" " & out_u(u(i1,i2)))
Next
Console.WriteLine()
Next
' 更新
Dim time As Double = 0.0
Dim dx(n*n) As Double
Dim uu(n*n) As Double
Dim g0(n*n) As Double
Dim g1(n*n) As Double
Dim g2(n*n) As Double
Dim g3(n*n) As Double
Dim k As Integer = 0
For i1 As Integer = 0 To n-1
For i2 As Integer = 0 To n-1
uu(k) = u(i1,i2)
k += 1
Next
Next
For i1 As Integer = 0 To 99
time = rkg(time, 1, uu, dx, g0, g1, g2, g3, n*n, snx)
Next
Console.WriteLine("最終状態（出力）：")
For i1 As Integer = 0 To n-1
For i2 As Integer = 0 To n-1
Console.Write(" " & out_u(uu(i1*n+i2)))
Next
Console.WriteLine()
Next
End Sub
'****************'
' ユニットの出力 '
'****************'
Function out_u(x As Double)
Return 0.5 * (1.0 + Math.Tanh(x))
' Return 1.0 / (1.0 + Math.Exp(-x))
End Function
''''''''''''''''''''''''''''''''''''''''''''
' ルンゲ・クッタ法 dx/dt=f(t,x) '
' time : 現在の時間 '
' h : 時間刻み幅 '
' x : 現在の状態 '
' dx : 微係数（f(t,x):snxで計算する） '
' g0,g1,g2,g3 : 作業域（gi(n)） '
' n : 微分方程式の次数 '
' fn : 関数値を計算する関数 '
' return : time+h '
''''''''''''''''''''''''''''''''''''''''''''
Function rkg(time As Double, h As Double, x() As Double, dx() As Double,
g0() As Double, g1() As Double, g2() As Double, g3() As Double,
n As Integer, fn As Func(Of Double, Double(), Double(), Integer))
Dim h2 As Double = 0.5 * h
fn(time, x, dx)
For i1 As Integer = 0 To n-1
g0(i1) = h * dx(i1)
Next
time += h2
For i1 As Integer = 0 To n-1
g1(i1) = x(i1) + 0.5 * g0(i1)
Next
fn(time, g1, dx)
For i1 As Integer = 0 To n-1
g1(i1) = h * dx(i1)
Next
For i1 As Integer = 0 To n-1
g2(i1) = x(i1) + 0.5 * g1(i1)
Next
fn(time, g2, dx)
For i1 As Integer = 0 To n-1
g2(i1) = h * dx(i1)
Next
time += h2
For i1 As Integer = 0 To n-1
g3(i1) = x(i1) + g2(i1)
Next
fn(time, g3, dx)
For i1 As Integer = 0 To n-1
g3(i1) = h * dx(i1)
Next
For i1 As Integer = 0 To n-1
x(i1) = x(i1) + (g0(i1) + 2.0 * g1(i1) + 2.0 * g2(i1) + g3(i1)) / 6.0
Next
Return time
End Function
End Module
| 情報学部 | 菅沼ホーム | 目次 | 索引 |