非線形方程式（セカント法）

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

　　プログラムは，f(x) = exp(x) - 3x = 0 の根をセカント法で求めた例です．

1. C++

   /*************************************/
   /* セカント法による exp(x)-3x=0 の根 */
   /*      coded by Y.Suganuma          */
   /*************************************/
   #include 
   #include 
   
   double secant(double, double, int, double, double, int *,
                 double(*)(double));
   double snx(double);
   
   int main()
   {
   	double eps1, eps2, x, x1, x2;
   	int max, ind;
   /*
             データの設定
   */
   	eps1 = 1.0e-10;
   	eps2 = 1.0e-10;
   	max  = 100;
   	x1   = 0.0;
   	x2   = 1.0;
   /*
             実行と結果
   */
   	x = secant(x1, x2, max, eps1, eps2, &ind, snx);
   
   	printf("   ind=%d  x=%f  f= %f\n", ind, x, snx(x));
   
   	return 0;
   }
   
   /****************/
   /* 関数値の計算 */
   /****************/
   double snx(double x)
   {
   	double y;
   	y = exp(x) - 3.0 * x;
   	return y;
   }
   
   /*********************************************************/
   /* secant法（はさみうち法）による非線形方程式f(x)=0の解  */
   /*      x1,x2 : 初期値（x1 < x2）                        */
   /*      max : 最大試行回数                               */
   /*      eps1 : 終了条件１（｜x(k+1)-x(k)｜＜eps1）       */
   /*      eps2 : 終了条件２（｜f(x(k))｜＜eps2）           */
   /*      ind : > 0 : 収束回数                             */
   /*            =-1 : 収束しなかった                       */
   /*      g : f(x)を計算する関数名                         */
   /*      return : 解                                      */
   /*********************************************************/
   #include 
   
   double secant(double x1, double x2, int max, double eps1, double eps2,
                 int *ind, double (*g)(double))
   {
   	double f, f1, f2, x = 0.0;
   	int count;
   
   	count = 0;
   	*ind  = 0;
   	f1    = (*g)(x1);
   	f2    = (*g)(x2);
   
   	if (fabs(f1) < eps2)
   		x = x1;
   	else {
   		if (fabs(f2) < eps2)
   			x = x2;
   		else {
   			while (*ind == 0) {
   				count += 1;
   				if (fabs(f2-f1) < eps2)
   					*ind = -1;
   				else {
   					x = x2 - f2 * (x2 - x1) / (f2 - f1);
   					f = (*g)(x);
   					if (fabs(f) < eps2 ||
   						 fabs(x2-x1) < eps1 || fabs(x2-x1) < eps1*fabs(x2))
   						*ind = count;
   					else {
   						if (count < max) {
   							if (f1*f2 < 0.0) {
   								x2 = x;
   								f2 = f;
   							}
   							else {
   								x1 = x;
   								f1 = f;
   							}
   						}
   						else
   							*ind = -1;
   					}
   				}
   			}
   		}
   	}
   
   	return x;
   }
   			

