情報学部 菅沼ホーム 目次 索引

最適化（シンプレックス法）

    1. A. C++
    2. B. Java
    3. C. JavaScript
    4. D. PHP
    5. E. Ruby
    6. F. Python
    7. G. C#
    8. H. VB

　　プログラムは，シンプレックス法を使用して，非線形関数の最小値を求めるためのものです（ プログラムの使用方法）．

  1. C++ 

    /**************************************/
/* シンプレックス法による最小値の計算 */
/*      coded by Y.Suganuma           */
/**************************************/
#include <stdio.h>

double snx1(double *);
double snx2(double *);
double snx3(double *);
int simplex(int, int, double, double, double, double, double *, double *, double (*)(double *));

int main()
{
	double eps, r1, r2, *x, y, k;
	int fun, i1, max, n, sw = 0;
					// データの入力
	scanf("%*s %d %*s %d %*s %d %*s %lf", &fun, &n, &max, &k);
	scanf("%*s %lf %*s %lf %*s %lf", &eps, &r1, &r2);
	x = new double [n];
	scanf("%*s");
	for (i1 = 0; i1 < n; i1++)
		scanf("%lf", &x[i1]);
					// 実行
	switch (fun) {
		case 1:
			sw = simplex(max, n, k, eps, r1, r2, &y, x, snx1);
			break;
		case 2:
			sw = simplex(max, n, k, eps, r1, r2, &y, x, snx2);
			break;
		case 3:
			sw = simplex(max, n, k, eps, r1, r2, &y, x, snx3);
			break;
	}
					// 結果の出力
	if (sw < 0)
		printf("   収束しませんでした！");
	else {
		printf("   結果＝");
		for (i1 = 0; i1 < n; i1++)
			printf("%f ", x[i1]);
		printf(" 最小値＝%f  回数＝%d\n", y, sw);
	}

	delete [] x;

	return 0;
}

/******************************************/
/* シンプレックス法                       */
/*      max : 最大繰り返し回数            */
/*      n : 次元                          */
/*      k : 初期値設定係数                */
/*      r1 : 縮小比率                     */
/*      r2 : 拡大比率                     */
/*      y : 最小値                        */
/*      x : x(初期値と答え)               */
/*      snx : 関数値を計算する関数名      */
/*      return : >=0 : 正常終了(収束回数) */
/*               =-1 : 収束せず           */
/******************************************/
#include <math.h>

int simplex(int max, int n, double k, double eps, double r1, double r2, double *y, double *x, double (*snx)(double *))
{
	double **xx, *yy, *xg, *xr, *xn, yr, yn, e;
	int i1, i2, fh = -1, fg = -1, fl = -1, count = 0, sw = -1;
					// 初期値の設定
	yy = new double [n+1];
	xg = new double [n];
	xr = new double [n];
	xn = new double [n];
	xx = new double * [n+1];
	for (i1 = 0; i1 < n+1; i1++)
		xx[i1] = new double [n];
	for (i1 = 0; i1 < n+1; i1++) {
		for (i2 = 0; i2 < n; i2++)
			xx[i1][i2] = x[i2];
		if (i1 > 0)
			xx[i1][i1-1] += k;
		yy[i1] = snx(xx[i1]);
	}
					// 最大値，最小値の計算
	for (i1 = 0; i1 < n+1; i1++) {
		if (fh < 0 || yy[i1] > yy[fh])
			fh = i1;
		if (fl < 0 || yy[i1] < yy[fl])
			fl = i1;
	}
	for (i1 = 0; i1 < n+1; i1++) {
		if (i1 != fh && (fg < 0 || yy[i1] > yy[fg]))
			fg = i1;
	}
					// 最小値の計算
	while (count < max && sw < 0) {
		count++;
							// 重心の計算
		for (i1 = 0; i1 < n; i1++)
			xg[i1] = 0.0;
		for (i1 = 0; i1 < n+1; i1++) {
			if (i1 != fh) {
				for (i2 = 0; i2 < n; i2++)
					xg[i2] += xx[i1][i2];
			}
		}
		for (i1 = 0; i1 < n; i1++)
			xg[i1] /= n;
							// 最大点の置き換え
		for (i1 = 0; i1 < n; i1++)
			xr[i1] = 2.0 * xg[i1] - xx[fh][i1];
		yr = snx(xr);
		if (yr >= yy[fh]) {   // 縮小
			for (i1 = 0; i1 < n; i1++)
				xr[i1] = (1.0 - r1) * xx[fh][i1] + r1 * xr[i1];
			yr = snx(xr);
		}
		else if (yr < (yy[fl]+(r2-1.0)*yy[fh])/r2) {   // 拡大
			for (i1 = 0; i1 < n; i1++)
				xn[i1] = r2 * xr[i1] - (r2 - 1.0) * xx[fh][i1];
			yn = snx(xn);
			if (yn <= yr) {
				for (i1 = 0; i1 < n; i1++)
					xr[i1] = xn[i1];
				yr = yn;
			}
		}
		for (i1 = 0; i1 < n; i1++)
			xx[fh][i1] = xr[i1];
		yy[fh] = yr;
							// シンプレックス全体の縮小
		if (yy[fh] >= yy[fg]) {
			for (i1 = 0; i1 < n+1; i1++) {
				if (i1 != fl) {
					for (i2 = 0; i2 < n; i2++)
						xx[i1][i2] = 0.5 * (xx[i1][i2] + xx[fl][i2]);
					yy[i1] = snx(xx[i1]);
				}
			}
		}
							// 最大値，最小値の計算
		fh = -1;
		fg = -1;
		fl = -1;
		for (i1 = 0; i1 < n+1; i1++) {
			if (fh < 0 || yy[i1] > yy[fh])
				fh = i1;
			if (fl < 0 || yy[i1] < yy[fl])
				fl = i1;
		}
		for (i1 = 0; i1 < n+1; i1++) {
			if (i1 != fh && (fg < 0 || yy[i1] > yy[fg]))
				fg = i1;
		}
							// 収束判定
		e = 0.0;
		for (i1 = 0; i1 < n+1; i1++) {
			if (i1 != fl) {
				yr  = yy[i1] - yy[fl];
				e  += yr * yr;
			}
		}
		if (e < eps)
			sw = 0;
	}

	if (sw == 0) {
		sw = count;
		*y = yy[fl];
		for (i1 = 0; i1 < n; i1++)
			x[i1] = xx[fl][i1];
	}

	delete [] yy;
	delete [] xg;
	delete [] xr;
	delete [] xn;
	for (i1 = 0; i1 < n+1; i1++)
		delete [] xx[i1];
	delete [] xx;

	return sw;
}

/*******************/
/* 関数値の計算    */
/*      y = f(x)   */
/*      return : y */
/*******************/
					// 関数１
double snx1(double *x)
{
	double x1, y1, y;

	x1 = x[0] - 1.0;
	y1 = x[1] - 2.0;
	y  = x1 * x1 + y1 * y1;

	return y;
}
					// 関数２
double snx2(double *x)
{
	double x1, y1, y;

	x1 = x[1] - x[0] * x[0];
	y1 = 1.0 - x[0];
	y  = 100.0 * x1 * x1 + y1 * y1;

	return y;
}
					// 関数３
