静岡理工科大学 菅沼ホーム 目次 索引

数値積分(シンプソン則)

    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 から π/2 までの積分するプログラム例です.

  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
    			

静岡理工科大学 菅沼ホーム 目次 索引