2. Java

   /*************************************/
   /* セカント法による exp(x)-3x=0 の根 */
   /*      coded by Y.Suganuma          */
   /*************************************/
   import java.io.*;
   
   public class Test {
   	public static void main(String args[]) throws IOException
   	{
   		double eps1, eps2, x, x1, x2;
   		int max, ind[] = new int [1];
   	/*
   	          データの設定
   	*/
   		eps1 = 1.0e-10;
   		eps2 = 1.0e-10;
   		max  = 100;
   		x1   = 0.0;
   		x2   = 1.0;
   	/*
   	          実行と結果
   	*/
   		Kansu kn = new Kansu();
   		x = kn.secant(x1, x2, max, eps1, eps2, ind);
   
   		System.out.println("   ind=" + ind[0] + "  x=" + x + "  f=" + kn.snx(x));
   	}
   }
   
   /****************/
   /* 関数値の計算 */
   /****************/
   class Kansu extends Secant
   {
   	double snx(double x)
   	{
   		double y = Math.exp(x) - 3.0 * x;
   		return y;
   	}
   }
   
   abstract class Secant
   {
   	/*********************************************************/
   	/* secant法（はさみうち法）による非線形方程式f(x)=0の解  */
   	/*      x1,x2 : 初期値（x1 < x2）                        */
   	/*      max : 最大試行回数                               */
   	/*      eps1 : 終了条件１（｜x(k+1)-x(k)｜＜eps1）       */
   	/*      eps2 : 終了条件２（｜f(x(k))｜＜eps2）           */
   	/*      ind : > 0 : 収束回数                             */
   	/*            =-1 : 収束しなかった                       */
   	/*      return : 解                                      */
   	/*********************************************************/
   
   	abstract double snx(double x);   // 定義しておく必要あり
   
   	double secant(double x1, double x2, int max, double eps1, double eps2, int ind[])
   	{
   		double f, f1, f2, x = 0.0;
   		int count;
   
   		count  = 0;
   		ind[0] = 0;
   		f1     = snx(x1);
   		f2     = snx(x2);
   
   		if (Math.abs(f1) < eps2)
   			x = x1;
   		else {
   			if (Math.abs(f2) < eps2)
   				x = x2;
   			else {
   				while (ind[0] == 0) {
   					count += 1;
   					if (Math.abs(f2-f1) < eps2)
   						ind[0] = -1;
   					else {
   						x = x2 - f2 * (x2 - x1) / (f2 - f1);
   						f = snx(x);
   						if (Math.abs(f) < eps2 ||
   						    Math.abs(x2-x1) < eps1 || Math.abs(x2-x1) < eps1*Math.abs(x2))
   							ind[0] = count;
   						else {
   							if (count < max) {
   								if (f1*f2 < 0.0) {
   									x2 = x;
   									f2 = f;
   								}
   								else {
   									x1 = x;
   									f1 = f;
   								}
   							}
   							else
   								ind[0] = -1;
   						}
   					}
   				}
   			}
   		}
   
   		return x;
   	}
   }
   			

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 = "";
   		ind = 0;   // 実際の試行回数（負の時は解を得ることができなかった）
   		function main()
   		{
   			str = document.getElementById("func").value + ";";
   					// データの設定
   			let eps1 = 1.0e-10;
   			let eps2 = 1.0e-10;
   			let max  = parseInt(document.getElementById("max").value);
   			let x1   = parseFloat(document.getElementById("x1").value);
   			let x2   = parseFloat(document.getElementById("x2").value);
   			ind      = 0;
   					// 実行
   			let x = secant(x1, x2, max, eps1, eps2, snx);
   					// 結果
   			if (ind < 0)
   				document.getElementById("res").value = "解を求めることができませんでした！";
   			else {
   				let c = 100000;
   				let s1 = Math.round(x * c) / c;
   				document.getElementById("res").value = " x = " + s1 + "，　収束回数：" + ind;
   			}
   		}
   
   		/****************/
   		/* 関数値の計算 */
   		/****************/
   		function snx(x)
   		{
   			let y = eval(str);
   			return y;
   		}
   
   		/*********************************************************/
   		/* secant法（はさみうち法）による非線形方程式f(x)=0の解  */
   		/*      x1,x2 : 初期値（x1 < x2）                        */
   		/*      max : 最大試行回数                               */
   		/*      eps1 : 終了条件１（｜x(k+1)-x(k)｜＜eps1）       */
   		/*      eps2 : 終了条件２（｜f(x(k))｜＜eps2）           */
   		/*      fn : 関数値を計算する関数　　　　　　      　　　*/
   		/*      return : 解                                      */
   		/*********************************************************/
   		function secant(x1, x2, max, eps1, eps2, fn)
   		{
   			let f, x = 0.0;
   
   			let count = 0;
   			let f1    = fn(x1);
   			let f2    = fn(x2);
   
   			if (Math.abs(f1) < eps2)
   				x = x1;
   			else {
   				if (Math.abs(f2) < eps2)
   					x = x2;
   				else {
   					while (ind == 0) {
   						count += 1;
   						if (Math.abs(f2-f1) < eps2)
   							ind = -1;
   						else {
   							x = x2 - f2 * (x2 - x1) / (f2 - f1);
   							f = fn(x);
   							if (Math.abs(f) < eps2 || Math.abs(x2-x1) < eps1 || Math.abs(x2-x1) < eps1*Math.abs(x2))
   								ind = count;
   							else {
   								if (count < max) {
   									if (f1*f2 < 0.0) {
   										x2 = x;
   										f2 = f;
   									}
   									else {
   										x1 = x;
   										f1 = f;
   									}
   								}
   								else
   									ind = -1;
   							}
   						}
   					}
   				}
   			}
   
   			return x;
   		}
   	</SCRIPT>
   
   </HEAD>
   
   <BODY STYLE="font-size: 130%; background-color: #eeffee;">
   
   	<H2 STYLE="text-align:center"><B>非線形方程式（セカント法）</B></H2>
   
   	<DL>
   		<DT>　　テキストフィールドには，例として，以下に示すような非線形方程式の解を求める場合に対する値が設定されています．他の問題を実行する場合は，それらを適切に修正してください．なお，式は，JavaScript の仕様に適合した形式で記述してあることに注意してください． 
   		<P STYLE="text-align:center"><IMG SRC="secant.gif"></P>
   	</DL>
   
   	<DIV STYLE="text-align:center">
   		初期値：<INPUT ID="x1" STYLE="font-size: 100%" TYPE="text" SIZE="5" VALUE="0">，
   				<INPUT ID="x2" STYLE="font-size: 100%" TYPE="text" SIZE="5" VALUE="1">　
   		最大繰り返し回数：<INPUT ID="max" STYLE="font-size: 100%" TYPE="text" SIZE="5" VALUE="100"><BR><BR>
   		式：<INPUT ID="func" STYLE="font-size: 100%" TYPE="text" SIZE="50" VALUE="Math.exp(x) - 3.0 * x">= 0　　
   		<BUTTON STYLE="font-size: 100%; background-color: pink" onClick="main()">実行</BUTTON><BR><BR>
   		結果：<INPUT ID="res" STYLE="font-size: 100%" TYPE="text" SIZE="30">
   	</DIV>
   
   </BODY>
   
   </HTML>
   			