double snx3(double *x)
{
	double x1, y1, z1, y;

	x1 = 1.5 - x[0] * (1.0 - x[1]);
	y1 = 2.25 - x[0] * (1.0 - x[1] * x[1]);
	z1 = 2.625 - x[0] * (1.0 - x[1] * x[1] * x[1]);
	y  = x1 * x1 + y1 * y1 + z1 * z1;

	return y;
}

  2. Java 

    /**************************************/
/* シンプレックス法による最小値の計算 */
/*      coded by Y.Suganuma           */
/**************************************/
import java.io.*;
import java.util.StringTokenizer;

public class Test {
	public static void main(String args[]) throws IOException
	{
		double eps, r1, r2, x[], y[], k;
		int fun, i1, max, n, sw = 0;
		StringTokenizer str;
		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
					// データの入力
		str = new StringTokenizer(in.readLine(), " ");
		str.nextToken();
		fun = Integer.parseInt(str.nextToken());
		str.nextToken();
		n = Integer.parseInt(str.nextToken());
		str.nextToken();
		max = Integer.parseInt(str.nextToken());
		str.nextToken();
		k = Double.parseDouble(str.nextToken());
		x = new double [n];
		y  = new double [1];

		str = new StringTokenizer(in.readLine(), " ");
		str.nextToken();
		eps = Double.parseDouble(str.nextToken());
		str.nextToken();
		r1 = Double.parseDouble(str.nextToken());
		str.nextToken();
		r2 = Double.parseDouble(str.nextToken());

		str = new StringTokenizer(in.readLine(), " ");
		str.nextToken();
		for (i1 = 0; i1 < n; i1++) {
			x[i1] = Double.parseDouble(str.nextToken());
		}
					// 実行
		Kansu kn = new Kansu(fun);
		sw = kn.simplex(max, n, k, eps, r1, r2, y, x);
					// 結果の出力
		if (sw < 0)
			System.out.print("   収束しませんでした！");
		else {
			System.out.print("   結果＝");
			for (i1 = 0; i1 < n; i1++)
				System.out.print(x[i1] + " ");
			System.out.println(" 最小値＝" + y[0] + "  回数＝" + sw);
		}
	}
}

/**********/
/* 関数値 */
/**********/
class Kansu extends Simplex
{
	private int sw;
					// コンストラクタ
	Kansu (int s) {sw = s;}
					// 関数値の計算
	double snx(double x[])
	{
		double x1, y1, z1, y = 0.0;

		switch (sw) {
			case 1:
				x1 = x[0] - 1.0;
				y1 = x[1] - 2.0;
				y  = x1 * x1 + y1 * y1;
				break;
			case 2:
				x1 = x[1] - x[0] * x[0];
				y1 = 1.0 - x[0];
				y  = 100.0 * x1 * x1 + y1 * y1;
				break;
			case 3:
				x1 = 1.5 - x[0] * (1.0 - x[1]);
				y1 = 2.25 - x[0] * (1.0 - x[1] * x[1]);
				z1 = 2.625 - x[0] * (1.0 - x[1] * x[1] * x[1]);
				y  = x1 * x1 + y1 * y1 + z1 * z1;
				break;
		}

		return y;
	}
}

abstract class Simplex {

	/******************************************/
	/* シンプレックス法                       */
	/*      max : 最大繰り返し回数            */
	/*      n : 次元                          */
	/*      k : 初期値設定係数                */
	/*      r1 : 縮小比率                     */
	/*      r2 : 拡大比率                     */
	/*      y : 最小値                        */
	/*      x : x(初期値と答え)               */
	/*      return : >=0 : 正常終了(収束回数) */
	/*               =-1 : 収束せず           */
	/******************************************/

	abstract double snx(double x[]);

	int simplex(int max, int n, double k, double eps, double r1, double r2, double y[], double x[])
	{
		double xx[][], yy[], xg[], xr[], xn[], yr, yn, e;
		int i1, i2, fh = -1, fg = -1, fl = -1, count = 0, sw = -1;
						// 初期値の設定
		yy = new double [n+1];
		xg = new double [n];
		xr = new double [n];
		xn = new double [n];
		xx = new double [n+1][n];
		for (i1 = 0; i1 < n+1; i1++) {
			for (i2 = 0; i2 < n; i2++)
				xx[i1][i2] = x[i2];
			if (i1 > 0)
				xx[i1][i1-1] += k;
			yy[i1] = snx(xx[i1]);
		}
						// 最大値，最小値の計算
		for (i1 = 0; i1 < n+1; i1++) {
			if (fh < 0 || yy[i1] > yy[fh])
				fh = i1;
			if (fl < 0 || yy[i1] < yy[fl])
				fl = i1;
		}
		for (i1 = 0; i1 < n+1; i1++) {
			if (i1 != fh && (fg < 0 || yy[i1] > yy[fg]))
				fg = i1;
		}
						// 最小値の計算
		while (count < max && sw < 0) {
			count++;
								// 重心の計算
			for (i1 = 0; i1 < n; i1++)
				xg[i1] = 0.0;
			for (i1 = 0; i1 < n+1; i1++) {
				if (i1 != fh) {
					for (i2 = 0; i2 < n; i2++)
						xg[i2] += xx[i1][i2];
				}
			}
			for (i1 = 0; i1 < n; i1++)
				xg[i1] /= n;
								// 最大点の置き換え
			for (i1 = 0; i1 < n; i1++)
				xr[i1] = 2.0 * xg[i1] - xx[fh][i1];
			yr = snx(xr);
			if (yr >= yy[fh]) {   // 縮小
				for (i1 = 0; i1 < n; i1++)
					xr[i1] = (1.0 - r1) * xx[fh][i1] + r1 * xr[i1];
				yr = snx(xr);
			}
			else if (yr < (yy[fl]+(r2-1.0)*yy[fh])/r2) {   // 拡大
				for (i1 = 0; i1 < n; i1++)
					xn[i1] = r2 * xr[i1] - (r2 - 1.0) * xx[fh][i1];
				yn = snx(xn);
				if (yn <= yr) {
					for (i1 = 0; i1 < n; i1++)
						xr[i1] = xn[i1];
					yr = yn;
				}
			}
			for (i1 = 0; i1 < n; i1++)
				xx[fh][i1] = xr[i1];
			yy[fh] = yr;
								// シンプレックス全体の縮小
			if (yy[fh] >= yy[fg]) {
				for (i1 = 0; i1 < n+1; i1++) {
					if (i1 != fl) {
						for (i2 = 0; i2 < n; i2++)
							xx[i1][i2] = 0.5 * (xx[i1][i2] + xx[fl][i2]);
						yy[i1] = snx(xx[i1]);
					}
				}
			}
								// 最大値，最小値の計算
			fh = -1;
			fg = -1;
			fl = -1;
			for (i1 = 0; i1 < n+1; i1++) {
				if (fh < 0 || yy[i1] > yy[fh])
					fh = i1;
				if (fl < 0 || yy[i1] < yy[fl])
					fl = i1;
			}
			for (i1 = 0; i1 < n+1; i1++) {
				if (i1 != fh && (fg < 0 || yy[i1] > yy[fg]))
					fg = i1;
			}
								// 収束判定
			e = 0.0;
			for (i1 = 0; i1 < n+1; i1++) {
				if (i1 != fl) {
					yr  = yy[i1] - yy[fl];
					e  += yr * yr;
				}
			}
			if (e < eps)
				sw = 0;
		}
	
		if (sw == 0) {
			sw   = count;
			y[0] = yy[fl];
			for (i1 = 0; i1 < n; i1++)
				x[i1] = xx[fl][i1];
		}
	
		return sw;
	}
}

  3. JavaScript

    　　ここをクリックすると，JavaScript の仕様に適合した形で最小値を求めたい式を入力することによって，任意の関数の最小値を画面上で求めることができます． 
    <!DOCTYPE HTML>

