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

数値積分（シンプソン則）

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

　　プログラムは，シンプソン則により sin(x) を 0 から π／２ までの積分するプログラム例です．

  1. C++ 

    /****************************/
/* シンプソン則             */
/*      coded by Y.Suganuma */
/****************************/
#include <stdio.h>
#include <math.h>

double snx(double);
double simpson(double, double, int, double(*)(double));

int main()
{
	double y, pi2 = 2.0 * atan(1.0);

	y = simpson(0.0, pi2, 100, snx);

	printf("result %f\n", y);

	return 0;
}

/****************/
/* 関数値の計算 */
/****************/
double snx(double x)
{
	return sin(x);
}

/*******************************************************/
/* 数値積分（シンプソン則）                            */
/*      x1 : 下限                                      */
/*      x2 : 上限                                      */
/*      n : 分割数                                     */
/*      fun : 関数名（f）                              */
/*      return : 積分値                                */
/*******************************************************/
double simpson(double x1, double x2, int n, double(*fun)(double))
{
	double s1 = 0.0;
	double s2 = 0.0;
	double s, x, h, h2;

	h  = (x2 - x1) / n;
	h2 = 2.0 * h;

	for (x = x1+h; x < x2; x += h2)
		s1 += (*fun)(x);

	for (x = x1+h2; x < x2-h; x += h2)
		s2 += (*fun)(x);

	s = h * ((*fun)(x1) + (*fun)(x2) + 4.0 * s1 + 2.0 * s2) / 3.0;

	return s;
}

  2. Java 

    /****************************/
/* シンプソン則             */
/*      coded by Y.Suganuma */
/****************************/
import java.io.*;

public class Test {
	public static void main(String args[]) throws IOException
	{
		double y;

		Kansu kn = new Kansu();
		y = kn.simpson(0.0, 0.5*Math.PI, 100);

		System.out.println("result " + y);
	}
}

/****************/
/* 関数値の計算 */
/****************/
class Kansu extends Simpson
{
	double snx(double x)
	{
		double y = Math.sin(x);
		return y;
	}
}

abstract class Simpson {

	/*******************************************************/
	/* 数値積分（シンプソン則）                            */
	/*      x1 : 下限                                      */
	/*      x2 : 上限                                      */
	/*      n : 分割数                                     */
	/*      return : 積分値                                */
	/*******************************************************/

	abstract double snx(double x);

	double simpson(double x1, double x2, int n)
	{
		double s1 = 0.0;
		double s2 = 0.0;
		double s, x, h, h2;

		h  = (x2 - x1) / n;
		h2 = 2.0 * h;

		for (x = x1+h; x < x2; x += h2)
			s1 += snx(x);

		for (x = x1+h2; x < x2-h; x += h2)
			s2 += snx(x);

		s = h * (snx(x1) + snx(x2) + 4.0 * s1 + 2.0 * s2) / 3.0;

		return s;
	}
}

  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()
		{
			str = document.getElementById("func").value + ";";
					// データの設定
			let n  = parseInt(document.getElementById("haba").value);
			let x1 = parseFloat(document.getElementById("x1").value);
			let x2 = parseFloat(document.getElementById("x2").value);
					// 実行
			let x = simpson(x1, x2, n, snx);
					// 結果
			let c = 100000;
			let s1 = Math.round(x * c) / c;
			document.getElementById("res").value = s1;
		}

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

		/**********************************/
		/* 数値積分（シンプソン則）       */
		/*      x1 : 下限                 */
		/*      x2 : 上限                 */
		/*      n : 分割数                */
		/*      fn : 関数値を計算する関数 */
		/*      return : 積分値           */
		/**********************************/
		function simpson(x1, x2, n, fn)
		{
			let s1 = 0.0;
			let s2 = 0.0;

			let h  = (x2 - x1) / n;
			let h2 = 2.0 * h;

			for (let x = x1+h; x < x2; x += h2)
				s1 += fn(x);

			for (let x = x1+h2; x < x2-h; x += h2)
				s2 += fn(x);

			let s = h * (fn(x1) + fn(x2) + 4.0 * s1 + 2.0 * s2) / 3.0;

			return s;
		}
	</SCRIPT>

</HEAD>

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

	<H2 STYLE="text-align:center"><B>数値積分（シンプソン則）</B></H2>

	<DL>
		<DT>　　テキストフィールドには，例として，sin(x) を 0 から π/2 まで積分する場合に対する値が設定されています．他の問題を実行する場合は，それらを適切に修正してください．なお，式は，JavaScript の仕様に適合した形式で記述してあることに注意してください．
	</DL>

	<DIV STYLE="text-align:center">
		積分範囲：<INPUT ID="x1" STYLE="font-size: 100%" TYPE="text" SIZE="10" VALUE="0.0">，
				<INPUT ID="x2" STYLE="font-size: 100%" TYPE="text" SIZE="10" VALUE="1.570796327">　
		分割：<INPUT ID="haba" 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.sin(x)">　　
		<BUTTON STYLE="font-size: 100%; background-color: pink" onClick="main()">実行</BUTTON><BR><BR>
		結果：<INPUT ID="res" STYLE="font-size: 100%" TYPE="text" SIZE="10">
	</DIV>

</BODY>

</HTML>

  4. PHP 

    <?php

/****************************/
/* シンプソン則             */
/*      coded by Y.Suganuma */
/****************************/

	$pi2 = 2.0 * atan(1.0);

	$y = simpson(0.0, $pi2, 100, "snx");

	printf("result %f\n", $y);

/****************/
/* 関数値の計算 */
/****************/
function snx($x)
{
	return sin($x);
}