4. PHP

   <?php
   
   /*************************************/
   /* セカント法による exp(x)-3x=0 の根 */
   /*      coded by Y.Suganuma          */
   /*************************************/
   /*
             データの設定
   */
   	$eps1 = 1.0e-10;
   	$eps2 = 1.0e-10;
   	$max  = 100;
   	$x1   = 0.0;
   	$x2   = 1.0;
   /*
             実行と結果
   */
   	$x = secant($x1, $x2, $max, $eps1, $eps2, $ind, "snx");
   
   	printf("   ind=%d  x=%f  f= %f\n", $ind, $x, snx($x));
   
   /****************/
   /* 関数値の計算 */
   /****************/
   function snx($x)
   {
   	return exp($x) - 3.0 * $x;
   }
   
   /*********************************************************/
   /* secant法（はさみうち法）による非線形方程式f(x)=0の解  */
   /*      x1,x2 : 初期値（x1 < x2）                        */
   /*      max : 最大試行回数                               */
   /*      eps1 : 終了条件１（｜x(k+1)-x(k)｜＜eps1）       */
   /*      eps2 : 終了条件２（｜f(x(k))｜＜eps2）           */
   /*      ind : > 0 : 収束回数                             */
   /*            =-1 : 収束しなかった                       */
   /*      fun : f(x)を計算する関数名                       */
   /*      return : 解                                      */
   /*********************************************************/
   #include 
   
   function secant($x1, $x2, $max, $eps1, $eps2, &$ind, $fun)
   {
   
   	$x     = 0.0;
   	$count = 0;
   	$ind   = 0;
   	$f1    = $fun($x1);
   	$f2    = $fun($x2);
   
   	if (abs($f1) < $eps2)
   		$x = $x1;
   	else {
   		if (abs($f2) < $eps2)
   			$x = $x2;
   		else {
   			while ($ind == 0) {
   				$count += 1;
   				if (abs($f2-$f1) < $eps2)
   					$ind = -1;
   				else {
   					$x = $x2 - $f2 * ($x2 - $x1) / ($f2 - $f1);
   					$f = $fun($x);
   					if (abs($f) < $eps2 || abs($x2-$x1) < $eps1 || abs($x2-$x1) < $eps1*abs($x2))
   						$ind = $count;
   					else {
   						if ($count < $max) {
   							if ($f1*$f2 < 0.0) {
   								$x2 = $x;
   								$f2 = $f;
   							}
   							else {
   								$x1 = $x;
   								$f1 = $f;
   							}
   						}
   						else
   							$ind = -1;
   					}
   				}
   			}
   		}
   	}
   
   	return $x;
   }
   
   ?>
   			