<HTML>

<HEAD>

	<TITLE>最適化（シンプレックス法）</TITLE>
	<META HTTP-EQUIV="Content-Type" CONTENT="text/html; charset=utf-8">
	<SCRIPT TYPE="text/javascript">
		str = "";
		function main()
		{
					// データの設定
			let n   = parseInt(document.getElementById("n").value);
			let max = parseInt(document.getElementById("max").value);
			let k   = parseFloat(document.getElementById("k").value);
			let r1  = parseFloat(document.getElementById("r1").value);
			let r2  = parseFloat(document.getElementById("r2").value);
			let x   = document.getElementById("x0").value.split(/ {1,}/)
			for (let i1 = 0; i1 < n; i1++)
				x[i1] = parseFloat(x[i1]);
			str = document.getElementById("func").value + ";";
			let eps = 1.0e-20;
			let y   = new Array();
					// 実行
			let sw = simplex(max, n, k, eps, r1, r2, y, x, snx);
					// 結果
			let res;
			if (sw < 0) {
				res = " 収束しませんでした！";
				switch (sw) {
					case -1:
						res += "（収束回数）";
						break;
					case -2:
						res += "（１次元最適化の区間）";
						break;
					case -3:
						res += "（黄金分割法）";
						break;
				}
				document.getElementById("res").value = res;
			}
			else {
				let c = 100000;
				res = " x ＝";
				for (let i1 = 0; i1 < n; i1++) {
					let s1 = Math.round(x[i1] * c) / c;
					res = res + " " + s1;
				}
				res += "\n";
				let s2 = Math.round(y[0] * c) / c;
				res = res + " 最小値 ＝ " + s2 + "  回数 ＝ " + sw;
				document.getElementById("res").value = res;
			}
		}

		/****************/
		/* 関数値の計算 */
		/****************/
		function snx(x)
		{
			let y = eval(str);
			return y;
		}

		/******************************************/
		/* シンプレックス法                       */
		/*      max : 最大繰り返し回数            */
		/*      n : 次元                          */
		/*      k : 初期値設定係数                */
		/*      r1 : 縮小比率                     */
		/*      r2 : 拡大比率                     */
		/*      y : 最小値                        */
		/*      x : x(初期値と答え)               */
		/*      fn : 関数値を計算する関数         */
		/*      return : >=0 : 正常終了(収束回数) */
		/*               =-1 : 収束せず           */
		/******************************************/
		function simplex(max, n, k, eps, r1, r2, y, x, fn)
		{
			let yr, yn, e, fh = -1, fg = -1, fl = -1, count = 0, sw = -1;
						// 初期値の設定
			yy = new Array();
			xg = new Array();
			xr = new Array();
			xn = new Array();
			xx = new Array();
			for (let i1 = 0; i1 < n+1; i1++) {
				xx[i1] = new Array();
				for (let i2 = 0; i2 < n; i2++)
					xx[i1][i2] = x[i2];
				if (i1 > 0)
					xx[i1][i1-1] += k;
				yy[i1] = fn(xx[i1]);
			}
						// 最大値，最小値の計算
			for (let i1 = 0; i1 < n+1; i1++) {
				if (fh < 0 || yy[i1] > yy[fh])
					fh = i1;
				if (fl < 0 || yy[i1] < yy[fl])
					fl = i1;
			}
			for (let i1 = 0; i1 < n+1; i1++) {
				if (i1 != fh && (fg < 0 || yy[i1] > yy[fg]))
					fg = i1;
			}
						// 最小値の計算
			while (count < max && sw < 0) {
				count++;
								// 重心の計算
				for (let i1 = 0; i1 < n; i1++)
					xg[i1] = 0.0;
				for (let i1 = 0; i1 < n+1; i1++) {
					if (i1 != fh) {
						for (let i2 = 0; i2 < n; i2++)
							xg[i2] += xx[i1][i2];
					}
				}
				for (let i1 = 0; i1 < n; i1++)
					xg[i1] /= n;
								// 最大点の置き換え
				for (let i1 = 0; i1 < n; i1++)
					xr[i1] = 2.0 * xg[i1] - xx[fh][i1];
				yr = fn(xr);
				if (yr >= yy[fh]) {   // 縮小
					for (i1 = 0; i1 < n; i1++)
						xr[i1] = (1.0 - r1) * xx[fh][i1] + r1 * xr[i1];
					yr = fn(xr);
				}
				else if (yr < (yy[fl]+(r2-1.0)*yy[fh])/r2) {   // 拡大
					for (let i1 = 0; i1 < n; i1++)
						xn[i1] = r2 * xr[i1] - (r2 - 1.0) * xx[fh][i1];
					yn = fn(xn);
					if (yn <= yr) {
						for (i1 = 0; i1 < n; i1++)
							xr[i1] = xn[i1];
						yr = yn;
					}
				}
				for (let i1 = 0; i1 < n; i1++)
					xx[fh][i1] = xr[i1];
				yy[fh] = yr;
								// シンプレックス全体の縮小
				if (yy[fh] >= yy[fg]) {
					for (let i1 = 0; i1 < n+1; i1++) {
						if (i1 != fl) {
							for (let i2 = 0; i2 < n; i2++)
								xx[i1][i2] = 0.5 * (xx[i1][i2] + xx[fl][i2]);
							yy[i1] = fn(xx[i1]);
						}
					}
				}
								// 最大値，最小値の計算
				fh = -1;
				fg = -1;
				fl = -1;
				for (let i1 = 0; i1 < n+1; i1++) {
					if (fh < 0 || yy[i1] > yy[fh])
						fh = i1;
					if (fl < 0 || yy[i1] < yy[fl])
						fl = i1;
				}
				for (let i1 = 0; i1 < n+1; i1++) {
					if (i1 != fh && (fg < 0 || yy[i1] > yy[fg]))
						fg = i1;
				}
								// 収束判定
				e = 0.0;
				for (let i1 = 0; i1 < n+1; i1++) {
					if (i1 != fl) {
						yr  = yy[i1] - yy[fl];
						e  += yr * yr;
					}
				}
				if (e < eps)
					sw = 0;
			}
	
			if (sw == 0) {
				sw   = count;
				y[0] = yy[fl];
				for (let i1 = 0; i1 < n; i1++)
					x[i1] = xx[fl][i1];
			}
	
			return sw;
		}
	</SCRIPT>

</HEAD>

