Add approximation assignment

Author: pmrukot

Diff for: Approximation/errors.py

@@ -0,0 +1,23 @@
+import numpy as np
+
+
+def calculate_mean_square_error(n, function_y, interpolated_y):
+    error = 0
+    for i in range(0, n):
+        error += (function_y[i] - interpolated_y[i])**2
+    error /= n
+    return error
+
+
+def calculate_max_error(n, function_y, interpolated_y):
+    max_error = 0
+    for i in range(0, n):
+        max_error = max(np.fabs(function_y[i] - interpolated_y[i]), max_error)
+    return max_error
+
+
+def print_error(N, x_len, y_values, y_interpolated, label):
+    print('{0},{1},{2},{3}'.format(label, N,
+                                   calculate_mean_square_error(x_len, y_values, y_interpolated),
+                                   calculate_max_error(x_len, y_values, y_interpolated)
+                                   ))

Diff for: Approximation/function.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+
+def fun(x):
+    return np.exp(3*np.cos(2*x))
+
+
+def fun_der(x):
+    return -6.*np.sin(2*x)*np.exp(3*np.cos(2*x))

Diff for: Approximation/main.py

@@ -0,0 +1,43 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+from errors import print_error
+from function import fun
+from polynomial_approx import polynomial_approximate
+from points import get_regular_interpolation_nodes, get_czebyshev_interpolation_nodes
+from trigonometric_approx import trigonometric_approximate
+
+if __name__ == '__main__':
+    start = -2.*np.pi
+    end = 1.*np.pi
+    N = 7
+    step = 0.05
+    function = fun
+
+    x = np.arange(start, end, step)
+    y = list(map(function, x))
+
+    x_len = len(x)
+
+    #points = get_regular_interpolation_nodes(N, function, start, end)
+    points = get_czebyshev_interpolation_nodes(N, function, start, end)
+
+    x_nodes, y_nodes = zip(*points)
+
+    polynomial = polynomial_approximate(points, N)
+    trigonometric = trigonometric_approximate(points, N)
+
+    polynomial_y = list(map(polynomial, x))
+    trigonometric_y = list(map(trigonometric, x))
+
+    print('label,N,mean_sqaure_error,max_error')
+    print_error(N, x_len, y, polynomial_y, 'polynomial')
+    print_error(N, x_len, y, trigonometric_y, 'trigonometric')
+
+    plt.plot(x, y, "b--", linewidth=1, label='function')
+    plt.plot(x, polynomial_y, "r--", linewidth=1, label='polynomial')
+    plt.plot(x, trigonometric_y, "g--", linewidth=1, label='trigonometric')
+    plt.plot(x_nodes, y_nodes, 'yo')
+    plt.legend(loc='upper left', prop={'size': 8})
+    plt.grid(True)
+    plt.show()

Diff for: Approximation/points.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+
+def get_regular_interpolation_nodes(n, fun, start, end):
+    return [(x, fun(x)) for x in np.linspace(start, end, n)]
+
+
+def get_czebyshev_interpolation_nodes(n, fun, start, end):
+    points = []
+    half_length = (end - start) / 2
+    middle = start + half_length
+    for i in range(0, n):
+        x = middle + np.cos(((2 * i + 1) * np.pi) / (2 * n)) * half_length
+        y = fun(x)
+        points.append((x, y))
+    return points

Diff for: Approximation/polynomial_approx.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+
+def get_s_matrix(x, n):
+    m = n + 1
+    S = np.empty((m, m))
+
+    for i in range(m):
+        for j in range(m):
+            S[i][j] = (sum([x**(i+j) for x in x]))
+
+    return S
+
+
+def get_t_vector(points, n):
+    m = n + 1
+    t = []
+
+    for i in range(m):
+        t.append(sum([y*(x**i) for x, y in points]))
+
+    return t
+
+
+def polynomial_approximate(points, n):
+    x, y = zip(*points)
+
+    S = get_s_matrix(x, n)
+    t = get_t_vector(points, n)
+
+    A = np.linalg.solve(S, t)
+
+    def function(x_point):
+        result = 0
+        for i in range(0, n+1):
+            result += (x_point**i) * A[i]
+        return result
+
+    return function

Diff for: Approximation/trigonometric_approx.py

@@ -0,0 +1,48 @@
+import numpy as np
+
+
+def polynomial(x, i):
+    return np.cos(x * i / 2) if i % 2 == 0 else np.sin(x * (i + 1) / 2)
+
+
+def get_s_matrix(x, n):
+    m = n + 1
+    S = np.empty((m, m))
+    indxs = range(m)
+
+    for i in indxs:
+        for j in indxs:
+            S[i][j] = sum([polynomial(x[k], j) * polynomial(x[k], i) for k in range(len(x))])
+
+    return S
+
+
+def get_t_vector(points, n):
+    x, y = zip(*points)
+    m = n + 1
+    t = []
+
+    for i in range(m):
+        sum = 0
+        for j in range(len(x)):
+            sum += polynomial(x[j], i) * y[j]
+        t.append(sum)
+
+    return t
+
+
+def trigonometric_approximate(points, n):
+    x, y = zip(*points)
+
+    S = get_s_matrix(x, n)
+    t = get_t_vector(points, n)
+
+    A = np.linalg.solve(S, t)
+
+    def function(x_point):
+        result = 0
+        for i in range(0, n+1):
+            result += polynomial(x_point, i) * A[i]
+        return result
+
+    return function