5. Ruby

   ############################################
   # セカント法による exp(x)-3x=0 の根
   #      coded by Y.Suganuma
   ############################################
   
   ############################################
   # secant法（はさみうち法）による非線形方程式f(x)=0の解
   #      x1,x2 : 初期値（x1 < x2）
   #      max : 最大試行回数
   #      eps1 : 終了条件１（｜x(k+1)-x(k)｜＜eps1）
   #      eps2 : 終了条件２（｜f(x(k))｜＜eps2）
   #      ind : > 0 : 収束回数
   #            =-1 : 収束しなかった
   #      fn : f(x)を計算する関数名
   #      return : 解
   #      coded by Y.Suganuma
   ############################################
   
   def secant(x1, x2, max, eps1, eps2, ind, &fn) 
   
   	x      = 0.0
   	count  = 0
   	ind[0] = 0
   	f1     = fn.call(x1)
   	f2     = fn.call(x2)
   
   	if f1.abs() < eps2 
   		x = x1
   	else 
   		if f2.abs() < eps2 
   			x = x2
   		else 
   			while ind[0] == 0 
   				count += 1
   				if (f2-f1).abs() < eps2 
   					ind[0] = -1
   				else 
   					x = x2 - f2 * (x2 - x1) / (f2 - f1)
   					f = fn.call(x)
   					if f.abs() < eps2 or (x2-x1).abs() < eps1 or (x2-x1).abs() < eps1*x2.abs() 
   						ind[0] = count
   					else 
   						if count < max 
   							if f1*f2 < 0.0 
   								x2 = x
   								f2 = f
   							else 
   								x1 = x
   								f1 = f
   							end
   						else 
   							ind[0] = -1
   						end
   					end
   				end
   			end
   		end
   	end
   
   	return x
   end
   
   ################
   # 関数値の計算 #
   ################
   snx = Proc.new { |x|
   	Math.exp(x) - 3.0 * x
   }
   
   			# データの設定
   ind  = [0];
   eps1 = 1.0e-10
   eps2 = 1.0e-10
   max  = 100
   x1   = 0.0
   x2   = 1.0
   			# 実行と結果
   x = secant(x1, x2, max, eps1, eps2, ind, &snx)
   
   print("   ind=", ind[0], "  x=", x, "  f= ", snx.call(x), "\n")
   			