<BODY STYLE="font-size: 130%; background-color: #eeffee;">

	<H2 STYLE="text-align:center"><B>最適化（シンプレックス法）</B></H2>

	<DL>
		<DT>　　テキストフィールドには，例として，以下に示すような関数の最小値を求める場合に対する値が設定されています（他の問題を実行する場合は，それらを適切に修正してください）．
		<P STYLE="text-align:center"><IMG SRC="simplex.gif"></P>
		<DT>目的関数の箇所には，その計算式が与えられています．ただし，プログラム内では，変数 x は，この例の x と y からなる配列として表現されています．なお，目的関数は，JavaScript の仕様に適合した形式で記述してあることに注意してください． 
	</DL>

	<DIV STYLE="text-align:center">
		変数の数(n)：<INPUT ID="n" STYLE="font-size: 100%" TYPE="text" SIZE="2" VALUE="2">　
		最大繰り返し回数：<INPUT ID="max" STYLE="font-size: 100%" TYPE="text" SIZE="3" VALUE="1000">　
		初期値設定係数：<INPUT ID="k" STYLE="font-size: 100%" TYPE="text" SIZE="3" VALUE="1.0"><BR>
		縮小比率：<INPUT ID="r1" STYLE="font-size: 100%" TYPE="text" SIZE="3" VALUE="0.7">　
		拡大比率：<INPUT ID="r2" STYLE="font-size: 100%" TYPE="text" SIZE="3" VALUE="1.5">　
		初期値(n個)：<INPUT ID="x0" STYLE="font-size: 100%" TYPE="text" SIZE="20" VALUE="0.0 0.0"><BR><BR>
		目的関数：　f(x) = <INPUT ID="func" STYLE="font-size: 100%" TYPE="text" SIZE="70" VALUE="100.0 * (x[1] - x[0] * x[0]) * (x[1] - x[0] * x[0]) + (1.0 - x[0]) * (1.0 - x[0])"><BR><BR>
		<BUTTON STYLE="font-size: 100%; background-color: pink" onClick="main()">実行</BUTTON><BR><BR>
		結果：<TEXTAREA ID="res" STYLE="font-size: 110%" COLS="40" ROWS="2"></TEXTAREA>
	</DIV>

</BODY>

</HTML>

  4. PHP 

    <?php

/**************************************/
/* シンプレックス法による最小値の計算 */
/*      coded by Y.Suganuma           */
/**************************************/

	$sw = 0;
					// データの入力
	fscanf(STDIN, "%*s %d %*s %d %*s %d %*s %lf", $fun, $n, $max, $k);
	fscanf(STDIN, "%*s %lf %*s %lf %*s %lf", $eps, $r1, $r2);

	$x   = array($n);
	$str = trim(fgets(STDIN));
	strtok($str, " ");
	for ($i1 = 0; $i1 < $n; $i1++)
		$x[$i1] = floatval(strtok(" "));
					// 実行
	switch ($fun) {
		case 1:
			$sw = simplex($max, $n, $k, $eps, $r1, $r2, $y, $x, "snx1");
			break;
		case 2:
			$sw = simplex($max, $n, $k, $eps, $r1, $r2, $y, $x, "snx2");
			break;
		case 3:
			$sw = simplex($max, $n, $k, $eps, $r1, $r2, $y, $x, "snx3");
			break;
	}
					// 結果の出力
	if ($sw < 0)
		printf("   収束しませんでした！");
	else {
		printf("   結果＝");
		for ($i1 = 0; $i1 < $n; $i1++)
			printf("%f ", $x[$i1]);
		printf(" 最小値＝%f  回数＝%d\n", $y, $sw);
	}

/******************************************/
/* シンプレックス法                       */
/*      max : 最大繰り返し回数            */
/*      n : 次元                          */
/*      k : 初期値設定係数                */
/*      r1 : 縮小比率                     */
/*      r2 : 拡大比率                     */
/*      y : 最小値                        */
/*      x : x(初期値と答え)               */
/*      snx : 関数値を計算する関数名      */
/*      return : >=0 : 正常終了(収束回数) */
/*               =-1 : 収束せず           */
/******************************************/

function simplex($max, $n, $k, $eps, $r1, $r2, &$y, &$x, $snx)
{
					// 初期値の設定
	$fh    = -1;
	$fg    = -1;
	$fl    = -1;
	$count = 0;
	$sw    = -1;
	$yy    = array($n+1);
	$xg    = array($n);
	$xr    = array($n);
	$xn    = array($n);
	$xx    = array($n+1);
	for ($i1 = 0; $i1 < $n+1; $i1++)
		$xx[$i1] = array($n);
	for ($i1 = 0; $i1 < $n+1; $i1++) {
		for ($i2 = 0; $i2 < $n; $i2++)
			$xx[$i1][$i2] = $x[$i2];
		if ($i1 > 0)
			$xx[$i1][$i1-1] += $k;
		$yy[$i1] = $snx($xx[$i1]);
	}
					// 最大値，最小値の計算
	for ($i1 = 0; $i1 < $n+1; $i1++) {
		if ($fh < 0 || $yy[$i1] > $yy[$fh])
			$fh = $i1;
		if ($fl < 0 || $yy[$i1] < $yy[$fl])
			$fl = $i1;
	}
	for ($i1 = 0; $i1 < $n+1; $i1++) {
		if ($i1 != $fh && ($fg < 0 || $yy[$i1] > $yy[$fg]))
			$fg = $i1;
	}
					// 最小値の計算
	while ($count < $max && $sw < 0) {
		$count++;
							// 重心の計算
		for ($i1 = 0; $i1 < $n; $i1++)
			$xg[$i1] = 0.0;
		for ($i1 = 0; $i1 < $n+1; $i1++) {
			if ($i1 != $fh) {
				for ($i2 = 0; $i2 < $n; $i2++)
					$xg[$i2] += $xx[$i1][$i2];
			}
		}
		for ($i1 = 0; $i1 < $n; $i1++)
			$xg[$i1] /= $n;
							// 最大点の置き換え
		for ($i1 = 0; $i1 < $n; $i1++)
			$xr[$i1] = 2.0 * $xg[$i1] - $xx[$fh][$i1];
		$yr = $snx($xr);
		if ($yr >= $yy[$fh]) {   // 縮小
			for ($i1 = 0; $i1 < $n; $i1++)
				$xr[$i1] = (1.0 - $r1) * $xx[$fh][$i1] + $r1 * $xr[$i1];
			$yr = $snx($xr);
		}
		else if ($yr < ($yy[$fl]+($r2-1.0)*$yy[$fh])/$r2) {   // 拡大
			for ($i1 = 0; $i1 < $n; $i1++)
				$xn[$i1] = $r2 * $xr[$i1] - ($r2 - 1.0) * $xx[$fh][$i1];
			$yn = $snx($xn);
			if ($yn <= $yr) {
				for ($i1 = 0; $i1 < $n; $i1++)
					$xr[$i1] = $xn[$i1];
				$yr = $yn;
			}
		}
		for ($i1 = 0; $i1 < $n; $i1++)
			$xx[$fh][$i1] = $xr[$i1];
		$yy[$fh] = $yr;
							// シンプレックス全体の縮小
		if ($yy[$fh] >= $yy[$fg]) {
			for ($i1 = 0; $i1 < $n+1; $i1++) {
				if ($i1 != $fl) {
					for ($i2 = 0; $i2 < $n; $i2++)
						$xx[$i1][$i2] = 0.5 * ($xx[$i1][$i2] + $xx[$fl][$i2]);
					$yy[$i1] = $snx($xx[$i1]);
				}
			}
		}
							// 最大値，最小値の計算
		$fh = -1;
		$fg = -1;
		$fl = -1;
		for ($i1 = 0; $i1 < $n+1; $i1++) {
			if ($fh < 0 || $yy[$i1] > $yy[$fh])
				$fh = $i1;
			if ($fl < 0 || $yy[$i1] < $yy[$fl])
				$fl = $i1;
		}
		for ($i1 = 0; $i1 < $n+1; $i1++) {
			if ($i1 != $fh && ($fg < 0 || $yy[$i1] > $yy[$fg]))
				$fg = $i1;
		}
							// 収束判定
		$e = 0.0;
		for ($i1 = 0; $i1 < $n+1; $i1++) {
			if ($i1 != $fl) {
				$yr  = $yy[$i1] - $yy[$fl];
				$e  += $yr * $yr;
			}
		}
		if ($e < $eps)
			$sw = 0;
	}

	if ($sw == 0) {
		$sw = $count;
		$y  = $yy[$fl];
		for ($i1 = 0; $i1 < $n; $i1++)
			$x[$i1] = $xx[$fl][$i1];
	}

	return $sw;
}

