forked from TheAlgorithms/Java
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathEulerMethod.java
More file actions
105 lines (95 loc) · 4.26 KB
/
Copy pathEulerMethod.java
File metadata and controls
105 lines (95 loc) · 4.26 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
package Maths;
import java.util.ArrayList;
import java.util.function.BiFunction;
/**
* In mathematics and computational science, the Euler method (also called forward Euler method) is
* a first-order numerical procedure for solving ordinary differential equations (ODEs) with a given
* initial value. It is the most basic explicit method for numerical integration of ordinary
* differential equations. The method proceeds in a series of steps. At each step the y-value is
* calculated by evaluating the differential equation at the previous step, multiplying the result
* with the step-size and adding it to the last y-value: y_n+1 = y_n + stepSize * f(x_n, y_n).
* (description adapted from https://en.wikipedia.org/wiki/Euler_method ) (see also:
* https://www.geeksforgeeks.org/euler-method-solving-differential-equation/ )
*/
public class EulerMethod {
/** Illustrates how the algorithm is used in 3 examples and prints the results to the console. */
public static void main(String[] args) {
System.out.println("example 1:");
BiFunction<Double, Double, Double> exampleEquation1 = (x, y) -> x;
ArrayList<double[]> points1 = eulerFull(0, 4, 0.1, 0, exampleEquation1);
assert points1.get(points1.size() - 1)[1] == 7.800000000000003;
points1.forEach(
point -> System.out.println(String.format("x: %1$f; y: %2$f", point[0], point[1])));
// example from https://en.wikipedia.org/wiki/Euler_method
System.out.println("\n\nexample 2:");
BiFunction<Double, Double, Double> exampleEquation2 = (x, y) -> y;
ArrayList<double[]> points2 = eulerFull(0, 4, 0.1, 1, exampleEquation2);
assert points2.get(points2.size() - 1)[1] == 45.25925556817596;
points2.forEach(
point -> System.out.println(String.format("x: %1$f; y: %2$f", point[0], point[1])));
// example from https://www.geeksforgeeks.org/euler-method-solving-differential-equation/
System.out.println("\n\nexample 3:");
BiFunction<Double, Double, Double> exampleEquation3 = (x, y) -> x + y + x * y;
ArrayList<double[]> points3 = eulerFull(0, 0.1, 0.025, 1, exampleEquation3);
assert points3.get(points3.size() - 1)[1] == 1.1116729841674804;
points3.forEach(
point -> System.out.println(String.format("x: %1$f; y: %2$f", point[0], point[1])));
}
/**
* calculates the next y-value based on the current value of x, y and the stepSize the console.
*
* @param xCurrent Current x-value.
* @param stepSize Step-size on the x-axis.
* @param yCurrent Current y-value.
* @param differentialEquation The differential equation to be solved.
* @return The next y-value.
*/
public static double eulerStep(
double xCurrent,
double stepSize,
double yCurrent,
BiFunction<Double, Double, Double> differentialEquation) {
if (stepSize <= 0) {
throw new IllegalArgumentException("stepSize should be greater than zero");
}
double yNext = yCurrent + stepSize * differentialEquation.apply(xCurrent, yCurrent);
return yNext;
}
/**
* Loops through all the steps until xEnd is reached, adds a point for each step and then returns
* all the points
*
* @param xStart First x-value.
* @param xEnd Last x-value.
* @param stepSize Step-size on the x-axis.
* @param yStart First y-value.
* @param differentialEquation The differential equation to be solved.
* @return The points constituting the solution of the differential equation.
*/
public static ArrayList<double[]> eulerFull(
double xStart,
double xEnd,
double stepSize,
double yStart,
BiFunction<Double, Double, Double> differentialEquation) {
if (xStart >= xEnd) {
throw new IllegalArgumentException("xEnd should be greater than xStart");
}
if (stepSize <= 0) {
throw new IllegalArgumentException("stepSize should be greater than zero");
}
ArrayList<double[]> points = new ArrayList<double[]>();
double[] firstPoint = {xStart, yStart};
points.add(firstPoint);
double yCurrent = yStart;
double xCurrent = xStart;
while (xCurrent < xEnd) {
// Euler method for next step
yCurrent = eulerStep(xCurrent, stepSize, yCurrent, differentialEquation);
xCurrent += stepSize;
double[] point = {xCurrent, yCurrent};
points.add(point);
}
return points;
}
}