6. Python

   # -*- coding: UTF-8 -*-
   import numpy as np
   from math import *
   
   ############################################
   # secant法（はさみうち法）による非線形方程式f(x)=0の解
   #      x1,x2 : 初期値（x1 < x2）
   #      max : 最大試行回数
   #      eps1 : 終了条件１（｜x(k+1)-x(k)｜＜eps1）
   #      eps2 : 終了条件２（｜f(x(k))｜＜eps2）
   #      ind : > 0 : 収束回数
   #            =-1 : 収束しなかった
   #      fn : f(x)を計算する関数名
   #      return : 解
   #      coded by Y.Suganuma
   ############################################
   
   def secant(x1, x2, max, eps1, eps2, ind, fn) :
   
   	x      = 0.0
   	count  = 0
   	ind[0] = 0
   	f1     = fn(x1)
   	f2     = fn(x2)
   
   	if abs(f1) < eps2 :
   		x = x1
   	else :
   		if abs(f2) < eps2 :
   			x = x2
   		else :
   			while ind[0] == 0 :
   				count += 1
   				if abs(f2-f1) < eps2 :
   					ind[0] = -1
   				else :
   					x = x2 - f2 * (x2 - x1) / (f2 - f1)
   					f = fn(x)
   					if abs(f) < eps2 or abs(x2-x1) < eps1 or abs(x2-x1) < eps1*abs(x2) :
   						ind[0] = count
   					else :
   						if count < max :
   							if f1*f2 < 0.0 :
   								x2 = x
   								f2 = f
   							else :
   								x1 = x
   								f1 = f
   						else :
   							ind[0] = -1
   
   	return x
   
   ################
   # 関数値の計算 #
   ################
   def snx(x) :
   	return exp(x) - 3.0 * x
   
   ############################################
   # セカント法による exp(x)-3x=0 の根
   #      coded by Y.Suganuma
   ############################################
   
   			# データの設定
   ind  = [0];
   eps1 = 1.0e-10
   eps2 = 1.0e-10
   max  = 100
   x1   = 0.0
   x2   = 1.0
   			# 実行と結果
   x = secant(x1, x2, max, eps1, eps2, ind, snx)
   
   print("   ind=" + str(ind[0]) + "  x=" + str(x) + "  f= " + str(snx(x)))
   			

7. C#

   /*************************************/
   /* セカント法による exp(x)-3x=0 の根 */
   /*      coded by Y.Suganuma          */
   /*************************************/
   using System;
   
   class Program
   {
   	static void Main()
   	{
   		Test1 ts = new Test1();
   	}
   }
   
   class Test1
   {
   	public Test1()
   	{
   	/*
   	          データの設定
   	*/
   		double eps1 = 1.0e-10;
   		double eps2 = 1.0e-10;
   		double x1   = 0.0;
   		double x2   = 1.0;
   		int max     = 100;
   		int ind     = 0;
   	/*
   	          実行と結果
   	*/
   		double x = secant(x1, x2, max, eps1, eps2, ref ind, snx);
   
   		Console.WriteLine("   ind=" + ind + "  x=" + x + "  f=" + snx(x));
   	}
   
   	/****************/
   	/* 関数値の計算 */
   	/****************/
   	double snx(double x)
   	{
   		return Math.Exp(x) - 3.0 * x;
   	}
   
   	/*********************************************************/
   	/* secant法（はさみうち法）による非線形方程式f(x)=0の解  */
   	/*      x1,x2 : 初期値（x1 < x2）                        */
   	/*      max : 最大試行回数                               */
   	/*      eps1 : 終了条件１（｜x(k+1)-x(k)｜＜eps1）       */
   	/*      eps2 : 終了条件２（｜f(x(k))｜＜eps2）           */
   	/*      ind : > 0 : 収束回数                             */
   	/*            =-1 : 収束しなかった                       */
   	/*      fn : 関数値を計算する関数                        */
   	/*      return : 解                                      */
   	/*********************************************************/
   	double secant(double x1, double x2, int max, double eps1, double eps2,
   	              ref int ind, Func<double, double> fn)
   	{
   		double f1 = fn(x1);
   		double f2 = fn(x2);
   		double x  = 0.0;
   		int count = 0;
   		ind = 0;
   
   		if (Math.Abs(f1) < eps2)
   			x = x1;
   		else {
   			if (Math.Abs(f2) < eps2)
   				x = x2;
   			else {
   				while (ind == 0) {
   					count += 1;
   					if (Math.Abs(f2-f1) < eps2)
   						ind = -1;
   					else {
   						x = x2 - f2 * (x2 - x1) / (f2 - f1);
   						double f = fn(x);
   						if (Math.Abs(f) < eps2 ||
   						    Math.Abs(x2-x1) < eps1 || Math.Abs(x2-x1) < eps1*Math.Abs(x2))
   							ind = count;
   						else {
   							if (count < max) {
   								if (f1*f2 < 0.0) {
   									x2 = x;
   									f2 = f;
   								}
   								else {
   									x1 = x;
   									f1 = f;
   								}
   							}
   							else
   								ind = -1;
   						}
   					}
   				}
   			}
   		}
   
   		return x;
   	}
   }
   			