/*******************/
/* 関数値の計算    */
/*      y = f(x)   */
/*      return : y */
/*******************/
					// 関数１
function snx1($x)
{
	$x1 = $x[0] - 1.0;
	$y1 = $x[1] - 2.0;
	$y  = $x1 * $x1 + $y1 * $y1;

	return $y;
}
					// 関数２
function snx2($x)
{
	$x1 = $x[1] - $x[0] * $x[0];
	$y1 = 1.0 - $x[0];
	$y  = 100.0 * $x1 * $x1 + $y1 * $y1;

	return $y;
}
					// 関数３
function snx3($x)
{
	$x1 = 1.5 - $x[0] * (1.0 - $x[1]);
	$y1 = 2.25 - $x[0] * (1.0 - $x[1] * $x[1]);
	$z1 = 2.625 - $x[0] * (1.0 - $x[1] * $x[1] * $x[1]);
	$y  = $x1 * $x1 + $y1 * $y1 + $z1 * $z1;

	return $y;
}

?>

  5. Ruby 

    #*************************************/
# シンプレックス法による最小値の計算 */
#      coded by Y.Suganuma           */
#*************************************/

#******************/
# 関数値の計算    */
#      y = f(x)   */
#      return : y */
#******************/
			# 関数１
snx1 = Proc.new { |x|
	x1 = x[0] - 1.0
	y1 = x[1] - 2.0
	x1 * x1 + y1 * y1
}
			# 関数２
snx2 = Proc.new { |x|
	x1 = x[1] - x[0] * x[0]
	y1 = 1.0 - x[0]
	100.0 * x1 * x1 + y1 * y1
}
			# 関数３
snx3 = Proc.new { |x|
	x1 = 1.5 - x[0] * (1.0 - x[1])
	y1 = 2.25 - x[0] * (1.0 - x[1] * x[1])
	z1 = 2.625 - x[0] * (1.0 - x[1] * x[1] * x[1])
	x1 * x1 + y1 * y1 + z1 * z1
}

#*****************************************/
# シンプレックス法                       */
#      max : 最大繰り返し回数            */
#      n : 次元                          */
#      k : 初期値設定係数                */
#      r1 : 縮小比率                     */
#      r2 : 拡大比率                     */
#      y : 最小値                        */
#      x : x(初期値と答え)               */
#      snx : 関数値を計算する関数名      */
#      return : >=0 : 正常終了(収束回数) */
#               =-1 : 収束せず           */
#*****************************************/
def simplex(max, n, k, eps, r1, r2, y, x, &snx)
					# 初期値の設定
	fh    = -1
	fg    = -1
	fl    = -1
	count = 0
	sw    = -1
	yy    = Array.new(n+1)
	xg    = Array.new(n)
	xr    = Array.new(n)
	xn    = Array.new(n)
	xx    = Array.new(n+1)
	for i1 in 0 ... n+1
		xx[i1] = Array.new(n)
	end
	for i1 in 0 ... n+1
		for i2 in 0 ... n
			xx[i1][i2] = x[i2]
		end
		if i1 > 0
			xx[i1][i1-1] += k
		end
		yy[i1] = snx.call(xx[i1])
	end
					# 最大値，最小値の計算
	for i1 in 0 ... n+1
		if fh < 0 || yy[i1] > yy[fh]
			fh = i1
		end
		if fl < 0 || yy[i1] < yy[fl]
			fl = i1
		end
	end
	for i1 in 0 ... n+1
		if i1 != fh && (fg < 0 || yy[i1] > yy[fg])
			fg = i1
		end
	end
					# 最小値の計算
	while count < max && sw < 0
		count += 1
							# 重心の計算
		for i1 in 0 ... n
			xg[i1] = 0.0
		end
		for i1 in 0 ... n+1
			if i1 != fh
				for i2 in 0 ... n
					xg[i2] += xx[i1][i2]
				end
			end
		end
		for i1 in 0 ... n
			xg[i1] /= n
		end
							# 最大点の置き換え
		for i1 in 0 ... n
			xr[i1] = 2.0 * xg[i1] - xx[fh][i1]
		end
		yr = snx.call(xr)
		if yr >= yy[fh]   # 縮小
			for i1 in 0 ... n
				xr[i1] = (1.0 - r1) * xx[fh][i1] + r1 * xr[i1]
			end
			yr = snx.call(xr)
		elsif yr < (yy[fl]+(r2-1.0)*yy[fh])/r2   # 拡大
			for i1 in 0 ... n
				xn[i1] = r2 * xr[i1] - (r2 - 1.0) * xx[fh][i1]
			end
			yn = snx.call(xn)
			if yn <= yr
				for i1 in 0 ... n
					xr[i1] = xn[i1]
				end
				yr = yn
			end
		end
		for i1 in 0 ... n
			xx[fh][i1] = xr[i1]
		end
		yy[fh] = yr
							# シンプレックス全体の縮小
		if yy[fh] >= yy[fg]
			for i1 in 0 ... n+1
				if i1 != fl
					for i2 in 0 ... n
						xx[i1][i2] = 0.5 * (xx[i1][i2] + xx[fl][i2])
					end
					yy[i1] = snx.call(xx[i1])
				end
			end
		end
							# 最大値，最小値の計算
		fh = -1
		fg = -1
		fl = -1
		for i1 in 0 ... n+1
			if fh < 0 || yy[i1] > yy[fh]
				fh = i1
			end
			if fl < 0 || yy[i1] < yy[fl]
				fl = i1
			end
		end
		for i1 in 0 ... n+1
			if i1 != fh && (fg < 0 || yy[i1] > yy[fg])
				fg = i1
			end
		end
							# 収束判定
		e = 0.0
		for i1 in 0 ... n+1
			if i1 != fl
				yr  = yy[i1] - yy[fl]
				e  += yr * yr
			end
		end
		if e < eps
			sw = 0
		end
	end

	if sw == 0
		sw   = count
		y[0] = yy[fl]
		for i1 in 0 ... n
			x[i1] = xx[fl][i1]
		end
	end

	return sw
end
				# データの入力
sw  = 0
str = gets()
a   = str.split(" ")
fun = Integer(a[1])
n   = Integer(a[3])
max = Integer(a[5])
k   = Float(a[7])
str = gets();
a   = str.split(" ");
eps = Float(a[1])
r1  = Float(a[3])
r2  = Float(a[5])
x   = Array.new(n)
y   = Array.new(1)
sw  = 0
str = gets();
a   = str.split(" ");
for i1 in 0 ... n
	x[i1]  = Float(a[i1+1])