/*******************************************************/
/* 数値積分（シンプソン則）                            */
/*      x1 : 下限                                      */
/*      x2 : 上限                                      */
/*      n : 分割数                                     */
/*      fun : 関数名（f）                              */
/*      return : 積分値                                */
/*******************************************************/
function simpson($x1, $x2, $n, $fun)
{
	$s1 = 0.0;
	$s2 = 0.0;
	$h  = ($x2 - $x1) / $n;
	$h2 = 2.0 * $h;

	for ($x = $x1+$h; $x < $x2; $x += $h2)
		$s1 += $fun($x);

	for ($x = $x1+$h2; $x < $x2-$h; $x += $h2)
		$s2 += $fun($x);

	$s = $h * ($fun($x1) + $fun($x2) + 4.0 * $s1 + 2.0 * $s2) / 3.0;

	return $s;
}

?>

  5. Ruby 

    #***************************/
# シンプソン則             */
#      coded by Y.Suganuma */
#***************************/

#***************/
# 関数値の計算 */
#***************/
snx = Proc.new { |x|
	Math.sin(x)
}

#******************************************************/
# 数値積分（シンプソン則）                            */
#      x1 : 下限                                      */
#      x2 : 上限                                      */
#      n : 分割数                                     */
#      fun : 関数名（f）                              */
#      return : 積分値                                */
#******************************************************/
def simpson(x1, x2, n, &fun)

	s1 = 0.0
	s2 = 0.0
	h  = (x2 - x1) / n
	h2 = 2.0 * h

	x = x1 + h
	while x < x2
		s1 += fun.call(x)
		x  += h2
	end

	x = x1 + h2
	while x < x2-h
		s2 += fun.call(x)
		x  += h2
	end

	s = h * (fun.call(x1) + fun.call(x2) + 4.0 * s1 + 2.0 * s2) / 3.0

	return s
end

pi2 = 2.0 * Math.atan(1.0)
y   = simpson(0.0, pi2, 100, &snx)
printf("result %f\n", y)

  6. Python 

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

############################################
# 数値積分（シンプソン則）
#      x1 : 下限
#      x2 : 上限
#      n : 分割数
#      fun : 関数名（f）
#      return : 積分値
#      coded by Y.Suganuma
############################################

def simpson(x1, x2, n, fun) :

	s1 = 0.0
	s2 = 0.0
	h  = (x2 - x1) / n
	h2 = 2.0 * h

	x  = x1 + h
	while x < x2 :
		s1 += fun(x)
		x  += h2

	x = x1 + h2
	while x < x2 - h :
		s2 += fun(x)
		x  += h2

	s = h * (fun(x1) + fun(x2) + 4.0 * s1 + 2.0 * s2) / 3.0

	return s;

############################################
# シンプソン則
#      coded by Y.Suganuma
############################################

			# 関数値の計算
def snx(x) :
	return sin(x)
			# 計算
pi2 = 0.5 * pi
y = simpson(0.0, pi2, 100, snx)
print("result " + str(y))

  7. C# 

    /****************************/
/* シンプソン則             */
/*      coded by Y.Suganuma */
/****************************/
using System;

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

class Test1
{
	public Test1()
	{
		double y = simpson(0.0, 0.5*Math.PI, 100, snx);

		Console.WriteLine("result " + y);
	}
			// 関数値の計算
	double snx(double x)
	{
		return Math.Sin(x);
	}

	/**********************************/
	/* 数値積分（シンプソン則）       */
	/*      x1 : 下限                 */
	/*      x2 : 上限                 */
	/*      n : 分割数                */
	/*      fn : 関数値を計算する関数 */
	/*      return : 積分値           */
	/**********************************/
	double simpson(double x1, double x2, int n, Func<double, double> fn)
	{
		double h  = (x2 - x1) / n;
		double h2 = 2.0 * h;

		double s1 = 0.0;
		for (double x = x1+h; x < x2; x += h2)
			s1 += fn(x);

		double s2 = 0.0;
		for (double x = x1+h2; x < x2-h; x += h2)
			s2 += fn(x);

		double s = h * (fn(x1) + fn(x2) + 4.0 * s1 + 2.0 * s2) / 3.0;

		return s;
	}
}

  8. VB 

    ''''''''''''''''''''''''''''
' シンプソン則             '
'      coded by Y.Suganuma '
''''''''''''''''''''''''''''
Module Test

	Sub Main()
			' 関数値の計算（ラムダ式）
		Dim snx = Function(x) As Double
			Return Math.Sin(x)
		End Function
			' 実行
		Dim y As Double = simpson(0.0, 0.5*Math.PI, 100, snx)

		Console.WriteLine("result " & y)

	End Sub

	''''''''''''''''''''''''''''''''''
	' 数値積分（シンプソン則）       '
	'      x1 : 下限                 '
	'      x2 : 上限                 '
	'      n : 分割数                '
	'      fn : 関数値を計算する関数 '
	'      return : 積分値           '
	''''''''''''''''''''''''''''''''''
	Function simpson(x1 As Double, x2 As Double, n As Integer, fn As Func(Of Double, Double))

		Dim h As Double  = (x2 - x1) / n
		Dim h2 As Double = 2.0 * h

		Dim s1 As Double = 0.0
		For x As Double = x1+h To x2+1.0e-10 Step h2
			s1 += fn(x)
		Next

		Dim s2 As Double = 0.0
		For x As Double = x1+h2 To x2-h+1.0e-10 Step h2
			s2 += fn(x)
		Next

		Dim s As Double = h * (fn(x1) + fn(x2) + 4.0 * s1 + 2.0 * s2) / 3.0

		Return s

	End Function

End Module

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