8. VB

   '''''''''''''''''''''''''''''''''''''
   ' セカント法による exp(x)-3x=0 の根 '
   '      coded by Y.Suganuma          '
   '''''''''''''''''''''''''''''''''''''
   Module Test
   	Sub Main()
   				'
   				' データの設定
   				'
   		Dim eps1 As Double = 1.0e-10
   		Dim eps2 As Double = 1.0e-10
   		Dim x1 As Double   = 0.0
   		Dim x2 As Double   = 1.0
   		Dim max As Integer = 100
   		Dim ind As Integer = 0
   				'
   				' 実行と結果
   				'
   		Dim snx = Function(v) As Double   ' 関数値の計算（ラムダ式）
   	                  Return Math.Exp(v) - 3.0 * v
   	              End Function
   
   		Dim x As Double = secant(x1, x2, max, eps1, eps2, ind, snx)
   
   		Console.WriteLine("   ind=" & ind & " x=" & x & "  f=" & snx(x))
   
   	End Sub
   
   	'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
   	' secant法（はさみうち法）による非線形方程式f(x)=0の解  '
   	'      x1,x2 : 初期値（x1 < x2）                        '
   	'      max : 最大試行回数                               '
   	'      eps1 : 終了条件１（｜x(k+1)-x(k)｜＜eps1）       '
   	'      eps2 : 終了条件２（｜f(x(k))｜＜eps2）           '
   	'      ind : > 0 : 収束回数                             '
   	'            =-1 : 収束しなかった                       '
   	'      fn : 関数値を計算する関数                        '
   	'      return : 解                                      '
   	'''''''''''''''''''''''''''''''''''''''''''''''''''''''''
   	Function secant(x1 As Double, x2 As Double, max As Integer, eps1 As Double,
   	                eps2 As Double, ByRef ind As Integer,
   	                fn As Func(Of Double, Double))
   
   		Dim f1 As Double     = fn(x1)
   		Dim f2 As Double     = fn(x2)
   		Dim x As Double      = 0.0
   		Dim count As Integer = 0
   		ind = 0
   
   		If Math.Abs(f1) < eps2
   			x = x1
   		Else
   			If Math.Abs(f2) < eps2
   				x = x2
   			Else
   				Do While ind = 0
   					count += 1
   					If Math.Abs(f2-f1) < eps2
   						ind = -1
   					Else
   						x = x2 - f2 * (x2 - x1) / (f2 - f1)
   						Dim f As Double = fn(x)
   						If Math.Abs(f) < eps2 or
   						   Math.Abs(x2-x1) < eps1 or Math.Abs(x2-x1) < eps1*Math.Abs(x2)
   							ind = count
   						Else
   							If count < max
   								If f1*f2 < 0.0
   									x2 = x
   									f2 = f
   								Else
   									x1 = x
   									f1 = f
   								End If
   							Else
   								ind = -1
   							End If
   						End If
   					End If
   				Loop
   			End If
   		End If
   
   		Return x
   
   	End Function
   
   End Module