end
				# 実行
case fun
	when 1
		sw = simplex(max, n, k, eps, r1, r2, y, x, &snx1)
	when 2
		sw = simplex(max, n, k, eps, r1, r2, y, x, &snx2)
	when 3
		sw = simplex(max, n, k, eps, r1, r2, y, x, &snx3)
end
				# 結果の出力
if sw < 0
	printf("   収束しませんでした！")
else
	printf("   結果＝")
	for i1 in 0 ... n
		printf("%f ", x[i1])
	end
	printf(" 最小値＝%f  回数＝%d\n", y[0], sw)
end

  6. Python 

    # -*- coding: UTF-8 -*-
import numpy as np
import sys
from math import *

############################################
# シンプレックス法
#      max : 最大繰り返し回数
#      n : 次元
#      k : 初期値設定係数
#      r1 : 縮小比率
#      r2 : 拡大比率
#      y : 最小値
#      x : x(初期値と答え)
#      snx : 関数値を計算する関数名
#      return : >=0 : 正常終了(収束回数)
#               =-1 : 収束せず
#      coded by Y.Suganuma
############################################

def simplex(max, n, k, eps, r1, r2, y, x, snx) :

			# 初期値の設定
	fh    = -1
	fg    = -1
	fl    = -1
	count = 0
	sw    = -1
	yy    = np.empty(n+1, np.float)
	xg    = np.empty(n, np.float)
	xr    = np.empty(n, np.float)
	xn    = np.empty(n, np.float)
	xx    = np.empty((n+1, n), np.float)
	for i1 in range(0, n+1) :
		for i2 in range(0, n) :
			xx[i1][i2] = x[i2]
		if i1 > 0 :
			xx[i1][i1-1] += k
		yy[i1] = snx(xx[i1])
			# 最大値，最小値の計算
	for i1 in range(0, n+1) :
		if fh < 0 or yy[i1] > yy[fh] :
			fh = i1
		if fl < 0 or yy[i1] < yy[fl] :
			fl = i1
	for i1 in range(0, n+1) :
		if i1 != fh and (fg < 0 or yy[i1] > yy[fg]) :
			fg = i1
			# 最小値の計算
	while count < max and sw < 0 :
		count += 1
				# 重心の計算
		for i1 in range(0, n) :
			xg[i1] = 0.0
		for i1 in range(0, n+1) :
			if i1 != fh :
				for i2 in range(0, n) :
					xg[i2] += xx[i1][i2]
		for i1 in range(0, n) :
			xg[i1] /= n
				# 最大点の置き換え
		for i1 in range(0, n) :
			xr[i1] = 2.0 * xg[i1] - xx[fh][i1]
		yr = snx(xr)
		if yr >= yy[fh] :   # 縮小
			for i1 in range(0, n) :
				xr[i1] = (1.0 - r1) * xx[fh][i1] + r1 * xr[i1]
			yr = snx(xr)
		elif yr < (yy[fl]+(r2-1.0)*yy[fh])/r2 :   # 拡大
			for i1 in range(0, n) :
				xn[i1] = r2 * xr[i1] - (r2 - 1.0) * xx[fh][i1]
			yn = snx(xn)
			if yn <= yr :
				for i1 in range(0, n) :
					xr[i1] = xn[i1]
				yr = yn
		for i1 in range(0, n) :
			xx[fh][i1] = xr[i1]
		yy[fh] = yr
				# シンプレックス全体の縮小
		if yy[fh] >= yy[fg] :
			for i1 in range(0, n+1) :
				if i1 != fl :
					for i2 in range(0, n) :
						xx[i1][i2] = 0.5 * (xx[i1][i2] + xx[fl][i2])
					yy[i1] = snx(xx[i1])
				# 最大値，最小値の計算
		fh = -1
		fg = -1
		fl = -1
		for i1 in range(0, n+1) :
			if fh < 0 or yy[i1] > yy[fh] :
				fh = i1
			if fl < 0 or yy[i1] < yy[fl] :
				fl = i1
		for i1 in range(0, n+1) :
			if i1 != fh and (fg < 0 or yy[i1] > yy[fg]) :
				fg = i1
				# 収束判定
		e = 0.0
		for i1 in range(0, n+1) :
			if i1 != fl :
				yr  = yy[i1] - yy[fl]
				e  += yr * yr
		if e < eps :
			sw = 0

	if sw == 0 :
		sw   = count
		y[0] = yy[fl]
		for i1 in range(0, n) :
			x[i1] = xx[fl][i1]

	return sw

############################################
# シンプレックス法による最小値の計算
#      coded by Y.Suganuma
############################################

###############
# 関数値の計算
###############

			# 関数１
def snx1(x) :
	x1 = x[0] - 1.0
	y1 = x[1] - 2.0
	y  = x1 * x1 + y1 * y1
	return y

			# 関数２
def snx2(x) :
	x1 = x[1] - x[0] * x[0]
	y1 = 1.0 - x[0]
	y  = 100.0 * x1 * x1 + y1 * y1
	return y

			# 関数３
def snx3(x) :
	x1 = 1.5 - x[0] * (1.0 - x[1])
	y1 = 2.25 - x[0] * (1.0 - x[1] * x[1])
	z1 = 2.625 - x[0] * (1.0 - x[1] * x[1] * x[1])
	y  = x1 * x1 + y1 * y1 + z1 * z1
	return y

			# データの入力
sw   = 0
line = sys.stdin.readline()
s    = line.split()
fun  = int(s[1])
n    = int(s[3])
max  = int(s[5])
k    = float(s[7])

line = sys.stdin.readline()
s    = line.split()
eps  = float(s[1])
r1   = float(s[3])
r2   = float(s[5])

x    = np.empty(n, np.float)
y    = np.empty(1, np.float)

line = sys.stdin.readline()
s    = line.split()
for i1 in range(0, n) :
	x[i1] = float(s[i1+1])
			# 実行
if fun == 1 :
	sw = simplex(max, n, k, eps, r1, r2, y, x, snx1)
elif fun == 2 :
	sw = simplex(max, n, k, eps, r1, r2, y, x, snx2)
else :
	sw = simplex(max, n, k, eps, r1, r2, y, x, snx3)
			# 結果の出力
if sw < 0 :
	print("   収束しませんでした！")
else :
	print("   結果＝", end="")
	for i1 in range(0, n) :
		print(str(x[i1]) + " ", end="")
	print(" 最小値＝" + str(y[0]) + "  回数＝" + str(sw))

  7. C# 

    /**************************************/
/* シンプレックス法による最小値の計算 */
/*      coded by Y.Suganuma           */
/**************************************/
using System;

class Program
{
	static void Main()
	{
		Test1 ts = new Test1();
	}
}

class Test1
{
	public Test1()
	{
					// データの入力
							// 1 行目
		string[] str = Console.ReadLine().Split(new char[] {' '}, StringSplitOptions.RemoveEmptyEntries);
		int fun      = int.Parse(str[1]);
		int n        = int.Parse(str[3]);
		int max      = int.Parse(str[5]);
		double k     = double.Parse(str[7]);
							// 2 行目
		str        = Console.ReadLine().Split(new char[] {' '}, StringSplitOptions.RemoveEmptyEntries);
		double eps = double.Parse(str[1]);
		double r1  = double.Parse(str[3]);
		double r2  = double.Parse(str[5]);
							// 3 行目
		double[] x = new double [n];
		double y   = 0.0;
		str        = Console.ReadLine().Split(new char[] {' '}, StringSplitOptions.RemoveEmptyEntries);
		for (int i1 = 0; i1 < n; i1++)
			x[i1] = double.Parse(str[i1+1]);
					// 実行
		int sw;
		if (fun == 1)
			sw = simplex(max, n, k, eps, r1, r2, ref y, x, snx1);
		else if (fun == 2)
			sw = simplex(max, n, k, eps, r1, r2, ref y, x, snx2);
		else
			sw = simplex(max, n, k, eps, r1, r2, ref y, x, snx3);
					// 結果の出力
		if (sw < 0)
			Console.WriteLine("   収束しませんでした！");
		else {
			Console.Write("   結果＝");
			for (int i1 = 0; i1 < n; i1++)
				Console.Write(x[i1] + " ");
			Console.WriteLine(" 最小値＝" + y + "  回数＝" + sw);
		}
	}
			// 関数１の値の計算
	double snx1(double[] x)
	{
		double x1  = x[0] - 1.0;
		double y1  = x[1] - 2.0;
		double y   = x1 * x1 + y1 * y1;
		return y;
	}
			// 関数２の値の計算
	double snx2(double[] x)
	{
		double x1  = x[1] - x[0] * x[0];
		double y1  = 1.0 - x[0];
		double y   = 100.0 * x1 * x1 + y1 * y1;
		return y;
	}
			// 関数３の値の計算
	double snx3(double[] x)
	{
		double x1  = 1.5 - x[0] * (1.0 - x[1]);
		double y1  = 2.25 - x[0] * (1.0 - x[1] * x[1]);
		double z1  = 2.625 - x[0] * (1.0 - x[1] * x[1] * x[1]);
		double y   = x1 * x1 + y1 * y1 + z1 * z1;
		return y;
	}

	/******************************************/
	/* シンプレックス法                       */
	/*      max : 最大繰り返し回数            */
	/*      n : 次元                          */
	/*      k : 初期値設定係数                */
	/*      r1 : 縮小比率                     */
	/*      r2 : 拡大比率                     */
	/*      y : 最小値                        */
	/*      x : x(初期値と答え)               */
	/*      fn : 関数値を計算する関数         */
	/*      return : >=0 : 正常終了(収束回数) */
	/*               =-1 : 収束せず           */
	/******************************************/
	int simplex(int max, int n, double k, double eps, double r1, double r2,
	            ref double y, double[] x, Func<double[], double> fn)
	{
						// 初期値の設定
		double[] yy = new double [n+1];
		double[] xg = new double [n];
		double[] xr = new double [n];
		double[] xn = new double [n];
		double[][] xx = new double [n+1][];
		for (int i1 = 0; i1 < n+1; i1++) {
			xx[i1] = new double [n];
			for (int i2 = 0; i2 < n; i2++)
				xx[i1][i2] = x[i2];
			if (i1 > 0)
				xx[i1][i1-1] += k;
			yy[i1] = fn(xx[i1]);
		}
						// 最大値，最小値の計算
		int fh = -1, fg = -1, fl = -1;
		for (int i1 = 0; i1 < n+1; i1++) {
			if (fh < 0 || yy[i1] > yy[fh])
				fh = i1;
			if (fl < 0 || yy[i1] < yy[fl])
				fl = i1;
		}
		for (int i1 = 0; i1 < n+1; i1++) {
			if (i1 != fh && (fg < 0 || yy[i1] > yy[fg]))
				fg = i1;
		}
						// 最小値の計算
		int count = 0, sw = -1;
		while (count < max && sw < 0) {
			count++;
								// 重心の計算
			for (int i1 = 0; i1 < n; i1++)
				xg[i1] = 0.0;
			for (int i1 = 0; i1 < n+1; i1++) {
				if (i1 != fh) {
					for (int i2 = 0; i2 < n; i2++)
						xg[i2] += xx[i1][i2];
				}
			}
			for (int i1 = 0; i1 < n; i1++)
				xg[i1] /= n;
								// 最大点の置き換え
			for (int i1 = 0; i1 < n; i1++)
				xr[i1] = 2.0 * xg[i1] - xx[fh][i1];
			double yr = fn(xr);
			if (yr >= yy[fh]) {   // 縮小
				for (int i1 = 0; i1 < n; i1++)
					xr[i1] = (1.0 - r1) * xx[fh][i1] + r1 * xr[i1];
				yr = fn(xr);
			}
			else if (yr < (yy[fl]+(r2-1.0)*yy[fh])/r2) {   // 拡大
				for (int i1 = 0; i1 < n; i1++)
					xn[i1] = r2 * xr[i1] - (r2 - 1.0) * xx[fh][i1];
				double yn = fn(xn);
				if (yn <= yr) {
					for (int i1 = 0; i1 < n; i1++)
						xr[i1] = xn[i1];
					yr = yn;
				}
			}
			for (int i1 = 0; i1 < n; i1++)
				xx[fh][i1] = xr[i1];
			yy[fh] = yr;
								// シンプレックス全体の縮小
			if (yy[fh] >= yy[fg]) {
				for (int i1 = 0; i1 < n+1; i1++) {
					if (i1 != fl) {
						for (int i2 = 0; i2 < n; i2++)
							xx[i1][i2] = 0.5 * (xx[i1][i2] + xx[fl][i2]);
						yy[i1] = fn(xx[i1]);
					}
				}
			}
								// 最大値，最小値の計算
			fh = -1;
			fg = -1;
			fl = -1;
			for (int i1 = 0; i1 < n+1; i1++) {
				if (fh < 0 || yy[i1] > yy[fh])
					fh = i1;
				if (fl < 0 || yy[i1] < yy[fl])
					fl = i1;
			}
			for (int i1 = 0; i1 < n+1; i1++) {
				if (i1 != fh && (fg < 0 || yy[i1] > yy[fg]))
					fg = i1;
			}
								// 収束判定
			double e = 0.0;
			for (int i1 = 0; i1 < n+1; i1++) {
				if (i1 != fl) {
					yr  = yy[i1] - yy[fl];
					e  += yr * yr;
				}
			}
			if (e < eps)
				sw = 0;
		}
	
		if (sw == 0) {
			sw = count;
			y  = yy[fl];
			for (int i1 = 0; i1 < n; i1++)
				x[i1] = xx[fl][i1];
		}
	
		return sw;
	}
}

  8. VB 

    ''''''''''''''''''''''''''''''''''''''
' シンプレックス法による最小値の計算 '
'      coded by Y.Suganuma           '
''''''''''''''''''''''''''''''''''''''
Imports System.Text.RegularExpressions

Module Test

	Sub Main()
					' データの入力
							' 1 行目
		Dim MS As Regex     = New Regex("\s+") 
		Dim str() As String = MS.Split(Console.ReadLine().Trim())
		Dim fun As Integer  = Integer.Parse(str(1))
		Dim n As Integer    = Integer.Parse(str(3))
		Dim max As Integer  = Integer.Parse(str(5))
		Dim k As Integer    = Double.Parse(str(7))
							' 2 行目
		str = MS.Split(Console.ReadLine().Trim())
		Dim eps As Double = Double.Parse(str(1))
		Dim r1 As Double  = Double.Parse(str(3))
		Dim r2 As Double  = Double.Parse(str(5))
							' 3 行目
		Dim x(n) As Double
		Dim y As Double = 0.0
		str             = MS.Split(Console.ReadLine().Trim())
		For i1 As Integer = 0 To n-1
			x(i1) = Double.Parse(str(i1+1))
		Next
					' 関数１の値の計算（ラムダ式）
		Dim snx1 = Function(x0) As Double
			Dim x1 As Double = x0(0) - 1.0
			Dim y1 As Double = x0(1) - 2.0
			Dim y0 As Double = x1 * x1 + y1 * y1
			Return y0
		End Function
					' 関数２の値の計算（ラムダ式）
		Dim snx2 = Function(x0) As Double
			Dim x1 As Double = x0(1) - x0(0) * x0(0)
			Dim y1 As Double = 1.0 - x0(0)
			Dim y0 As Double = 100.0 * x1 * x1 + y1 * y1
			Return y0
		End Function
					' 関数３の値の計算（ラムダ式）
		Dim snx3 = Function(x0) As Double
			Dim x1 As Double = 1.5 - x0(0) * (1.0 - x0(1))
			Dim y1 As Double = 2.25 - x0(0) * (1.0 - x0(1) * x0(1))
			Dim z1 As Double = 2.625 - x0(0) * (1.0 - x0(1) * x0(1) * x0(1))
			Dim y0 As Double = x1 * x1 + y1 * y1 + z1 * z1
			Return y0
		End Function
					' 実行
		Dim sw As Integer
		If fun = 1
			sw = simplex(max, n, k, eps, r1, r2, y, x, snx1)
		ElseIf fun = 2
			sw = simplex(max, n, k, eps, r1, r2, y, x, snx2)
		Else
			sw = simplex(max, n, k, eps, r1, r2, y, x, snx3)
		End If
					' 結果の出力
		If sw < 0
			Console.Write("   収束しませんでした！")
		Else
			Console.Write("   結果＝")
			For i1 As Integer = 0 To n-1
				Console.Write(x(i1) & " ")
			Next
			Console.WriteLine(" 最小値＝" & y & "  回数＝" & sw)
		End If

	End Sub

	''''''''''''''''''''''''''''''''''''''''''
	' シンプレックス法                       '
	'      max : 最大繰り返し回数            '
	'      n : 次元                          '
	'      k : 初期値設定係数                '
	'      r1 : 縮小比率                     '
	'      r2 : 拡大比率                     '
	'      y : 最小値                        '
	'      x : x(初期値と答え)               '
	'      fn : 関数値を計算する関数         '
	'      return : >=0 : 正常終了(収束回数) '
	'               =-1 : 収束せず           '
	''''''''''''''''''''''''''''''''''''''''''
	Function simplex(max As Integer, n As Integer, k As Double, eps As Double,
	                 r1 As Double, r2 As Double, ByRef y As Double, x() As Double,
	                 fn As Func(Of Double(), Double))

						' 初期値の設定
		Dim yy(n+1) As Double
		Dim xg(n) As Double
		Dim xr(n) As Double
		Dim xn(n) As Double
		Dim xx(n+1,n) As Double
		For i1 As Integer = 0 To n
			For i2 As Integer = 0 To n-1
				xx(i1,i2) = x(i2)
			Next
			If i1 > 0
				xx(i1,i1-1) += k
			End If
			Dim xx1(n) As Double
			For i2 As Integer = 0 To n-1
				xx1(i2) = xx(i1,i2)
			Next
			yy(i1) = fn(xx1)
		Next
						' 最大値，最小値の計算
		Dim fh As Integer = -1
		Dim fg As Integer = -1
		Dim fl As Integer = -1
		For i1 As Integer = 0 To n
			If fh < 0
				fh = i1
			ElseIf yy(i1) > yy(fh)
				fh = i1
			End If
			If fl < 0
				fl = i1
			ElseIf yy(i1) < yy(fl)
				fl = i1
			End If
		Next
		For i1 As Integer = 0 To n
			If i1 <> fh
				If fg < 0
					fg = i1
				ElseIf yy(i1) > yy(fg)
					fg = i1
				End If
			End If
		Next
						' 最小値の計算
		Dim count As Integer = 0
		Dim sw As Integer    = -1
		Do While count < max and sw < 0
			count += 1
								' 重心の計算
			For i1 As Integer = 0 To n-1
				xg(i1) = 0.0
			Next
			For i1 As Integer = 0 To n
				If i1 <> fh
					For i2 As Integer = 0 To n-1
						xg(i2) += xx(i1,i2)
					Next
				End If
			Next
			For i1 As Integer = 0 To n-1
				xg(i1) /= n
			Next
								' 最大点の置き換え
			For i1 As Integer = 0 To n-1
				xr(i1) = 2.0 * xg(i1) - xx(fh,i1)
			Next
			Dim yr As Double = fn(xr)
			If yr >= yy(fh)   ' 縮小
				For i1 As Integer = 0 To n-1
					xr(i1) = (1.0 - r1) * xx(fh,i1) + r1 * xr(i1)
				Next
				yr = fn(xr)
			ElseIf yr < (yy(fl)+(r2-1.0)*yy(fh))/r2   ' 拡大
				For i1 As Integer = 0 To n-1
					xn(i1) = r2 * xr(i1) - (r2 - 1.0) * xx(fh,i1)
				Next
				Dim yn As Double = fn(xn)
				If yn <= yr
					For i1 As Integer = 0 To n-1
						xr(i1) = xn(i1)
					Next
					yr = yn
				End If
			End If
			For i1 As Integer = 0 To n-1
				xx(fh,i1) = xr(i1)
			Next
			yy(fh) = yr
								' シンプレックス全体の縮小
			If yy(fh) >= yy(fg)
				For i1 As Integer = 0 To n
					If i1 <> fl
						For i2 As Integer = 0 To n-1
							xx(i1,i2) = 0.5 * (xx(i1,i2) + xx(fl,i2))
						Next
						Dim xx1(n) As Double
						For i2 As Integer = 0 To n-1
							xx1(i2) = xx(i1,i2)
						Next
						yy(i1) = fn(xx1)
					End If
				Next
			End If
								' 最大値，最小値の計算
			fh = -1
			fg = -1
			fl = -1
			For i1 As Integer = 0 To n
				If fh < 0
					fh = i1
				ElseIf yy(i1) > yy(fh)
					fh = i1
				End If
				If fl < 0
					fl = i1
				ElseIf yy(i1) < yy(fl)
					fl = i1
				End If
			Next
			For i1 As Integer = 0 To n
				If i1 <> fh
					If fg < 0
						fg = i1
					ElseIf yy(i1) > yy(fg)
						fg = i1
					End If
				End If
			Next
								' 収束判定
			Dim e As Double = 0.0
			For i1 As Integer = 0 To n
				If i1 <> fl
					yr  = yy(i1) - yy(fl)
					e  += yr * yr
				End If
			Next
			If e < eps
				sw = 0
			End If
		Loop
	
		If sw = 0
			sw = count
			y  = yy(fl)
			For i1 As Integer = 0 To n-1
				x(i1) = xx(fl,i1)
			Next
		End If
	
		Return sw

	End Function

End Module

情報学部 菅沼ホーム 目次 索引