# import packages
import numpy as np
import matplotlib.pyplot as plt
#from scipy.stats import linregress
from scipy.integrate import simps
#from matplotlib.patches import Polygon

# input data
x = np.array([1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 7, 7.5, 8, 8.5,9, 9.5, 10])
y = np.array([3.43, 4.94, 6.45, 9.22, 6.32, 6.11, 4.63, 8.95, 7.8, 8.35, 11.45, 14.71, 11.97, 12.46, 17.42, 17.0, 15.45, 19.15, 20.86])

# 1: fit linear
l_co = np.polyfit(x, y, 1)
l_fit = np.poly1d(l_co)

# 2: fit cubic
c_co = np.polyfit(x, y, 3)
c_fit = np.poly1d(c_co)

# 3: Find the area underneath the cubic curve
t = np.linspace(1, 10, 200)
area = simps(c_fit(t),t)
print("Area under cubic line = ",area)

# 4 & 5: Plot the data, the linear fit, and the cubic fit; Put the area on the plot

plt.scatter(x,y, label = 'Data')
plt.plot(x,l_fit(x),'r', label = 'Linear Fit')
plt.plot(t,c_fit(t),'g', label = 'Cubic Fit')
plt.xlabel('x')
plt.ylabel('y')
plt.title('Fitting the data')
plt.legend()
plt.text(0.8,16,'Area under cubic line = '+str(area))
plt.savefig('ylu_data_fitting.pdf')

# 6: Justify preferable model (linear or cubic) by BIC
def BIC(y, yhat, k, weight = 1):
    err = y - yhat
    sigma = np.std(np.real(err))
    n = len(y)
    B = n*np.log(sigma**2) + weight*k*np.log(n)
    return B
linear = BIC(y,l_fit(x),len(l_co)) # k = number of coefficients
cubic = BIC(y,c_fit(x),len(c_co))
print('BIC(linear):',linear)
print('BIC(cubic):',cubic)
if linear <= cubic:
    print('linear model is preferable')
else:
    print('cubic model is preferable')


#!/usr/bin/env python
# coding: utf-8
# # CAPM - Capital Asset Pricing Model
# Watch the video for the full overview.
# Portfolio Returns:
# ## $r_p(t) = \sum\limits_{i}^{n}w_i r_i(t)$
# Market Weights:
# ## $ w_i = \frac{MarketCap_i}{\sum_{j}^{n}{MarketCap_j}} $
# ### CAPM of a portfolio
# ## $ r_p(t) = \beta_pr_m(t) + \sum\limits_{i}^{n}w_i \alpha_i(t)$
# Model CAPM as a simple linear regression
from scipy import stats
import pandas as pd
import pandas_datareader as web
import matplotlib.pyplot as plt
import numpy as np

help(stats.linregress)
spy_etf = web.DataReader('SPY', 'yahoo')
# In[21]:
spy_etf.info()
# In[22]:
spy_etf.head()
# In[18]:
start = pd.to_datetime('2010-01-04')
end = pd.to_datetime('2017-07-18')
aapl = web.DataReader('AAPL', 'yahoo', start, end)
aapl.head()
# In[28]:
#get_ipython().run_line_magic('matplotlib', 'inline')
aapl['Close'].plot(label='AAPL', figsize=(10, 8))
spy_etf['Close'].plot(label='SPY Index')
plt.legend()
# ## Compare Cumulative Return
aapl['Cumulative'] = aapl['Close'] / aapl['Close'].iloc[0]
spy_etf['Cumulative'] = spy_etf['Close'] / spy_etf['Close'].iloc[0]
aapl['Cumulative'].plot(label='AAPL', figsize=(10, 8))
spy_etf['Cumulative'].plot(label='SPY Index')
plt.legend()
plt.title('Cumulative Return')
# ## Get Daily Return
aapl['Daily Return'] = aapl['Close'].pct_change(1)
spy_etf['Daily Return'] = spy_etf['Close'].pct_change(1)
plt.scatter(aapl['Daily Return'], spy_etf['Daily Return'], alpha=0.3)
# In[46]:
aapl['Daily Return'].hist_df(bins=100)
spy_etf['Daily Return'].hist_df(bins=100)
beta, alpha, r_value, p_value, std_err = stats.linregress(aapl['Daily Return'].iloc[1:],
                                                          spy_etf['Daily Return'].iloc[1:])
beta
# In[39]:
alpha
# In[40]:
r_value
# ## What if our stock was completely related to SP500?
spy_etf['Daily Return'].head()
noise = np.random.normal(0, 0.001, len(spy_etf['Daily Return'].iloc[1:]))
noise
# In[65]:
spy_etf['Daily Return'].iloc[1:] + noise
# In[66]:
beta, alpha, r_value, p_value, std_err = stats.linregress(spy_etf['Daily Return'].iloc[1:] + noise,
                                                          spy_etf['Daily Return'].iloc[1:])
beta
# In[68]:
alpha
# Looks like our understanding is correct!


import numpy as np
from numpy.linalg import svd
from scipy.io import loadmat
import matplotlib.pyplot as plt

def featureNormalize(X):
    """
    Normalize the dataset X

    :param X:
    :return:
    """

    mu = np.mean(X, axis=0)
    sigma = np.std(X, axis=0)

    X_normalized = (X - mu) / sigma

    return X_normalized, mu, sigma

def pca(X):
    """
    Compute eigenvectors of the covariance matrix X

    :param X:
    :return:
    """

    number_of_examples = X.shape[0]
    sigma = (1/number_of_examples) * np.dot(X.T, X)
    U, S, V = svd(sigma)

    return U, S, V

def projectData(X, U, K):
    """
    Computes the reduced data representation when projecting only onto
    the top K eigenvectors

    :param X: Dataset
    :param U: Principal components
    :param K: The desired number of dimensions to reduce
    :return:
    """

    number_of_examples = X.shape[0]
    U_reduced = U[:, :K]

    Reduced_representation = np.zeros((number_of_examples, K))

    for i in range(number_of_examples):
        for j in range(K):
            Reduced_representation[i, j] = np.dot(X[i, :], U_reduced[:, j])

    return Reduced_representation

def recoverData(Z, U, K):
    """
    Recovers an approximation of the original data when using the projected data

    :param Z: Reduced representation
    :param U: Principal components
    :param K: The desired number of dimensions to reduce
    :return:
    """

    number_of_examples = Z.shape[0]
    number_of_features = U.shape[0]

    X_recovered = np.zeros((number_of_examples, number_of_features))
    U_reduced = U[:, :K]

    for i in range(number_of_examples):
        X_recovered[i, :] = np.dot(Z[i, :], U_reduced.T)

    return X_recovered

'''
Step 0: Load the dataset.
'''

dataset = loadmat("./data/lab9data2.mat")
print(dataset.keys(), '\n')

X = dataset["X"]

'''
Step 1: Normalize the dataset X
'''

X_normalized, mu, std = featureNormalize(X)
print("Values of the first 3 normalized dataset X: \n{}\n".format(X_normalized[:3]))

'''
Step 2: Compute the principal components and the diagonal matrix
'''

U, S, _ = pca(X_normalized)

print("The principal components: \n{}\n".format(U))
print("The diagonal matrix: \n{}\n".format(S))

'''
Step 3: Project the data onto 1 dimension
'''

reduced_representation = projectData(X_normalized, U, 1)
print("Projection of the first example: {}\n".format(reduced_representation[0][0]))

'''
Step 4: Reconstruct an approximation of the data (which was reduced to 1 dimension)
'''

X_recovered = recoverData(reduced_representation, U, 1)
print("Approximation of the first example: {}\n".format(X_recovered[0, :]))

'''
Step 5: Visualizing the projections
'''

plt.scatter(X_normalized[:, 0], X_normalized[:, 1], marker="o", label="Original", facecolors="none", edgecolors="b", s=15)
plt.scatter(X_recovered[:, 0], X_recovered[:, 1], marker="o", label="Approximation", facecolors="none", edgecolors="r", s=15)
plt.title("The Normalized and Projected Data after PCA")
plt.legend()


import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
from numpy import linalg as LA

fig = plt.figure()
ax = fig.add_subplot(321, aspect='equal')
# Parallelogram
xy = np.array([[0,0], [7,2], [12,11],[5,9]])
mean = np.mean(xy, axis=0)
print('Mean', mean)
cov = np.cov(xy.T)
print('Cov::')
print(cov)
eigenvalues, eigenvectors = LA.eig(cov)
print('Eigen values', eigenvalues)
print('Eigen vectors', eigenvectors)
ax.add_patch(patches.Polygon(xy, fill=False))
plt.quiver(mean[0],mean[1],eigenvectors[0,0],eigenvectors[0,1], color=['r'],scale=5, label="eigen vector[0]")
plt.quiver(mean[0],mean[1],eigenvectors[1,0],eigenvectors[1,1], color=['g'],scale=5, label="eigen vector[1]")

ax1 = fig.add_subplot(322, aspect='equal')
# Parallelogram : Square
xy1 = np.array([[0,0], [0,3], [3,3],[3,0]])
mean1 = np.mean(xy1, axis=0)
print('Mean', mean1)
cov1 = np.cov(xy1.T)
print('Cov::')
print(cov1)
eigenvalues1, eigenvectors1 = LA.eig(cov1)
print('Eigen values', eigenvalues1)
print('Eigen vectors', eigenvectors1)
ax1.add_patch(patches.Polygon(xy1, fill=False))
ax1.quiver(mean1[0],mean1[1],eigenvectors1[0,0],eigenvectors1[0,1], color=['r'],scale=5, label="eigen vector[0]")
ax1.quiver(mean1[0],mean1[1],eigenvectors1[1,0],eigenvectors1[1,1], color=['g'],scale=5, label="eigen vector[1]")

ax2 = fig.add_subplot(323, aspect='equal')
# Parallelogram : Rectangle
xy2 = np.array([[0,0], [0,2], [4,2],[4,0]])
mean2 = np.mean(xy2, axis=0)
print('Mean', mean2)
cov2 = np.cov(xy2.T)
print('Cov::')
print(cov2)
eigenvalues2, eigenvectors2 = LA.eig(cov2)
print('Eigen values', eigenvalues2)
print('Eigen vectors', eigenvectors2)
ax2.add_patch(patches.Polygon(xy2, fill=False))
ax2.quiver(mean2[0],mean2[1],eigenvectors2[0,0],eigenvectors2[0,1], color=['r'],scale=5, label="eigen vector[0]")
ax2.quiver(mean2[0],mean2[1],eigenvectors2[1,0],eigenvectors2[1,1], color=['g'],scale=5, label="eigen vector[1]")

ax3 = fig.add_subplot(324, aspect='equal')
# Parallelogram : Rectangle
xy3 = np.array([[0,0], [-1,3], [4,3],[5,0]])
mean3 = np.mean(xy3, axis=0)
print('Mean', mean3)
cov3 = np.cov(xy3.T)
print('Cov::')
print(cov3)
eigenvalues3, eigenvectors3 = LA.eig(cov3)
print('Eigen values', eigenvalues3)
print('Eigen vectors', eigenvectors3)
ax3.add_patch(patches.Polygon(xy3, fill=False))
ax3.quiver(mean3[0],mean3[1],eigenvectors3[0,0],eigenvectors3[0,1], color=['r'],scale=5, label="eigen vector[0]")
ax3.quiver(mean3[0],mean3[1],eigenvectors3[1,0],eigenvectors3[1,1], color=['g'],scale=5, label="eigen vector[1]")

ax4 = fig.add_subplot(325, aspect='equal')
# Parallelogram
xy4 = np.array([[0,0], [1,3], [5,3],[4,0]])
mean4 = np.mean(xy4, axis=0)
print('Mean', mean4)
cov4 = np.cov(xy4.T)
print('Cov::')
print(cov4)
eigenvalues4, eigenvectors4 = LA.eig(cov4)
print('Eigen values', eigenvalues4)
print('Eigen vectors', eigenvectors4)
ax4.add_patch(patches.Polygon(xy4, fill=False))
ax4.quiver(mean4[0],mean4[1],eigenvectors4[0,0],eigenvectors4[0,1], color=['r'],scale=5, label="eigen vector[0]")
ax4.quiver(mean4[0],mean4[1],eigenvectors4[1,0],eigenvectors4[1,1], color=['g'],scale=5, label="eigen vector[1]")
plt.show()


'''
The NumPy ndarray: A Multidimensional Array Object

One of the key features of NumPy is its N-dimensional array object, or ndarray,
which is a fast, flexible container for large datasets in Python.
Arrays enable you to perform mathematical operations on whole blocks of data using similar syntax to the
equivalent operations between scalar elements.
'''

'''
Problem 2)
Generating random data using ndarray
'''

import numpy as np

data1 = np.random.randn(3) # returns a random sample
print(data1) # run the program in python terminal to see the result --- row-vector with 3 elements is produced

data2 = np.random.randn(2,4) # returns a random array with 2 rows and 4 columns each
print(data2) # run the program in python terminal to see the result --- array with 2 rows and 4 columns is produced

# performing mathematical operations on the ndarray
data3 = data2 * 5 # multiply each element by 5
print(data3)

# produces a new array wherein each "cell" of data2 is added to each other
data4 = data2 + data2
print(data4)

'''
Problem 3)
To find size of each dimension of data4 produced above and also finding the data type of the array
'''
# to get the size of each dimension of data4 we use the shape method that returns the tuple
print(data4.shape) # prints a tuple (2, 4) indicating that there are 2 dimensions with size 4 each

# to get the data type of the array we use the object dtype
print(data4.dtype) # prints float64 indicating each cell value is a floating-point value occupying 64 bits in memory


# strassens_algorithm.py

# A demonstration of Strassen's subcubic runtime matrix multiplication
# algorithm on square matrices using the divide and conquer model.

import numpy as np

def main():
    m1 = np.array([[1,2],[3,4]])
    m2 = np.array([[5,6],[7,8]])

    print("The first square matrix is: ")
    print(m1)
    print("The second square matrix is: ")
    print(m2)

    output_matrix = strassens_algorithm(m1, m2)
    expected_matrix = np.matmul(m1, m2)

    print("When taking the dot product of m1 and m2 we expected an \
output matrix of:")
    print(expected_matrix)
    print("Using Strassen's subcubic runtime matrix multiplication \
algorithm we got:")
    print(output_matrix)

def strassens_algorithm(m1, m2):
    # Base case: A matrix of shape 1x1 is solved by default
    if np.shape(m1) == (1, 1):
        return np.asscalar(m1 * m2)

    # Pre-calculate the n/2 value. We'll be using it a lot and it's the same
    # for matrix 1 and matrix 2 since they have equivalent square dimensions.
    n_over_2 = len(m1)//2

    # Divide
    # Create submatrix blocks from quadrants of m1
    # |A B|
    # |C D|
    A = m1[0:n_over_2, 0:n_over_2]
    B = m1[0:n_over_2, n_over_2:]
    C = m1[n_over_2:, 0:n_over_2]
    D = m1[n_over_2:, n_over_2:]

    # Create submatrix blocks from quadrants of m2
    # |E F|
    # |G H|
    E = m2[0:n_over_2, 0:n_over_2]
    F = m2[0:n_over_2, n_over_2:]
    G = m2[n_over_2:, 0:n_over_2]
    H = m2[n_over_2:, n_over_2:]

    # Conquer
    # Calculate the 7 products: (elements matrix 1) * (elements matrix 2)
    p1 = strassens_algorithm(A, F-H)        # p1 = A * (F - H)
    p2 = strassens_algorithm(A+B, H)        # p2 = (A + B) * H
    p3 = strassens_algorithm(C+D, E)        # p3 = (C + D) * E
    p4 = strassens_algorithm(D, G-E)        # p4 = D * (G - E)
    p5 = strassens_algorithm(A+D, E+H)      # p5 = (A + D) * (E + H)
    p6 = strassens_algorithm(B-D, G+H)      # p6 = (B - D) * (G + H)
    p7 = strassens_algorithm(A-C, E+F)      # p7 = (A - C) * (E + F)

    # Combine
    return np.array([[p5+p4-p2+p6, p1+p2],[p3+p4, p1+p5-p3-p7]])

if __name__ == "__main__":
    main()


#!/usr/bin/python3
# -*- coding: utf-8 -*-

## jupyter console

import numpy as np

##
data = [[1,2,3,4],[5,6,7,8]]
arr1 = np.array(data)
type(arr1)
arr1.ndim
arr1.shape
np.zeros((3,2))
np.empty((3,2,2))
np.arange(10)

##
arr1 * arr1
arr1 * 0
arr1 + 1

##
arr2 = np.arange(10)
arr2[2]
arr3 = np.array([[1,2,3],[4,5,6]])
arr3[0]
arr3[0][1]

##
arr2[:3]
arr2[:-3]
arr3[1:, :2]

##
arr3 < 5
arr3[arr3 < 5]

##
arr4 = np.empty((8,4))
for i in range(8):
    arr4[i] = i
arr4

##
arr5 = np.arange(32).reshape((8,4))
arr5

##
arr5.shape
arr6 = arr5.T
arr6.shape

##
arr7 = np.random.randn(6, 3)
arr7
np.dot(arr7.T, arr7)

##
arr8 = np.arange(16).reshape((2,2,4))
arr8
arr8.transpose((2, 1, 0))

##
arr9 = np.arange(1, 17)
arr9
np.sqrt(arr9)
np.exp(arr9)

## 用数组表达式代替循环: 矢量化
arr10 = np.arange(-5, 5, 0.01)
xs, ys = np.meshgrid(arr10, arr10)
ys
z = np.sqrt(xs ** 2 + ys ** 2)
z

## broadcast
arr11 = np.arange(12).reshape((3,4))
arr11
arr11[0]
arr11 - arr11[0]


import numpy as np
import pandas as pd
import numpy as np
from scipy.constants import G
import random

random.seed(0)

def newton_equation(m1=1, m2=1, r=1, G=G):
    """
    Newton´s Equation
    :param m1: Mass first body in kg
    :param m2: Mass second body in kg
    :param r: Distance between m1 and m2 in meters
    :param G: Gravitational constant
    :return: Newtons equation in the Internation System of Units
    """
    return G * m1 * m2 * (1 / r ** 2)

def movement_equation(x0=1, v=1, a=1, t=1):
    return x0 + v * t + 0.5 * a * t * t

def make_newton(
    samples=100,
    m1_min=0.001,
    m1_max=1,
    m2_min=0.001,
    m2_max=1,
    r_min=1,
    r_max=10,
    G=G,
    dataframe=True,
):
    """
    Creates a sample of data of the Newton Equation
    :param samples: Number of samples
    :param m1_min: Minimum value in the range of the mass of the first body
    :param m1_max: Maximum value in the range of the mass of the first body
    :param m2_min: Minimum value in the range of the mass of the second body
    :param m2_max: Maximum value in the range of the mass of the second body
    :param r_min: Minimum value of the distance between the bodies
    :param r_max: Maximum value of the distance between the bodies
    :param dataframe: wether it returns a dataframe or an array
    :return: data sample
    """
    data = []
    for n in range(samples):
        m1 = (m1_max - m1_min) * np.random.random() + m1_min
        m2 = (m2_max - m2_min) * np.random.random() + m2_min
        r = (r_max - r_min) * np.random.random() + r_min

        data.append([m1, m2, r, newton_equation(m1=m1, m2=m2, r=r, G=G)])
    if dataframe:
        return pd.DataFrame(data=data, columns=["m1", "m2", "r", "f"])
    else:
        return data

def make_movement_data(
    samples=100,
    x0_min=1,
    x0_max=2,
    v_min=1,
    v_max=2,
    a_min=1,
    a_max=2,
    t_min=1,
    t_max=2,
    dataframe=True,
):
    data = []
    for n in range(samples):
        x0 = (x0_max - x0_min) * np.random.random() + x0_min
        v = (v_max - v_min) * np.random.random() + v_min
        a = (a_max - a_min) * np.random.random() + a_min
        t = (t_max - t_min) * np.random.random() + t_min

        data.append([x0, v, a, t, movement_equation(x0=x0, v=v, a=a, t=t)])
    if dataframe:
        return pd.DataFrame(data=data, columns=["x0", "v", "a", "t", "pos"])
    else:
        return data


import numpy as np

'''
    This python code calculates the Min-Max Normalization

    Min-max normalization is one of the most common ways to normalize data.
    For every feature, the minimum value of that feature gets transformed into a 0,
    the maximum value gets transformed into a 1, and every other value
    gets transformed into a decimal between 0 and 1.

    norm = [(x - X.min)/(X.max - X.min)]*(new_max - new_min) + new_min

'''

def minmax_norm(X, npmin, diff, nmax, nmin):
    return ( (X - npmin) / (diff) ) * (nmax-nmin) + nmin

# Input the data array
data = [ 13, 15, 16, 16, 19, 20, 20, 21, 22, 22,
         25, 25, 25, 25, 30, 33, 33, 35, 35, 35,
         35, 36, 40, 45, 46, 52, 70]

# Setting the new min and new max
nmin = 0
nmax = 1

# Putting the data in new numpy array
nparray = np.array(data)

#------------- Normalizing the data --------------------------#
# Difference between max nparray value and min nparray value
diff = nparray.max() - nparray.min()
npmin = nparray.min()

ndata = minmax_norm(nparray, npmin, diff, nmax, nmin)

print(ndata)

# Getting the norm of 35
nvalue = minmax_norm(35, npmin, diff, nmax, nmin)
print(np.round(nvalue, 2))


# -*- coding: utf-8 -*-

'''
Un-documented code (booo!) for trial documentation-sprint.
'''

import numpy as np

def quadratic_formula(a,b,c):
        """Calculates the real roots for ax^2+bx+c=0

        :param a: quadratic coefficient
        :type a: float, optional
        :param b: linear coefficient
        :type b: float, optional
        :param c: linear coefficient
        :type c: float, optional

        :raises: raises ValueError if the discriminant is less than zero
        :return: List of quadratic polynomial roots
        :rtype: list
        """
        d = b**2-4*a*c # discriminant

        if d < 0:
            raise ValueError("This equation has no real solution")
        elif d == 0:
            x = (-b+np.sqrt(b**2-4*a*c))/2*a
            sol = [x]
            return sol
        else:
            x1 = (-b+np.sqrt(b**2-4*a*c))/2*a
            x2 = (-b-np.sqrt(b**2-4*a*c))/2*a
            sol = [x1, x2]
            return sol

# simple numerical integration of f(x) over an interval x: [x_lower, x_upper] using composite trapezoid rule.

def simple_integrate(f, x):
    """Computes the definite integral of a function from the lower to the upper limit using composite trapezoid rule.

    :param f: function to be integrated.
    :param x:  [x_lower, x_upper] lower limit of integration upper limit of integration
    :raises: raises ValueError if the discriminant is less than zero
    :return: integral value
    :rtype: float
    """
    int_sum = 0

    for i in range(x.size-1):
        int_sum += 0.5*(x[i+1] - x[i])*(f[i] + f[i+1])

    return int_sum

# function for nth Fibonacci number

def fibonacci(n):
    """Computes the nth fibonacci number, starting at 0.

    :param n: the index of the Fibonacci number to be computed
    :raises: raises ValueError if n is less than 1
    :return: nth fibonacci number
    :rtype: int
    """
    if n<=0:
        raise ValueError("Input cannot be less than 1")
    elif n==1:
        return 0
    elif n==2:
        return 1
    else:
        return fibonacci(n-1)+fibonacci(n-2)

# convert time in seconds to hours, minutes and seconds

def get_hms(t_sec):
    """Converts time in seconds to hours, minutes, and seconds.

    :param t_sec: time in seconds
    :return: time in hours, minutes, and seconds
    :rtype: list
    """

    h = t_sec//3600

    m = (t_sec - h*3600)//60

    s = t_sec%60

    return h,m,s #question: does it return a list? Or maybe not?


import numpy as np

def R(theta):
    """
        Returns the rotation matrix for rotating an object
        centered around the origin with a given angle

        Arguments:
            theta: angle in degrees

        Returns:
            R: 2x2 np.ndarray with rotation matrix
    """
    theta = np.radians(theta)
    return np.array(
        [[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]
    )

def M(axis="x"):
    """
        Returns a matrix to mirror an object against a given axis

        Arguments:
            axis: str. 'x', 'y', 'origin' or 'xy'

        Returns:
            M: mirror matrix
    """
    if axis == "x":
        return np.array([[1, 0], [0, -1]])
    elif axis == "y":
        return np.array([[-1, 0], [0, 1]])
    elif axis == "origin":
        return np.array([[-1, 0], [0, -1]])
    elif axis == "xy":
        return np.array([[0, 1], [1, 0]])
    else:
        raise NotImplementedError(
            f"Could not recognize axis of mirroring: {axis}"
        )

def cart2pol(x, y):
    """
        Cartesian to polar coordinates

        angles in degrees
    """
    rho = np.hypot(x, y)
    phi = np.degrees(np.arctan2(y, x))
    return rho, phi

def pol2cart(rho, phi):
    """
        Polar to cartesian coordinates

        angles in degrees
    """
    x = rho * np.cos(np.radians(phi))
    y = rho * np.sin(np.radians(phi))
    return x, y


"""
author: Fabian Schaipp
"""

import numpy as np

class f_rosenbrock:
    """
    Nonsmooth Rosenbrock function (see 5.1 in Curtis, Overton "SQP FOR NONSMOOTH CONSTRAINED OPTIMIZATION")

    x -> w|x_1^2 − x_2| + (1 − x_1)^2
    """
    def __init__(self, w = 8):
        self.name = 'rosenbrock'
        self.dim = 2
        self.dimOut = 1
        self.w = w

    def eval(self, x):
        return self.w*np.abs(x[0]**2-x[1]) + (1-x[0])**2

    def differentiable(self, x):
        return np.abs(x[0]**2 - x[1]) > 1e-10

    def grad(self, x):
        a = np.array([-2+x[0], 0])
        sign = np.sign(x[0]**2 -x[1])

        if sign == 1:
            b = np.array([2*x[0], -1])
        elif sign == -1:
            b = np.array([-2*x[0], 1])
        else:
            b = np.array([-2*x[0], 1])

        #b = np.sign(x[0]**2 -x[1]) * np.array([2*x[0], -1])
        return a + b

class g_max:
    """
    maximum function (see 5.1 in Curtis, Overton "SQP FOR NONSMOOTH CONSTRAINED OPTIMIZATION")

    x -> max(c1*x_1, c2*x_2) - 1
    """
    def __init__(self, c1 = np.sqrt(2), c2 = 2.):
        self.name = 'max'
        self.c1 = c1
        self.c2 = c2
        self.dimOut = 1
        return

    def eval(self, x):
        return np.maximum(self.c1*x[0], self.c2*x[1]) - 1

    def differentiable(self, x):
        return np.abs(self.c1*x[0] -self.c2*x[1]) > 1e-10

    def grad(self, x):

        sign = np.sign(self.c1*x[0] - self.c2*x[1])
        if sign == 1:
            g = np.array([self.c1, 0])
        elif sign == -1:
            g = np.array([0, self.c2])
        else:
            g = np.array([0, self.c2])
        return g

class g_linear:
    """
    linear constraint:

    x -> Ax - b
    """
    def __init__(self, A, b):
        self.name = 'linear'
        self.A = A
        self.b = b
        self.dim = A.shape[0]
        self.dimOut = A.shape[1]
        return

    def eval(self, x):
        return self.A @ x - self.b

    def differentiable(self, x):
        return True

    def grad(self, x):
        return self.A


import numpy as np
def LM(f,a,b,n):
    # Carries out the numerical integration using the Left Hand Rule
    # INPUT: f , a , b , n
    # f : function which is the integrand
    # a : lower limit of the interval
    # b : upper limit of the interval
    # n : number of sub-intervals

    # makes sure the input format is correct
    if (b < a) :
        print('Input Error: Lower limit(a) must be < Upper limit(b)')
        exit()
    # limits the maximum number of iterations to 1 million
    if (n > 1000000) :
        print('Input Error: No more than 1 million divisions are allowed!')
        exit()
    # calculate the step size or length of each sub-interval
    h = (b - a)/n
    #step.append(h)
    # calculates the numerical integration using Left Hand Rule
    area = 0
    for i in range(n):
        x = a + float(i*h)
        area = area + f(x)*h
    # calculates error
    err = 1 - area
    rel_err = np.abs(err)*100
    #abs_err.append(np.abs(err))
    print('---------------------------------------------------')
    print('NUMERICAL QUADRATURE RESULTS : LEFT-ENDPOINT METHOD')
    print('---------------------------------------------------')
    print('Integrating from %8.2f    to %8.2f   in %5d steps' %(a,b,n))
    print('Area           = %10.4f units\u00b2'%(area))
    print('Error          = %10.4f'%err)
    print('Absolute Error = %10.4f '%(np.abs(err)))
    print('Relative Error = %10.4f'%rel_err)
    print('---------------------------------------------------')
    return h,np.abs(err)
def RM(f,a,b,n):
    # Carries out the numerical integration using the Right Hand Rule
    # INPUT: f , a , b , n
    # f : function which is the integrand
    # a : lower limit of the interval
    # b : upper limit of the interval
    # n : number of sub-intervals

    # makes sure the input format is correct
    if (b < a) :
        print('Input Error: Lower limit(a) must be < Upper limit(b)')
        exit()
    # limits the maximum number of iterations to 1 million
    if (n > 1000000) :
        print('Input Error: No more than 1 million divisions are allowed!')
        exit()
    # calculate the step size or length of each sub-interval
    h = (b - a)/n
    #step.append(h)
    # calculates the numerical integration using Right Hand Rule
    area = 0
    for i in range(1,n+1):
        x = a + float(i*h)
        area = area + f(x)*h
    # calculates error
    err = 1 - area
    rel_err = np.abs(err)*100
    #abs_err.append(np.abs(err))
    print('---------------------------------------------------')
    print('NUMERICAL QUADRATURE RESULTS : RIGHT-ENDPOINT METHOD')
    print('---------------------------------------------------')
    print('Integrating from %8.2f    to %8.2f   in %5d steps' %(a,b,n))
    print('Area           = %10.4f units\u00b2'%(area))
    print('Error          = %10.4f'%err)
    print('Absolute Error = %10.4f '%(np.abs(err)))
    print('Relative Error = %10.4f'%rel_err)
    print('---------------------------------------------------')
    return h,np.abs(err)
def MpM(f,a,b,n):
    # Carries out the numerical integration using the Midpoint Rule
    # INPUT: f , a , b , n
    # f : function which is the integrand
    # a : lower limit of the interval
    # b : upper limit of the interval
    # n : number of sub-intervals

    # makes sure the input format is correct
    if (b < a) :
        print('Input Error: Lower limit(a) must be < Upper limit(b)')
        exit()
    # limits the maximum number of iterations to 1 million
    if (n > 1000000) :
        print('Input Error: No more than 1 million divisions are allowed!')
        exit()
    # calculate the step size or length of each sub-interval
    h = (b - a)/n
    #step.append(h)
    # calculates the numerical integration using Midpoint Rule
    area = 0
    for i in range(n):
        x = a + float((i+0.5)*h)
        area = area + f(x)*h
    # calculates error
    err = 1 - area
    rel_err = np.abs(err)*100
    #abs_err.append(np.abs(err))
    print('---------------------------------------------------')
    print('NUMERICAL QUADRATURE RESULTS : MIDPOINT METHOD')
    print('---------------------------------------------------')
    print('Integrating from %8.2f    to %8.2f   in %5d steps' %(a,b,n))
    print('Area           = %10.4f units\u00b2'%(area))
    print('Error          = %10.4f'%err)
    print('Absolute Error = %10.4f '%(np.abs(err)))
    print('Relative Error = %10.4f'%rel_err)
    print('---------------------------------------------------')
    return h,np.abs(err)
def TM(f,a,b,n):
    # Carries out the numerical integration using the Trapezoidal Rule
    # INPUT: f , a , b , n
    # f : function which is the integrand
    # a : lower limit of the interval
    # b : upper limit of the interval
    # n : number of sub-intervals

    # makes sure the input format is correct
    if (b < a) :
        print('Input Error: Lower limit(a) must be < Upper limit(b)')
        exit()
    # limits the maximum number of iterations to 1 million
    if (n > 1000000) :
        print('Input Error: No more than 1 million divisions are allowed!')
        exit()
    # calculate the step size or length of each sub-interval
    h = (b - a)/n
    #step.append(h)
    # calculates the numerical integration using Trapezoidal Rule
    area = f(float(a))*h/2
    for i in range(1,n):
        x = a + float(i*h)
        area = area + f(x)*h
    area = area + f(float(b))*h/2
    # calculates error
    err = 1 - area
    rel_err = np.abs(err)*100
    #abs_err.append(np.abs(err))
    print('---------------------------------------------------')
    print('NUMERICAL QUADRATURE RESULTS : TRAPEZOID METHOD')
    print('---------------------------------------------------')
    print('Integrating from %8.2f    to %8.2f   in %5d steps' %(a,b,n))
    print('Area           = %10.4f units\u00b2'%(area))
    print('Error          = %10.4f'%err)
    print('Absolute Error = %10.4f '%(np.abs(err)))
    print('Relative Error = %10.4f'%rel_err)
    print('---------------------------------------------------')
    return h,np.abs(err)


from sympy import *

x, y, a, b = symbols('x y a b')
all_symbols = [a,b]

target_value = y
model_function = a*x + b
obs_eq = Matrix([target_value - model_function]).vec()
obs_eq_jacobian = obs_eq.jacobian(all_symbols)

print(model_function)
print(obs_eq)
print(obs_eq_jacobian)
print(latex(model_function))
print(latex(obs_eq_jacobian))

with open("example_func_ax_plus_b_eq_y_jacobian.h",'w') as f_cpp:
    f_cpp.write("inline void example_func_ax_plus_b(double &y, double x, double a, double b)\n")
    f_cpp.write("{")
    f_cpp.write("y = %s;\n"%(ccode(model_function)))
    f_cpp.write("}")
    f_cpp.write("\n")
    f_cpp.write("inline void observation_equation_example_func_ax_plus_b_eq_y(double &delta, double x, double y, double a, double b)\n")
    f_cpp.write("{")
    f_cpp.write("delta = %s;\n"%(ccode(obs_eq[0,0])))
    f_cpp.write("}")
    f_cpp.write("\n")
    f_cpp.write("inline void observation_equation_example_func_ax_plus_b_eq_y_jacobian(Eigen::Matrix<double, 1, 2> &j, double x, double y, double a, double b)\n")
    f_cpp.write("{")
    for i in range (1):
        for j in range (2):
            f_cpp.write("j.coeffRef(%d,%d) = %s;\n"%(i,j, ccode(obs_eq_jacobian[i,j])))
    f_cpp.write("}")


# solutions.py
"""Volume I: Monte Carlo Integration
Solutions file. Written by Tanner Christensen, Jan 2016
Edited by Jessica Morrise, May 2016
"""

import numpy as np
import scipy.stats as stats
from matplotlib import pyplot as plt

def prob1(N=10000):
    """Return an estimate of the volume of the unit sphere using Monte
    Carlo Integration.

    Input:
        N (int, optional) - The number of points to sample. Defaults
            to 10000.

    """
    points = np.random.rand(3, N)
    points = points*2 - 1
    radii = np.linalg.norm(points,axis=0)
    numInSphere = np.count_nonzero(radii <= 1)
    return 8.*numInSphere/N

def prob2(f, a, b, N=10000):
    """Use Monte-Carlo integration to approximate the integral of
    1-D function f on the interval [a,b].

    Inputs:
        f (function) - Function to integrate. Should take scalar input.
        a (float) - Left-hand side of interval.
        b (float) - Right-hand side of interval.
        N (int, optional) - The number of points to sample in
            the Monte-Carlo method. Defaults to 10000.

    Returns:
        estimate (float) - The result of the Monte-Carlo algorithm.

    Example:
        >>> f = lambda x: x**2
        >>> # Integral from 0 to 1. True value is 1/3.
        >>> prob2(f, 0, 1)
        0.3333057231764805
    """
    points = np.random.rand(1,N)
    V = b-a
    points = V*points + a
    fPoints = np.apply_along_axis(f,0,points)
    return V*np.sum(fPoints)/float(N)

def prob3(f, mins, maxs, N=10000):
    """Use Monte-Carlo integration to approximate the integral of f
    on the box defined by mins and maxs.

    Inputs:
        f (function) - The function to integrate. This function should
            accept a 1-D NumPy array as input.
        mins (1-D np.ndarray) - Minimum bounds on integration.
        maxs (1-D np.ndarray) - Maximum bounds on integration.
        N (int, optional) - The number of points to sample in
            the Monte-Carlo method. Defaults to 10000.

    Returns:
        estimate (float) - The result of the Monte-Carlo algorithm.

    Example:
        >>> f = lambda x: np.hypot(x[0], x[1]) <= 1
        >>> # Integral over the square [-1,1] x [-1,1]. True value is pi.
        >>> mc_int(f, np.array([-1,-1]), np.array([1,1]))
        3.1290400000000007
    """
    if len(mins) != len(maxs):
        raise ValueError("Dimension of mins and maxs must be the same")

    # create points
    dim = len(mins)
    side_lengths = maxs-mins
    points = np.random.rand(N,dim)
    points = side_lengths*points + mins

    # calculate Volume
    V = 1
    for i in xrange(dim):
        V *= maxs[i] - mins[i]

    # apply the function f along axis=1 and sum all the results
    estimate = V*np.sum(np.apply_along_axis(f,1,points))/float(N)

    return estimate

def prob4():

    #define the joint normal distribution
    joint_normal = lambda x: 1/(2*np.pi)**(len(x)/2.)*np.exp(-x.T.dot(x)/2.)

    mins = np.array([-1.5,0,0,0])
    maxs = np.array([0.75,1,0.5,1])
    means = np.zeros(4)
    covs = np.eye(4)

    my_value = prob3(joint_normal,mins,maxs,50000)
    scipy_value, inform = stats.mvn.mvnun(mins, maxs, means, covs)
    err = np.abs(my_value - scipy_value)/abs(scipy_value) # relative error
    return my_value, scipy_value, err

def prob5(numEstimates=50):
    """Plot the error of Monte Carlo Integration.
    """

    # actual volume of the unit sphere
    actual = 4.1887902047863905

    # construct an array of values of N
    # use closer-spaced values near 50
    N = [i*1000 for i in xrange(1,51)]
    N = [50,100,500] + N
    errors = []

    for n in N:
        meanErr = 0.
        for i in xrange(numEstimates):
            I = prob1(n) # estimate the integral
            err = np.abs(I - actual)/actual # compute the relative error
            meanErr += err
        errors.append(meanErr/float(numEstimates))

    # create the plot
    plt.plot(N,errors,label='Error')
    plt.plot(N,[1./n**0.5 for n in N],'r--',label=r'$1/\sqrt{N}$')
    plt.ylim([0,max(errors)])
    plt.xlim([0,max(N)])
    plt.xlabel(r'$N$')
    plt.ylabel('Relative error')
    plt.title('Sphere volume error vs. number of points used')
    plt.legend()
    plt.show()

if __name__ == "__main__":
    print prob1()


import numpy as np
a = np.array([0, 0.5, 1.0, 1.5, 2.0])
type(a)
a[:2]  # Slicing works as for lists

# Built in methods
a.sum()
a.std()
a.cumsum()
a.max()
a.argmax()

# Careful with np.max!
np.max(2, 0)
np.max(-2, 0)  # silent fail :) second argument is the axis
np.max(0, 2)  # fail
np.maximum(-2, 0)

# Vectorized operations: operations are applied to each element
a*2
a**2
np.sqrt(a)
np.log2(a+1)

b = np.array([a, a*2])
b

b.sum(axis=0)  # sum along axis 0 ==> columns
b.sum()
b.sum(axis=1)

eye = np.identity(4)
eye

np.ones_like(eye)
np.ones((2,3))

zeros = np.zeros((2,3,4))
zeros.shape
zeros[1]

# Optimized for speed!
import time
start = time.time()
acc = 0
for i in range(1000):
    for j in range(1000):
        acc += np.random.standard_normal()
end = time.time()
print("It took (ms): ", (end-start)*1000)

# Numpy outsources the loops to underlying C code for performance
# %timeit test = np.random.standard_normal((1000,1000)).sum()

# CODE VECTORIZATION
r = np.random.standard_normal((4,3))
s = np.random.standard_normal((4,3))
r+s

# Broadcasting
2*r+3 # same as 2*r+3*np.ones_like(r)

########################################
########################################
######## MOVE TO BROWSER HERE
########################################
########################################

# Functions are applied element-wise.
def f(x):
    return 3*x+5

f(3)
f(r)

import math
math.sin(math.pi)
math.sin(r)  # Error: this function only takes real numbers!
np.sin(r)
type(np.sin)  # ufunc: universal function (works with arrays too)


import numpy as np

from utils_2nd_version import inc_index, dec_index, \
                              constraint_inequalities_funcs_generator

def gradient_approximation(f,x,h=1e-8):
    '''
    Numerical approximation of gradient for function f using forward differences.
    Args:
        f (lambda expression): definition of function f.
        x (array): numpy array that holds values where gradient will be computed.
        h (float): step size for forward differences, tipically h=1e-8
    Returns:
        gf (array): numerical approximation to gradient of f.
    '''
    n = x.size
    gf = np.zeros(n)
    f_x = f(x)
    for i in np.arange(n):
        inc_index(x,i,h)
        gf[i] = f(x) - f_x
        dec_index(x,i,h)
    return gf/h
def Hessian_approximation(f,x,h=1e-6):
    '''
    Numerical approximation of Hessian for function f using forward differences.
    Args:
        f (lambda expression): definition of function f.
        x (array): numpy array that holds values where Hessian will be computed.
        h (float): step size for forward differences, tipically h=1e-6
    Returns:
        Hf (array): numerical approximation to Hessian of f.
    '''
    n = x.size
    Hf = np.zeros((n,n))
    f_x = f(x)
    for i in np.arange(n):
        inc_index(x,i,h)
        f_x_inc_in_i = f(x)
        for j in np.arange(i,n):
            inc_index(x,j,h)
            f_x_inc_in_i_j = f(x)
            dec_index(x,i,h)
            f_x_inc_in_j = f(x)
            dif = f_x_inc_in_i_j-f_x_inc_in_i-f_x_inc_in_j+f_x
            Hf[i,j] = dif
            if j != i:
                Hf[j,i] = dif
            dec_index(x,j,h)
            inc_index(x,i,h)
        dec_index(x,i,h)
    return Hf/h**2
def numerical_differentiation_of_logarithmic_barrier(f, x, t_path, constraint_inequalities,
                                                     infeasible = None):
    '''
    First and second derivative of logarithmic barrier function approximation
    via finite differences
    '''
    sum_gf_const = 0
    sum_Hf_const = 0
    for const in constraint_inequalities_funcs_generator(constraint_inequalities):
        const_eval = const(x)
        gf_const_eval = gradient_approximation(const, x)
        Hf_const_eval = Hessian_approximation(const, x)
        sum_gf_const += gf_const_eval/(-const_eval) if not infeasible else \
                        gf_const_eval/(infeasible - const_eval)
        if not infeasible:
            sum_Hf_const += np.outer(gf_const_eval,gf_const_eval)/const_eval**2 - Hf_const_eval/const_eval
        else:
            sum_Hf_const += np.outer(gf_const_eval,gf_const_eval)/(infeasible - const_eval)**2 + \
                            Hf_const_eval/(infeasible - const_eval)
    gf_eval = gradient_approximation(f,x)
    Hf_eval = Hessian_approximation(f,x)
    return {'gradient': t_path*gf_eval + sum_gf_const,
            'Hessian': t_path*Hf_eval + sum_Hf_const
           }


import sympy
from typing import Tuple

def sym_skew(vec: sympy.Matrix) -> sympy.Matrix:
    vec = vec.reshape(1, 3)
    return sympy.Matrix([
        [0, -vec[2], vec[1]],
        [vec[2], 0, -vec[0]],
        [-vec[1], vec[0], 0]
    ])

def sym_vex(skewmat: sympy.Matrix) -> sympy.Matrix:
    return sympy.Matrix([skewmat[2, 1], skewmat[0, 2], skewmat[1, 0]])

def sym_no_rot() -> sympy.Matrix:
    return sympy.Matrix([
        [1, 0, 0],
        [0, 1, 0],
        [0, 0, 1]
    ])

def sym_hom_no_rot() -> sympy.Matrix:
    return sympy.Matrix([
        [1, 0, 0, 0],
        [0, 1, 0, 0],
        [0, 0, 1, 0],
        [0, 0, 0, 1]
    ])

def sym_rot(axis: sympy.Matrix, angle: sympy.NumberSymbol) -> sympy.Matrix:
    if axis.shape != (1, 3) and axis.shape != (3, 1):
        return sympy.Matrix([
        [1, 0, 0],
        [0, 1, 0],
        [0, 0, 1]
    ])
    axis = axis.reshape(3, 1)
    axis = sympy.simplify(axis.normalized())
    c = sympy.cos(angle)
    s = sympy.sin(angle)
    axis2 = sympy.simplify(axis * axis.T)
    axis = axis.reshape(1, 3)
    skewaxis = sympy.Matrix([
        [0, -axis[2], axis[1]],
        [axis[2], 0, -axis[0]],
        [-axis[1], axis[0], 0]
    ])
    return sympy.simplify(axis2 + (sympy.Matrix([
        [1, 0, 0],
        [0, 1, 0],
        [0, 0, 1]
    ]) - axis2) * c + skewaxis * s)

def sym_rotx(angle: sympy.NumberSymbol) -> sympy.Matrix:
    c = sympy.cos(angle)
    s = sympy.sin(angle)
    return sympy.Matrix([
        [1, 0, 0],
        [0, c, -s],
        [0, s, c]
    ])

def sym_roty(angle: sympy.NumberSymbol) -> sympy.Matrix:
    c = sympy.cos(angle)
    s = sympy.sin(angle)
    return sympy.Matrix([
        [c, 0, s],
        [0, 1, 0],
        [-s, 0, c]
    ])

def sym_rotz(angle: sympy.NumberSymbol) -> sympy.Matrix:
    c = sympy.cos(angle)
    s = sympy.sin(angle)
    return sympy.Matrix([
        [c, -s, 0],
        [s, c, 0],
        [0, 0, 1]
    ])

def sym_rot_eulzxz(anglez: sympy.NumberSymbol, anglex: sympy.NumberSymbol, anglez1: sympy.NumberSymbol) \
    -> sympy.Matrix:
    cz = sympy.cos(anglez)
    sz = sympy.sin(anglez)
    cx = sympy.cos(anglex)
    sx = sympy.sin(anglex)
    cz1 = sympy.cos(anglez1)
    sz1 = sympy.sin(anglez1)
    rotzmat = sympy.Matrix([
        [cz, -sz, 0],
        [sz, cz, 0],
        [0, 0, 1]
    ])
    rotxmat = sympy.Matrix([
        [1, 0, 0],
        [0, cx, -sx],
        [0, sx, cx]
    ])
    rotz1mat = sympy.Matrix([
        [cz1, -sz1, 0],
        [sz1, cz1, 0],
        [0, 0, 1]
    ])
    return sympy.simplify(rotzmat * rotxmat * rotz1mat)

def sym_rot_rpyxyz(anglex: sympy.NumberSymbol, angley: sympy.NumberSymbol, anglez: sympy.NumberSymbol) \
    -> sympy.Matrix:
    cx = sympy.cos(anglex)
    sx = sympy.sin(anglex)
    cy = sympy.cos(angley)
    sy = sympy.sin(angley)
    cz = sympy.cos(anglez)
    sz = sympy.sin(anglez)
    rotxmat = sympy.Matrix([
        [1, 0, 0],
        [0, cx, -sx],
        [0, sx, cx]
    ])
    rotymat = sympy.Matrix([
        [cy, 0, sy],
        [0, 1, 0],
        [-sy, 0, cy]
    ])
    rotzmat = sympy.Matrix([
        [cz, -sz, 0],
        [sz, cz, 0],
        [0, 0, 1]
    ])
    return sympy.simplify(rotzmat * rotymat * rotxmat)

def sym_rot_inv(rotmat: sympy.Matrix) -> sympy.Matrix:
    return sympy.transpose(rotmat)

def sym_hom_rotx(angle: sympy.NumberSymbol) -> sympy.Matrix:
    c = sympy.cos(angle)
    s = sympy.sin(angle)
    return sympy.Matrix([
        [1, 0, 0, 0],
        [0, c, -s, 0],
        [0, s, c, 0],
        [0, 0, 0, 1]
    ])

def sym_hom_roty(angle: sympy.NumberSymbol) -> sympy.Matrix:
    c = sympy.cos(angle)
    s = sympy.sin(angle)
    return sympy.Matrix([
        [c, 0, s, 0],
        [0, 1, 0, 0],
        [-s, 0, c, 0],
        [0, 0, 0, 1]
    ])

def sym_hom_rotz(angle: sympy.NumberSymbol) -> sympy.Matrix:
    c = sympy.cos(angle)
    s = sympy.sin(angle)
    return sympy.Matrix([
        [c, -s, 0, 0],
        [s, c, 0, 0],
        [0, 0, 1, 0],
        [0, 0, 0, 1]
    ])

def sym_hom_rot_inv(homrotmat: sympy.Matrix) -> sympy.Matrix:
    rot_inv_mat = sympy.transpose(homrotmat[0:3, 0:3])
    return sympy.Matrix([
        [rot_inv_mat[0, 0], rot_inv_mat[0, 1], rot_inv_mat[0, 2], 0],
        [rot_inv_mat[1, 0], rot_inv_mat[1, 1], rot_inv_mat[1, 2], 0],
        [rot_inv_mat[2, 0], rot_inv_mat[2, 1], rot_inv_mat[2, 2], 0],
        [0, 0, 0, 1]
    ])

def sym_no_transl() -> sympy.Matrix:
    return sympy.Matrix([[0, 0, 0]])

def sym_transl(tx: sympy.NumberSymbol, ty: sympy.NumberSymbol, tz: sympy.NumberSymbol) -> sympy.Matrix:
    return sympy.Matrix([[tx, ty, tz]])

def sym_no_coltransl() -> sympy.Matrix:
    return sympy.Matrix([0, 0, 0])

def sym_coltransl(tx: sympy.NumberSymbol, ty: sympy.NumberSymbol, tz: sympy.NumberSymbol) -> sympy.Matrix:
    return sympy.Matrix([tx, ty, tz])

def sym_transl_inv(translvec: sympy.Matrix) -> sympy.Matrix:
    return -translvec

def sym_hom_transl(tx: sympy.NumberSymbol, ty: sympy.NumberSymbol, tz: sympy.NumberSymbol) -> sympy.Matrix:
    return sympy.Matrix([
        [1, 0, 0, tx],
        [0, 1, 0, ty],
        [0, 0, 1, tz],
        [0, 0, 0, 1]
    ])

def sym_hom_transl_inv(homtranslmat: sympy.Matrix) -> sympy.Matrix:
    transl_inv_vec = -homtranslmat[0:3, 3:4]
    return sympy.Matrix([
        [1, 0, 0, transl_inv_vec[0, 0]],
        [0, 1, 0, transl_inv_vec[1, 0]],
        [0, 0, 1, transl_inv_vec[2, 0]],
        [0, 0, 0, 1]
    ])

def sym_DH_transformation(alpha: sympy.NumberSymbol, a: sympy.NumberSymbol,
                          d: sympy.NumberSymbol, theta: sympy.NumberSymbol) -> sympy.Matrix:
    calpha = sympy.cos(alpha)
    salpha = sympy.sin(alpha)
    ctheta = sympy.cos(theta)
    stheta = sympy.sin(theta)
    transf1 = sympy.Matrix([
        [ctheta, -stheta, 0, 0],
        [stheta, ctheta, 0, 0],
        [0, 0, 1, d],
        [0, 0, 0, 1]
    ])
    transf2 = sympy.Matrix([
        [1, 0, 0, a],
        [0, calpha, -salpha, 0],
        [0, salpha, calpha, 0],
        [0, 0, 0, 1]
    ])
    return sympy.simplify(transf1 * transf2)

def sym_hom(rotmat: sympy.Matrix, translvec: sympy.Matrix) -> sympy.Matrix:
    translvec = translvec.reshape(3, 1)
    return sympy.Matrix([
        [rotmat[0, 0], rotmat[0, 1], rotmat[0, 2], translvec[0, 0]],
        [rotmat[1, 0], rotmat[1, 1], rotmat[1, 2], translvec[1, 0]],
        [rotmat[2, 0], rotmat[2, 1], rotmat[2, 2], translvec[2, 0]],
        [0, 0, 0, 1]
    ])

def sym_hom_inv(hommat: sympy.Matrix) -> sympy.Matrix:
    rot_inv_mat = sympy.transpose(hommat[0:3, 0:3])
    transl_inv_vec = sympy.simplify(-rot_inv_mat * hommat[0:3, 3:4])
    return sympy.Matrix([
        [rot_inv_mat[0, 0], rot_inv_mat[0, 1], rot_inv_mat[0, 2], transl_inv_vec[0, 0]],
        [rot_inv_mat[1, 0], rot_inv_mat[1, 1], rot_inv_mat[1, 2], transl_inv_vec[1, 0]],
        [rot_inv_mat[2, 0], rot_inv_mat[2, 1], rot_inv_mat[2, 2], transl_inv_vec[2, 0]],
        [0, 0, 0, 1]
    ])

def dehom(hommat: sympy.Matrix) -> Tuple[sympy.Matrix, sympy.Matrix]:
    rotmat = sympy.Matrix([
        [hommat[0, 0], hommat[0, 1], hommat[0, 2]],
        [hommat[1, 0], hommat[1, 1], hommat[1, 2]],
        [hommat[2, 0], hommat[2, 1], hommat[2, 2]]
    ])
    translvec = sympy.Matrix([[hommat[0, 3], hommat[1, 3], hommat[2, 3]]])
    return rotmat, translvec


# Introdução à Computação Simbólica com _sympy_

## Motivação

Neste ponto do curso, você já aprendeu a realizar operações matemáticas elementares com Python. Por exemplo, se lhe for dado o valor do raio $R$, você consegue facilmente computar a área $\pi R^2$ de um círculo. Todavia, o valor de $\pi$ que você obtém é finito. As instruções abaixo verificam isto.

```python
from math import pi
print(pi)
3.141592653589793
```

Pense, no entanto, se você pudesse realizar o cálculo desta área de maneira "exata". Matematicamente falando, é impossível fazer isto pois $\pi$ é um número irracional – o imbróglio desta constante é longo na história da Matemática. Porém, a computação simbólica permite que operemos com $\pi$ como se fosse simplesmente um símbolo com precisão infinita. Embora 15 casas decimais, como o valor exemplificado acima, sejam suficientes para a maioria dos cálculos do mundo real, a computação simbólica permite que trabalhemos com modelos abstratos que servem a uma diversidade de propósitos.

Aliás, quando se diz que 3.141592653589793 é um valor razoavelmente aceitável, isto é verdade até mesmo para cálculos em escala astronômica. A equipe de engenharia da NASA explica que, usando este valor para calcular o perímetro de uma circunferência com diâmetro igual a 25 bilhões de milhas, o erro de cálculo é próximo de 1,5 polegada [[NASA]](https://www.jpl.nasa.gov/edu/news/2016/3/16/how-many-decimals-of-pi-do-we-really-need/). Até aí, nada mal para uma aproximação!

## O que é Computação Simbólica e para que serve?

*Computação Simbólica* (CS) é uma subárea de estudo da matemática e da ciência da computação que se preocupa em resolver problemas usando objetos simbólicos representáveis em um computador. Esses problemas surgem em muitas aplicações em ciências naturais, pesquisa básica, na indústria e principalmente no desenvolvimento de softwares para computação avançada denominados _sistemas de computação algébrica_ (SCAs).

A CS existente em um SCA é aplicada em álgebra computacional, projetos assistidos por computação (CAD), raciocínio automatizado, gestão do conhecimento, lógica computacional e sistemas formais de verificação. O desenvolvimento da CS depende da integração de basicamente três campos: *softwares matemáticos*, *álgebra computacional* e *lógica computacional* [[RISC/JKU]](https://risc.jku.at/studying-symbolic-computation/). Em casos mais avançados, a CS é útil para solucionar equações da macroeconomia, manipular números para a finalidade de criptografia e criar modelos probabilísticos [[Kotzé]](https://kevinkotze.github.io/mm-tut1-symbolic/), [[Cohen]](https://www.ukma.edu.ua/~yubod/teach/compalgebra/%5BJoel_S._Cohen%5D_Computer_algebra_and_symbolic_comp(BookFi.org).pdf).

## Principais SCAs

Alguns SCAs são populares de longa data, tais como Maple, Mathematica e MuPad. Entretanto, são comerciais e costumam ter licenças custosas, embora ofereçam versões com desconto para estudantes. Algumas alternativas robustas de uso livre são Scilab, Sagemath, Octave e o próprio módulo *sympy*. Uma lista completa de SCAs está disponível na [[Wikipedia]](https://en.wikipedia.org/wiki/Computer_algebra_system).

## Por que *sympy*?

O objetivo principal do *sympy* é ser uma biblioteca de manipulação simbólica para Python. Ele começou a ser desenvolvido em 2006 e atualmente está na versão 1.5.1, lançada em dezembro de 2019 na página oficial [[sympy.org]](https://www.sympy.org/pt/index.html). As principais características do módulo são as seguintes:

- é gratuito;

- é baseado inteiramente em Python;

- é leve e independente.

## Objetos numéricos x objetos simbólicos

Importaremos os módulos `math` e `sympy` para ver algumas  diferenças entre objetos numéricos e simbólicos.

import math as mt
import sympy as sy
sy.init_printing(pretty_print=True) # melhor impressão de símbolos

mt.pi # numérico

sy.pi # simbólico

Verifiquemos com `type`.

type(mt.pi)

type(sy.pi) # é um objeto simbólico

Vejamos mais um exemplo:

mt.sqrt(2)

sy.sqrt(2)

type(mt.sqrt(2))

type(sy.sqrt(2)) # é um objeto simbólico

### Função x método

Na aula anterior destacamos que `print` e `type` são "funções" similares àquelas do tipo $y = f(x)$ em Matemática. Em Python, essas "funções" recebem o nome de *função* mesmo.

Porém, há módulos que possuem *métodos*, que para seu entendimento, podem ser vistos como "funções" também. Porém, *função* e *método* são conceitos levemenete distintos.

Para aplicarmos funções usamos parênteses envolvendo um ou mais *parâmetros*.

No caso acima, `mt.sqrt(2)` mostra que `sqrt` age como uma função e o número 2 é seu único parâmetro. Note, além disso, que o sympy também possui a sua própria função `sqrt`, que é de uma natureza distinta. Ela é um objeto `sympy.core.power.Pow`. Não precisamos entender isso agora, mas basta saber que ela pertence a um submódulo do *sympy*.

Por outro lado, também aprendemos que o conjugado de um número complexo `z` (tipo `complex`) pode ser obtido como `z.conjugate()`. Esta forma "sem parâmetros" indica que `conjugate` é um método do objeto `z`.

A partir deste ponto, poderemos ver situações como as seguintes:

- `f(x)`: a função `f` é aplicada ao parâmetro `x`

- `a.f()`: `f` é um método sem parâmetro do objeto `a`

- `a.f(x)`: `f` é um método com parâmetro `x` do objeto `a`

A partir do último exemplo, podemos dizer que um método é, na verdade, uma função que pertence a um objeto.

### Atribuições com símbolos

Podemos atribuir símbolos a variáveis usando a função `symbols`.

x = sy.symbols('x')
y = sy.symbols('y')

`x` e `y` são símbolos sem valor definido.

x

y

Podemos operar aritmeticamente com símbolos e obter uma expressão simbólica como resultado.

z = sy.symbols('z')
x*y + z**2/3 + sy.sqrt(x*y - z)

**Exemplo**: escreva o produto notável $(x - y)^2$ como uma expressão simbólica.

x**2 - 2*x*y + y**2

Note que o nome da variável não tem a ver com o nome do símbolo. Poderíamos fazer o seguinte:

y = sy.symbols('x') # y é variável; x é símbolo
y

### Atribuição por desempacotamento

Também poderíamos realizar as atribuições anteriores da seguinte forma:

x, y, z = sy.symbols('x y z')

### Alfabeto de símbolos

O *sympy* dispõe de um submódulo chamado `abc` do qual podemos importar símbolos para letras latinas (maiúsculas e minúsculas) e gregas (minúsculas).

from sympy.abc import a,b,c,alpha,beta,gamma
(a + 2*b - 3*c)*(alpha/3 + beta/2 - gamma) # símbolico

from sympy.abc import D,G,psi,theta
D**a * G**b * psi**c * theta**2 # símbolico

**Nota**: algumas letras já são usadas como símbolos especiais, tais como `O`, que indica "ordem" e `I`, que é o complexo $i$. Neste caso, cuidado deve ser tomado com nomes de variáveis

sy.I # imaginário simbólico

type(sy.I)

### Símbolos com nomes genéricos

Para criar símbolos genéricos, temos de usar `symbols` ou `Symbol`.

sem_nocao = sy.symbols('nada')
sem_nocao

muito_louco = sy.Symbol('massa')
muito_louco

### Variáveis e símbolos

sem_medo = sem_nocao + 2
sem_medo

soma = muito_louco + 2
muito_louco = 3 # 'muito_louco' aqui não é o simbólico
soma

## Substituição

A operação de *substituição* permite que:

1. substituamos variáveis por valores numéricos para avaliar uma expressão ou calcular valores de uma função em um dado ponto.
2. substituamos uma subexpressão por outra.

Para tanto, procedemos da seguinte forma:

```python
expressao.subs(variavel,valor)
```

**Exemplo**: considere o polinômio $P(x) = 2x^3 - 4x -6$. Calcule o valor de $P(-1)$, $P(e/3)$, $P(\sqrt{3.2})$.

from sympy.abc import x
P = 2*x**3 - 4*x - 6
P1 = P.subs(x,-1)
Pe3 = P.subs(x,mt.e/3)
P32 = P.subs(x,mt.sqrt(3.2))
print(P1, Pe3, P32)

**Exemplo:** sejam $f(x) = 4^x$ e $g(x) = 2x - 1$. Compute o valor da função composta $f(g(x))$ em $x = 3$.

f = 4**x
fg = f.subs(x,2*x - 1)

fg.subs(x,3)

Poderíamos também fazer isso com um estilo "Pythônico":

fg = 4**x.subs(x,2*x - 1).subs(x,3)
fg

**Exemplo:** se $a(x) = 2^x$, $b(x) = 6^x$ e $c(x) = \cos(x)$, compute o valor de $a(x)b(c(x))$ em $x = 4$

a = 2**x
b = 6**x
c = sy.cos(x)
(a * b.subs(x,c)).subs(x,4)

Ou, de modo direto:

valor = ( 2**x * ( 6**x.subs(x,sy.cos(x))) ).subs(x,4)
valor

### Avaliação de expressão em ponto flutuante

Note que a expressão anterior não foi computada em valor numérico. Para obter seu valor numérico, podemos usar o método `evalf`.

valor.evalf()

#### Precisão arbitrária

`evalf` permite que escolhamos a precisão do cálculo impondo o número de dígitos de precisão. Por exemplo, a última expressão com 20 dígitos de precisão seria:

valor.evalf(20)

Com 55, seria:

valor.evalf(55)

E com 90 seria:

valor.evalf(90)

**Exemplo**: calcule o valor de $e$ com 200 dígitos de precisão.

sy.exp(1).evalf(200)

## Funções predefinidas x funções regulares

Vamos apresentar aqui três grupos de funções que podem ser criadas em Python para nos auxiliar ao longo do curso sem, no entanto, nos aprofundaremos nos detalhes de cada um.

Como dissemos em um momento anterior, a linguagem Python possui um *core* que contém um conjunto de funções já prontas que podemos usar, como é o caso de `print()`, `type()` e até mesmo `int()` e `float()` para operações de *casting*. Essas funções podem ser chamadas de **predefinidas** (*built-in functions*). Ou seja, são aquelas funções "já existentes". Exemplos adicionais seriam as funções do módulo `math`.

Suponhamos, porém, que você vasculhe módulos e mais módulos atrás de uma função que faça exatamente o que você quer, mas não a encontra. O que você faz? Você a cria! Podemos fazer isto de uma maneira usando uma "palavra-chave" (*keyword*) chamada `def` da seguinte forma:

```python
def f(x):
    (...)
    return y
```
A instrução acima permite que você crie uma *função* chamada `f` da qual `x` é um *argumento* e `y` é um *valor de retorno*, indicado por uma segunda "palavra-chave", *return*. Funções definidas por você dessa maneira são chamadas de **regulares**, *normais* – pelo fato de serem programadas de um modo regular, seguindo a "normalidade" da linguagem –, ou ainda *definidas pelo usuário* (do inglês *user-defined functions*, ou simplesmente *UDF*). Por conveniência, vamos nos referir a elas por este acrônimo elegante: UDF.

Uma UDF permite que você abstraia seu pensamento para criar basicamente o que quiser dentro dos limites da linguagem Python. Cabe, apesar disso, fazermos as seguintes ressalvas:

- uma UDF **pode ter zero ou mais argumentos**, tantos quantos se queira;
- uma UDF **pode ou não ter valor de retorno**;

Vamos entender as UDFs com exemplos.

**Exemplo:** Suponha que você é um(a) analista de dados do mercado imobiliário e está estudando o impacto do repasse de comissões pagas a corretores mediante vendas de imóveis. Você, então, começa a raciocinar e cria um modelo matemático bastante simples que, antes de tudo, precisa calcular o valor do repasse a partir do preço de venda.

Se $c$ for o percentual de comissão, $V$ o valor da venda do imóvel e $r$ o valor a ser repassado para o corretor, então, a função a ser definida é

$$r(V) = c\, V,$$

assumindo que $c$ seja um valor fixo.

Digamos que $c$ corresponda a 1.03% do valor da venda do imóvel. Neste caso podemos criar uma UDF para calcular $r$ para nós da seguinte forma:

def repasse(V):
    r = 0.0103*V
    return r

Para $V = \, R\$ \, 332.130,00$:

repasse(332130)

O que é necessário observar:

- `def` vem seguido pelo *nome* da função (`repasse`) após um espaço;
- o nome precede os argumentos, enclausurados por parênteses `(V)`. Neste caso, temos apenas um *argumento*, que é `V`;
- após o nome, os dois-pontos (`:`) são obrigatórios e significam mais ou menos "o que esta função faz será definido da seguinte maneira"
- a instrução `r = 0.0103*V` é o *escopo* da função, que deve ser escrito em uma ou mais linhas indentadas (pressione `TAB` para isso, ou use 4 espaços)
- o valor de retorno, se houver, é posto na última linha do escopo.

Podemos atribuir os valores do argumento e resultado a variáveis:

V = 332130
rep = repasse(V)
rep

Nomes iguais de variável e função são permissíveis.

repasse = repasse(V) # 'repasse' à esquerda é uma variável; à direita, função
print(repasse)

Todavia, isto pode ser confuso e é bom evitar.

O estilo "Pythônico" de escrever permite que o valor de retorno não seja explicitamente declarado. No escopo

```python
...
    r = 0.0103*V
    return r
```
 a variável `r` não é necessária.

Python é inteligente para permitir o seguinte:

def repasse(V):
    return 0.0103*V

# note que aqui não indentamos a linha.
# Logo esta instrução NÃO pertence ao escopo da função.
repasse(V)

Podemos criar uma função para diferentes valores de `c` e `V` usando *dois* argumentos:

def repasse_c(c,V): # esta função tem outro nome
    return c*V

c = 0.0234 # equivaleria a uma taxa de repasse de 2.34%
V = 197432 # o valor do imóvel agora é R$ 197.432,00
repasse_c(c,V)

A ordem dos argumentos importa:

V = 0.0234 # este deveria ser o valor de c
c = 197432 # este deveria ser o valor de V
repasse_c(c,V)

Por que o valor resultante é o mesmo? Porque a operação no escopo da função é uma multiplicação, `c*V`, que é comutativa independentemente do valor das variáveis. Porém, digamos que um segundo modelo tenha uma forma de cálculo distinta para a comissão dada por

$$r_2(V) = c^{3/5} \, V$$

Neste caso:

def repasse_2(c,V):
    return c**(3/5)*V

V = 197432
c = 0.0234

repasse_2(c,V)

Porém, se trocarmos o valor das variáveis, a função `repasse_2` calculará um valor distinto. Embora exista um produto também comutativo, o expoente `3/4` modifica apenas o valor de `c`.

# variáveis com valores trocados
c = 197432
V = 0.0234

repasse_2(c,V)

A ordem com que escrevemos os argumentos tem importância relativa aos valores que passamos e ao que definimos:

# variáveis com valores corretos
V = 197432
c = 0.0234

def repasse_2_trocada(V,c): # V vem antes de c
    return c**(3/5)*V

repasse_2_trocada(V,c)

Mas,

# os valores das variáveis estão corretos,
# mas foram passados para a função na ordem errada
repasse_2_trocada(c,V)

e

# a ordem dos argumentos está de acordo com a que foi definida
# mas os valores das variáveis foram trocados
V = 197432
c = 0.0234
repasse_2_trocada(c,V)

## Modelos matemáticos simbólicos

A partir do que aprendemos, podemos definir modelos matemáticos completamente simbólicos.

from sympy.abc import c,V

def repasse_2_simbolica(c,V):
    return c**(3/5)*V

Se chamarmos esta função, ela será um objeto simbólico.

repasse_2_simbolica(c,V)

Atribuindo em variável:

rep_simb = repasse_2_simbolica(c,V)

type(rep_simb) # é um objeto simbólico

**Exemplo:** Suponha, agora, que seu modelo matemático de repasse deva considerar não apenas um percentual $c$ pré-estabelecido, mas também um valor de "bônus" adicional concedido como prêmio pela venda do imóvel. Considere, então, que o valor deste bônus seja $b$. Diante disso, nosso novo modelo teria uma fórmula como a seguinte:

$$r_3(V) = c\,V + b$$

Simbolicamente:

# importaremos apenas o símbolo b,
# uma vez que c e V já foram importados
# como símbolos anteriormente
from sympy.abc import b

def r3(V):
    return c*V + b

rep_3 = r3(V)
rep_3

### Substituindo valores

Podemos usar a função `subs` para atribuir quaisquer valores para o modelo.

**Exemplo:** $c = 0.119$

rep_3.subs(c,0.119) # substituindo para c

**Exemplo:** $c = 0.222$

rep_3.subs(c,0.222) # substituindo para c

**Exemplo:** $c = 0.222$ e $b = 12.0$

rep_3.subs(c,0.222).subs(b,12.0) # substituindo para c, depois para b

### Substituição múltipla

O modo anterior de substituição não é "Pythônico". Para substituirmos mais de uma variável de uma vez, devemos usar *pares ordenados* separados por vírgula sequenciados entre colchetes como uma *lista*. Mais tarde, aprenderemos sobre pares ordenados e listas.

**Exemplo:** Modifique o modelo $r_3$ para que $c = 0.043$ e $b = 54.0$

# espaços foram adicionados para dar legibilidade
rep_3.subs( [ (c,0.043), (b,54.0) ] )

#### Pares ordenados

Em matemática, o conceito de par ordenado pode ser definido pelo conjunto:

$$ X \times Y = \{ (x,y) ; x \in X \text{ e } y \in Y \},$$

onde $X$ e $Y$ são conjuntos quaisquer e $x$ e $y$ são as *coordenadas*. Por exemplo, se $X = Y = \mathbb{R}$, o conjunto acima contém elementos do tipo $(3,2)$, $(-1,3)$, $(\pi,2.18)$ etc. Na verdade, eles formam o conjunto $\mathbb{R} \times \mathbb{R} = \mathbb{R}^2$, que é exatamente o *plano cartesiano*.

Logo, a substituição múltipla com `subs` ocorre da seguinte forma;

- a primeira coordenada é o *símbolo*;

- a segunda coordenada é o *valor* que você quer dar para o símbolo.

**Exemplo:** Calcule $r_3(V)$ considerando $c = 0.021$, $b = 34.0$ e $V = 432.000$.

# armazenaremos o valor na variável 'valor'
valor = r3(V)

# subsituição
valor.subs( [ (c,0.021), (b,54.0) ] )

Com o estilo "Pythônico":

valor = r3(V).subs( [ (c,0.021), (b,54.0) ] ) #
valor

Podemos seguir esta regra de pares para substituir todos os valores de um modelo simbólico genérico não necessariamente definido através de uma função. Veja o exemplo aplicado a seguir.

## Exemplo de aplicação: o índice de caminhabilidade

Estudos empíricos nos EUA mostraram que a *caminhabilidade* de uma vizinhança impacta substancialmente os preços das casas. A caminhabilidade está relacionada à distância da moradia a locais de amenidades, tais como restaurantes, bares, bibliotecas, mercearias etc.

O *índice de caminhabilidade* $W$ para uma vizinhança de casas é uma medida matemática que assume valores no intervalo $[0,1]$. A fórmula é definida por:

$$W(d) = e^{-5 \left( \dfrac{d}{M} \right)^5},$$

onde $d$ é a distância medida entre a vizinhança (0 metro) e um dado ponto de referência, e $M$ é a distância máxima de avaliação considerada a partir da qual a caminhabilidade é assumida como nula. Ou seja,

- quando estamos na vizinhança, $d = 0$, $W = 1$ e a caminhabilidade é considerada ótima.

- à medida que nos afastamos da vizinhança em direção ao local da amenidade, $d$ aumenta e o valor $W$ decai vertiginosamente até atingir o valor limite $M$ a partir do qual $W = 0$ e a caminhabilidade é considerada "péssima".

O índice de caminhabilidade é, portanto, calculado com relação a um ponto de destino definido e a distância deve levar em consideração as vias de circulação (ruas, rodovias etc) e não a distância mais curta (raio do perímetro). Por exemplo, se a distância máxima a ser considerada para a caminhabilidade for $M = 500 \, m$ , um bar localizado a 100 metros da vizinhança teria um índice de caminhabilidade maior do que o de uma farmácia localizada a 300 m e muito maior do que o de um shopping localizado a 800 m, ainda que muito famoso. Aliás, neste caso, o valor de $W$ para o shopping seria zero, já que 800 m está além do limite $M$ estabelecido.

Fonte: *De Nadai, M. and Lepri, B. [[The economic value of neighborhoods: Predicting real estate prices from the urban environment]](https://arxiv.org/pdf/1808.02547.pdf)*.

### Modelo simbólico

Podemos modelar $W$ simbolicamente e calcular seu valor para diferentes valores de $d$ e $M$ usando a substituição múltipla.

from sympy.abc import d,M,W

W = sy.exp(-5*(d/M)**5) # função exponencial simbólica
W

**Exemplo:** A nossa corretora de imóveis gostaria de entender a relação de preços de imóveis para o Condomínio Pedras de Marfim. Considerando $M = 1 km$, calcule:

- o índice de caminhabilidade $W_1$ em relação à farmácia Dose Certa, localizada a 222 m do condomínio.

- o índice de caminhabilidade $W_2$ em relação ao restaurante Sabor da Arte, localizada a 628 m do condomínio.

- o índice de caminhabilidade $W_3$ em relação ao Centro Esportivo Physicalidade, localizada a 998 m do condomínio.

- o índice de caminhabilidade $W_4$ em relação à Padaria Dolce Panini, localizada a 1,5 km do condomínio.

# note que 1 km = 1000 m
W1 = W.subs([ (d,222), (M,1000) ])
W2 = W.subs([ (d,628), (M,1000) ])
W3 = W.subs([ (d,998), (M,1000) ])
W4 = W.subs([ (d,1500), (M,1000) ])

Perceba, entretanto, que os valores calculados ainda não são numéricos, como esperado.

W1

W2

W3

W4

Lembre-se que podemos usar `evalf` para calcular esses valores. Faremos isso considerando 3 casas decimais.

# reatribuindo todos os valores
W1n = W1.evalf(3)
W2n = W2.evalf(3)
W3n = W3.evalf(3)
W4n = W4.evalf(3)

print('W1 =', W1n, '; ' \
      'W2 =', W2n, '; ' \
      'W3 =', W3n, '; ' \
      'W4 =', W4n)

Como era de se esperar, os valores decaem de 0.997 a 3.24e-17, que é um valor considerado nulo em termos de aproximação numérica.

#### Quebrando instruções com `\`

A contra-barra `\` pode ser usada para quebrar instruções e continuá-las nas próximas linhas, porém não poderá haver nenhum caracter após ela, nem mesmo espaços. Caso contrário, um erro será lançado.

print('Continuando' \
      'na linha abaixo')

# neste exemplo, há um caracter de espaço após \
print('Continuando' \
      'na linha abaixo')

### O tipo `bool`

Em Python, temos mais um tipo de dado bastante útil, o `bool`, que é uma redução de "booleano". Objetos `bool`, que têm sua raiz na chamada Álgebra de Boole, são baseados nos conceitos *true* (verdadeiro) e *false*, ou *0* e *1* e são estudados em algumas disciplinas, tais como Circuitos Lógicos, Matemática Discreta, Lógica Aplicada, entre outras.

Aprenderemos sobre operadores lógicos mais à frente. Por enquanto, cabe mencionar as entidades fundamentais `True` e `False`.

True

False

type(True)

type(False)

Podemos realizar testes lógicos para concluir verdades ou falsidades quando temos dúvidas sobre objetos e relações entre eles. Por exemplo, retomemos os seguintes valores:

W1

W2

A princípio, é difícil determinar qual dos dois é o maior. Porém, podemos realizar "perguntas" lógicas para o interpretador Python com operadores lógicos. Mostraremos apenas dois exemplos com `>` e `<`.

W1 > W2 # isto quer dizer: "W1 é maior do que W2?"

O valor `True` confirma que o valor de `W1` é maior do que `W2`.

W4 < 0

Note que, de acordo com nosso modelo de caminhabilidade, este valor deveria ser zero. Porém, numericamente, ele é uma aproximação para zero. Embora muito pequeno, não é exatamente zero! Por que isso ocorre? Porque o computador lida com uma matemática inexata e aproximada, mas com precisão satisfatória.

## Operadores lógicos

Vimos que `True` e `False` são os dois valores atribuíves a um objeto de tipo `bool`. Eles são úteis para testar condições, realizar verificações e comparar quantidades. Vamos estudar *operadores de comparação*, *operadores de pertencimento* e *operadores de identidade*.

### Operadores de comparação

A tabela abaixo resume os operadores de comparação utilizados em Python.

| operador | significado | símbolo matemático |
|---|---|---|
| `<` | menor do que | $<$ |
| `<=` | menor ou igual a | $\leq$ |
| `>` | maior do que | $>$ |
| `>=` | maior ou igual a | $\geq$ |
| `==` | igual a | $=$ |
| `!=` | diferente de | $\neq$ |

Podemos usá-los para comparar objetos.

**Nota:** `==` está relacionado à igualdade, ao passo que `=` é uma atribuição. São conceitos operadores com finalidade distinta.

2 < 3 # o resultado é um 'bool'

5 < 2 # isto é falso

2 <= 2 # isto é verdadeiro

4 >= 3 # isto é verdadeiro

6 != -2

4 == 4 # isto não é uma atribuição!

Podemos realizar comparações aninhadas:

x = 2
1 < x < 3

3 > x > 4

2 == x > 3

As comparações aninhadas acima são resolvidas da esquerda para a direita e em partes. Isso nos leva a introduzir os seguintes operadores.

| operador | símbolo matemático | significado | uso relacionado a |
|---|---|---|---|
| `or` | $\vee$ | "ou" booleano | união, disjunção |
| `and` | $\wedge$ | "e" booleano | interseção, conjunção |
| `not` | $\neg$ | "não" booleano | exclusão, negação |

# parênteses não são necessários aqui
(2 == x) and (x > 3) # 1a. comparação: 'True'; 2a.: 'False'. Portanto, ambas: 'False'

# parênteses não são necessários aqui
(x < 1) or (x < 2) # nenhuma das duas é True. Portanto,

not (x == 2) # nega o "valor-verdade" que é 'True'

not x + 1 > 3 # estude a precedência deste exemplo. Por que é 'True'?

not (x + 1 > 3) # estude a precedência deste exemplo. Por que também é 'True'?

### Operadores de pertencimento

A tabela abaixo resume os operadores de pertencimento.

| operador | significado | símbolo matemático
|---|---|---|
| `in` | pertence a | $\in$ |
| `not in` | não pertence a | $\notin$ |

Eles terão mais utilidade quando falarmos sobre sequências, listas. Neste momento, vejamos exemplos com objetos `str`.

'2' in '2 4 6 8 10' # o caracter '2' pertence à string

frase_teste = 'maior do que'
'maior' in frase_teste

'menor' in frase_teste # a palavra 'menor' está na frase

1 in 2 # 'in' e 'not in' não são aplicáveis aqui

### Operadores de identidade

A tabela abaixo resume os operadores de identidade.

| operador | significado
|---|---|
| `is` | "aponta para o mesmo objeto"
| `is not` | "não aponta para o mesmo objeto" |

Esses operadores são úteis para verificar se duas variáveis se referem ao mesmo objeto. Exemplo:

```python
a is b
a is not b
```

- `is` é `True` se `a` e `b` se referem ao mesmo objeto; `False`, caso contrário.
- `is not` é `False` se `a` e `b` se referem ao mesmo objeto; `True`, caso contrário.

a = 2
b = 3
a is b # valores distintos

a = 2
b = a
a is b # mesmos valores

a = 2
b = 3
a is not b # de fato, valores não são distintos

a = 2
b = a
a is not b # de fato, valores são distintos

## Equações simbólicas

Equações simbólicas podem ser formadas por meio de `Eq` e não com `=` ou `==`.

# importação
from sympy.abc import a,b
import sympy as sy
sy.init_printing(pretty_print=True)

sy.Eq(a,b) # equação simbólica

sy.Eq(sy.cos(a), b**3) # os objetos da equação são simbólicos

### Resolução de equações algébricas simbólicas

Podemos resolver equações algébricas da seguinte forma:

```python
solveset(equação,variável,domínio)
```

**Exemplo:** resolva $x^2 = 1$ no conjunto $\mathbb{R}$.

from sympy.abc import x
sy.solveset( sy.Eq( x**2, 1), x,domain=sy.Reals)

Podemos reescrever a equação como: $x^2 - 1 = 0$.

sy.solveset( sy.Eq( x**2 - 1, 0), x,domain=sy.Reals)

Com `solveset`, não precisamos de `Eq`. Logo, a equação é passada diretamente.

sy.solveset( x**2 - 1, x,domain=sy.Reals)

**Exemplo:** resolva $x^2 + 1 = 0$ no conjunto $\mathbb{R}$.

sy.solveset( x**2 + 1, x,domain=sy.Reals) # não possui solução real

**Exemplo:** resolva $x^2 + 1 = 0$ no conjunto $\mathbb{C}$.

sy.solveset( x**2 + 1, x,domain=sy.Complexes) # possui soluções complexas

**Exemplo:** resolva $\textrm{sen}(2x) = 3 + x$ no conjunto $\mathbb{R}$.

sy.solveset( sy.sin(2*x) - x - 3,x,sy.Reals) # a palavra 'domain' também pode ser omitida.

O conjunto acima indica que nenhuma solução foi encontrada.

**Exemplo:** resolva $\textrm{sen}(2x) = 1$ no conjunto $\mathbb{R}$.

sy.solveset( sy.sin(2*x) - 1,x,sy.Reals)

## Expansão, simplificação e fatoração de polinômios

Vejamos exemplos de polinômios em uma variável.

a0, a1, a2, a3 = sy.symbols('a0 a1 a2 a3') # coeficientes
P3x = a0 + a1*x + a2*x**2 + a3*x**3 # polinômio de 3o. grau em x
P3x

b0, b1, b2, b3 = sy.symbols('b0 b1 b2 b3') # coeficientes
Q3x = b0 + b1*x + b2*x**2 + b3*x**3 # polinômio de 3o. grau em x
Q3x

R3x = P3x*Q3x # produto polinomial
R3x

R3x_e = sy.expand(R3x) # expande o produto
R3x_e

sy.simplify(R3x_e) # simplify às vezes não funciona como esperado

sy.factor(R3x_e) # 'factor' pode funcionar melhor

# simplify funciona para casos mais gerais
ident_trig = sy.sin(x)**2 + sy.cos(x)**2
ident_trig

sy.simplify(ident_trig)

## Identidades trigonométricas

Podemos usar `expand_trig` para expandir funções trigonométricas.

sy.expand_trig( sy.sin(a + b) ) # sin(a+b)

sy.expand_trig( sy.cos(a + b) ) # cos(a+b)

sy.expand_trig( sy.sec(a - b) ) # sec(a-b)

## Propriedades de logaritmo

Com `expand_log`, podemos aplicar propriedades válidas de logaritmo.

sy.expand_log( sy.log(a*b) )

A identidade não foi validada pois `a` e `b` são símbolos irrestritos.

a,b = sy.symbols('a b',positive=True) # impomos que a,b > 0

sy.expand_log( sy.log(a*b) ) # identidade validada

sy.expand_log( sy.log(a/b) )

m = sy.symbols('m', real = True) # impomos que m seja um no. real
sy.expand_log( sy.log(a**m) )

Com `logcombine`, compactamos as propriedades.

sy.logcombine( sy.log(a) + sy.log(b) ) # identidade recombinada

## Fatorial

A função `factorial(n)` pode ser usada para calcular o fatorial de um número.

sy.factorial(m)

sy.factorial(m).subs(m,10) # 10!

sy.factorial(10) # diretamente

**Exemplo:** Sejam $m,n,x$ inteiros positivos. Se $f(m) = 2m!$, $g(n) = \frac{(n + 1)!}{n^2!}$ e $h(x) = f(x)g(x)$, qual é o valor de $h(2)$?

from sympy.abc import m,n,x

f = 2*sy.factorial(m)
g = sy.factorial(n + 1)/sy.factorial(n**2)

h = (f.subs(m,x)*g.subs(n,x)).subs(x,4)
h

## Funções anônimas

A terceira classe de funções que iremos aprender é a de *funções anônimas*. Uma **função anônima** em Python consiste em uma função cujo nome não é explicitamente definido e que pode ser criada em apenas uma linha de código para executar uma tarefa específica.

Funções anônimas são baseadas na palavra-chave `lambda`. Este nome tem inspiração em uma área da ciência da computação chamada de cálculo-$\lambda$.

Uma função anônima tem a seguinte forma:

```python
lambda lista_de_parâmetros: expressão
```

Funções anônimas podem são bastante úteis para tornar um código mais conciso.

Por exemplo, na aula anterior, definimos a função

```python
def repasse(V):
    return 0.0103*V
```

para calcular o repasse financeiro ao corretor imobiliário.

Com uma função anônima, a mesma função seria escrita como:

repasse = lambda V: 0.0103*V

Não necessariamente temos que atribui-la a uma variável. Neste caso, teríamos:

lambda V: 0.0103*V

Para usar a função, passamos um valor:

repasse(100000) # repasse sobre R$ 100.000,00

O modelo completo com "bonificação" seria escrito como:

r3 = lambda c,V,b: c*V + b # aqui há 3 parâmetros necessários

Redefinamos objetos simbólicos:

from sympy.abc import b,c,V
r3(b,c,V)

O resultado anterior continua sendo um objeto simbólico, mas obtido de uma maneira mais direta. Podemos usar funções anônimas para tarefas de menor complexidade.

## "Lambdificação" simbólica

Usando `lambdify`, podemos converter uma expressão simbólica do *sympy* para uma expressão que pode ser numericamente avaliada em outra biblioteca. Essa função desempenha papel similar a uma função *lambda* (anônima).

expressao = sy.sin(x) + sy.sqrt(x) # expressão simbólica
f = sy.lambdify(x,expressao,"math") # lambdificação para o módulo math
f(0.2) # avalia

Para avaliações simples como a anterior, podemos usar `evalf` e `subs`. A lambdificação será útil quando quisermos avaliar uma função em vários pontos, por exemplo. Na próxima aula, introduziremos sequencias e listas. Para mostrar um exemplo de lambdificação melhor veja o seguinte exemplo.

from numpy import arange # importação de função do módulo numpy

X = arange(40) # gera 40 valores de 0 a 39

X

f = sy.lambdify(x,expressao,"numpy")(X) # avalia 'expressao' em X
f


# importing Python library
import numpy as np

# define Unit Step Function
def unitStep(v):
    if v >= 0:
        return 1
    else:
        return 0

# design Perceptron Model
def perceptronModel(x, w, b):
    v = np.dot(w, x) + b
    y = unitStep(v)
    return y

# NOT Logic Function
# wNOT = -1, bNOT = 0.5
def NOT_logicFunction(x):
    wNOT = -1
    bNOT = 0.5
    return perceptronModel(x, wNOT, bNOT)

# AND Logic Function
# w1 = 1, w2 = 1, bAND = -1.5
def AND_logicFunction(x):
    w = np.array([1, 1])
    bAND = -1.5
    return perceptronModel(x, w, bAND)

# NAND Logic Function
# with AND and NOT
# function calls in sequence
def NAND_logicFunction(x):
    output_AND = AND_logicFunction(x)
    output_NOT = NOT_logicFunction(output_AND)
    return output_NOT

# testing the Perceptron Model
test1 = np.array([0, 1])
test2 = np.array([1, 1])
test3 = np.array([0, 0])
test4 = np.array([1, 0])

print("NAND({}, {}) = {}".format(0, 1, NAND_logicFunction(test1)))
print("NAND({}, {}) = {}".format(1, 1, NAND_logicFunction(test2)))
print("NAND({}, {}) = {}".format(0, 0, NAND_logicFunction(test3)))
print("NAND({}, {}) = {}".format(1, 0, NAND_logicFunction(test4)))

'''
OUTPUT
NAND(0, 1) = 1
NAND(1, 1) = 0
NAND(0, 0) = 1
NAND(1, 0) = 1
'''

ml/Perceptrons/Perceptron as NAND operator.py


import numpy as np

def detA_2x2(a, b, c, d):
    return a*d-b*c

def inv(A):

    if len(A.shape) == 1:
        return ValueError('Matix must have at least 2 dimensions!')
    if A.shape[1] not in [2, 3]:
        return ValueError('Matrix must be either 2x2 or 3x3!')

    elif len(A.shape) == 2:
        if A.shape[0] == 2:       # 2x2
            detA = detA_2x2(A[0, 0], A[0,1], A[1,0], A[1,1])
            cofactor = np.array([[A[1,1], -A[0,1]],
                                [-A[1,0], A[0,0]]])
            Ainv = cofactor/detA
        else:                     # 3x3
            detA = A[0,0]*detA_2x2(A[1,1],A[1,2],A[2,1],A[2,2]) + \
                    -A[0,1]*detA_2x2(A[1,0],A[1,2],A[2,0],A[2,2]) + \
                    +A[0,2]*detA_2x2(A[1,0],A[1,1],A[2,0],A[2,1])

            cf00 = detA_2x2(A[1,1],A[1,2],A[2,1],A[2,2])
            cf01 = detA_2x2(A[0,2],A[0,1],A[2,2],A[2,1])
            cf02 = detA_2x2(A[0,1],A[0,2],A[1,1],A[1,2])
            cf10 = detA_2x2(A[1,2],A[1,0],A[2,2],A[2,0])
            cf11 = detA_2x2(A[0,0],A[0,2],A[2,0],A[2,2])
            cf12 = detA_2x2(A[0,2],A[0,0],A[1,2],A[1,0])
            cf20 = detA_2x2(A[1,0],A[1,1],A[2,0],A[2,1])
            cf21 = detA_2x2(A[0,1],A[0,0],A[2,1],A[2,0])
            cf22 = detA_2x2(A[0,0],A[0,1],A[1,0],A[1,1])

            Ainv = np.array([[cf00, cf01, cf02],
                            [cf10, cf11, cf12],
                            [cf20, cf21, cf22]])/detA

    elif len(A.shape) == 3:
        Ainv = np.zeros_like(A)

        if A.shape[1] == 2:       # 2x2
            detA = detA_2x2(A[:,0, 0], A[:,0,1], A[:,1,0], A[:,1,1])

            cf00 = A[:,1,1]
            cf01 = -A[:,0,1]
            cf10 = -A[:,1,0]
            cf11 = A[:,0,0]

            Ainv[:,0,0] = cf00
            Ainv[:,0,1] = cf01
            Ainv[:,1,0] = cf10
            Ainv[:,1,1] = cf11

            Ainv = Ainv/detA[:,None,None]
        else:                     # 3x3
            detA = A[:,0,0]*detA_2x2(A[:,1,1],A[:,1,2],A[:,2,1],A[:,2,2]) + \
                    -A[:,0,1]*detA_2x2(A[:,1,0],A[:,1,2],A[:,2,0],A[:,2,2]) + \
                    +A[:,0,2]*detA_2x2(A[:,1,0],A[:,1,1],A[:,2,0],A[:,2,1])

            cf00 = detA_2x2(A[:,1,1],A[:,1,2],A[:,2,1],A[:,2,2])
            cf01 = detA_2x2(A[:,0,2],A[:,0,1],A[:,2,2],A[:,2,1])
            cf02 = detA_2x2(A[:,0,1],A[:,0,2],A[:,1,1],A[:,1,2])
            cf10 = detA_2x2(A[:,1,2],A[:,1,0],A[:,2,2],A[:,2,0])
            cf11 = detA_2x2(A[:,0,0],A[:,0,2],A[:,2,0],A[:,2,2])
            cf12 = detA_2x2(A[:,0,2],A[:,0,0],A[:,1,2],A[:,1,0])
            cf20 = detA_2x2(A[:,1,0],A[:,1,1],A[:,2,0],A[:,2,1])
            cf21 = detA_2x2(A[:,0,1],A[:,0,0],A[:,2,1],A[:,2,0])
            cf22 = detA_2x2(A[:,0,0],A[:,0,1],A[:,1,0],A[:,1,1])

            Ainv[:,0,0] = cf00
            Ainv[:,0,1] = cf01
            Ainv[:,0,2] = cf02
            Ainv[:,1,0] = cf10
            Ainv[:,1,1] = cf11
            Ainv[:,1,2] = cf12
            Ainv[:,2,0] = cf20
            Ainv[:,2,1] = cf21
            Ainv[:,2,2] = cf22

            Ainv = Ainv/detA[:,None,None]

    return Ainv, detA

if __name__ == '__main__':
    A_2x2 = np.random.rand(2,2)
    A_3x3 = np.random.rand(3,3)

    print(np.linalg.norm((np.linalg.inv(A_2x2) - inv(A_2x2))))
    print(np.linalg.norm((np.linalg.inv(A_3x3) - inv(A_3x3))))

    a = np.array([[[4, 8, 2],
                    [5, 0, 2],
                    [1, 1, 3]],

                    [[7, 0, 8],
                    [9, 5, 4],
                    [3, 4, 2]]])

    b = np.array([[[4, 8],
                    [5, 0]],

                    [[7, 0],
                    [9, 5]]])

    #2x2
    i = np.zeros_like(a, dtype=float)
    i[0,:,:] = np.linalg.inv(a[0,:,:])
    i[1,:,:] = np.linalg.inv(a[1,:,:])

    i_custom = inv(a)

    print(np.linalg.norm(i-i_custom))

    #3x3
    i = np.zeros_like(b, dtype=float)
    i[0,:,:] = np.linalg.inv(b[0,:,:])
    i[1,:,:] = np.linalg.inv(b[1,:,:])

    i_custom = inv(b)

    print(np.linalg.norm(i-i_custom))


"""
test_numpy.fft_example_01.py

This is an example code for numpy.fft.fft
https://docs.scipy.org/doc/numpy/reference/generated/numpy.fft.fft.html#numpy.fft.fft

More in general, Discrete Fourier Transform (numpy.fft)
https://docs.scipy.org/doc/numpy/reference/routines.fft.html

>>> np.arange(8)
array([0, 1, 2, 3, 4, 5, 6, 7])

when x=0, a=1,
        ...
     x=8, e^2(pi)j
"""

import numpy as np
import matplotlib.pyplot as plt

x = np.arange(8)
a = np.exp( 2j*np.pi * x/8 )
plt.plot( a )
np.fft.fft( a )

t = np.arange(256)
#array([0, 1, 2, ... , 254, 255])
sp = np.fft.fft( np.sin(t) )
freq = np.fft.fftfreq( t.shape[-1] )
plt.plot( freq, sp.real, freq, sp.imag )
plt.show()

"""
In this example, real input has an FFT which is Hermitian,
i.e., symmetric in the real part and anti-symmetric in the imaginary part,
as described in the numpy.fft documentation:
"""

plt.figure()

plt.subplot(211)
plt.title("Real part")
plt.plot( freq, sp.real )
plt.grid(True)
plt.axis([-0.5,0.5,-100,100])
plt.ylabel("?")

plt.subplot(212)
plt.title("Imagenary part")
plt.plot( freq, sp.imag )
plt.grid(True)

plt.axis([-0.5,0.5,-100,100])
plt.xlabel("?")
plt.ylabel("?")

#plt.title("Spectrum of r'$e^(2\pij*x/8)$'")


#!/usr/bin/env python

#	Sigular Value Decomposition (SVD)
#		Trucco, Appendix A.6
#
#	definition
#
#			A = U*D*transpose(V)
#
#		A any real m x n matrix
#		U is m x n matrix that columns are eigenvectors of A*transpose(A)
#			A*transpose(A) = U * D * transpose(V) * V * D * transpose(U) = U * D^2 * transpose(U)
#		V is n x n matrix that columns are eivenvectors of transpose(A)*A
#			transpose(A)*A = V * D * transpose(U) * U * D * transpose(V) = V * D^2 * transpose(V)
#		D is n x n diagonal matrix (non-negative real values called sigular values)
#
#	computing the inverse of a matrix using SVD
#
#		inverse(A) = V*inverse(D)*transpose(U)
#			where inverse(D) are 1/singular values
#

#
#		|-     -|
#		| 1 2 1 |
#	A = | 2 3 2 |
#		| 1 2 1 |
#		|_	   _|
#
#											   |-	     -|
#											   | 6  10 6  |
#	A * transpose( A ) = transpose( A ) * A =  | 10 17 10 |
#											   | 6  10 6  |
#											   |_	     _|

import numpy as np

Epsilon = 1e-12

a = np.array( [ [ 1, 2, 1 ],
				[ 2, 3, 2 ],
				[ 1, 2, 1 ],
			] )
print( '  matrix A = {}'.format( a ) )

#	basic inverse matrix
print( '###################################################' )
print( 'basic method inverse matrix...............' )

#	try to inverse using basic method 1/det(a) * adj(a)
try:
	inverseA = np.linalg.inv( a )
	print( '  matrix inverse( A ) = {}'.format( inverseA ) )
except np.linalg.linalg.LinAlgError as e:
	print( 'ERROR!!! Cannot inverse matrix : {}'.format( e ) )

print( '###################################################' )
print( 'SVD method inverse matrix...............' )

#	construct A * transpose( A )
aMultiplyTransposeA = np.array( [ [ 6, 10, 6 ],
									[ 10, 17, 10 ],
									[ 6, 10, 6 ],
								] )
print( '  matrix A * trasnpose( A ) = {}'.format( aMultiplyTransposeA ) )

#	calculate eigenvalues and eigenvectors
print( '      calculating eigen values/vectors' )
eigenvalues, eigenvectors = np.linalg.eig( aMultiplyTransposeA )
print( '      eigenvalues of matrix A * trasnpose( A ) = {}'.format( eigenvalues ) )
print( '      eigenvectors of matrix A * trasnpose( A ) = {}'.format( eigenvectors ) )

#	construct the D matrix from eigenvalues
d = np.array( [ [ eigenvalues[0], 0, 0 ],
				[ 0, eigenvalues[1], 0 ],
				[ 0, 0, eigenvalues[2] ]
			] )
print( '\n    d matrix = {}'.format( d ) )

#	construct the U and V matrix from eigenvectors
u = np.array( eigenvectors )
print( '    u matrix = {}'.format( u ) )

#	construct transpose v
vt = np.array( [ [ eigenvectors[0][0], eigenvectors[1][0], eigenvectors[2][0] ],
					[ eigenvectors[0][1], eigenvectors[1][1], eigenvectors[2][1] ],
					[ eigenvectors[0][2], eigenvectors[1][2], eigenvectors[2][2] ],
				 ] )
print( '    vt matrix = {}'.format( vt ) )

print( '    testing by calculate A from U*D*transpose(V)..............' )
result = np.matmul( u, d )
result = np.matmul( result, vt )
print( '         result from reconstruct A from SVD = {}'.format( result ) )
assert( ( a[0][0] - result[0][0] < Epsilon ) and ( a[0][1] - result[0][1] < Epsilon ) and ( a[0][2] - result[0][2] < Epsilon )
		and ( a[1][0] - result[1][0] < Epsilon ) and ( a[1][1] - result[1][1] < Epsilon ) and ( a[1][2] - result[1][2] < Epsilon )
		and ( a[2][0] - result[2][0] < Epsilon ) and ( a[2][1] - result[2][1] < Epsilon ) and ( a[2][2] - result[2][2] < Epsilon ) )

print( '..........................................' )
print( '\n\n    preparing data to do a inverse matrix from V*inverse(D)*transpose(U)..............' )

#	calculate inverse of D
inverseD = np.array( [ [ 1./eigenvalues[0] if eigenvalues[0] > Epsilon else 0, 0, 0 ],
						[ 0, 1./eigenvalues[1] if eigenvalues[1] > Epsilon else 0, 0 ],
						[ 0, 0, 1./eigenvalues[2] if eigenvalues[2] > Epsilon else 0 ]
					] )
print( '\n    inverse(D) matrix = {}'.format( inverseD ) )

#	construct v from eigenvectors
v = np.array( eigenvectors )
print( '    v matrix = {}'.format( v ) )

#	construct transpose u
ut = np.array( [ [ eigenvectors[0][0], eigenvectors[1][0], eigenvectors[2][0] ],
					[ eigenvectors[0][1], eigenvectors[1][1], eigenvectors[2][1] ],
					[ eigenvectors[0][2], eigenvectors[1][2], eigenvectors[2][2] ],
				 ] )
print( '    ut matrix = {}'.format( ut ) )

print( '\n\n    testing by calculate inverse( A ) from V*inverse(D)*transpose(U)..............' )
inverseA = np.matmul( v, inverseD )
inverseA = np.matmul( result, ut )
print( '         result from reconstruct inverse of A from SVD = {}'.format( inverseA ) )

#	checking the inverse matrix
aMultiplyInverseA = np.matmul( a, inverseA )
print( '         checking the inverse of A by A * inverse(A) = {}'.format( aMultiplyInverseA ) )


'''
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Author:B.Ajay
Licence:Apache 2.0
------------------------------------------------------------------------------------------------------------------------------------------------------------------------
'''

import random as r
import math
import numpy as np
import matplotlib.pyplot as plt
lx,ly=[],[]
def compute_pi(sample_points):
    inside_point_ctr=0
    for i in range(sample_points):
        x=r.random()
        y=r.random()
        lx.append(x)
        ly.append(y)
        if(math.sqrt(x**2+y**2)<=1):inside_point_ctr+=1
    return 4*inside_point_ctr/sample_points
def draw():
    x_axis=np.linspace(0,1.0,150)
    y_axis=np.linspace(0,1.0,150)
    a,b=np.meshgrid(x_axis,y_axis)
    circle_equation=a**2+b**2-1.0
    _,axis=plt.subplots()
    axis.contour(a,b,circle_equation,[0])
    plt.scatter(lx,ly,s=0.001)
    axis.set_aspect(1)
    plt.title("Scatter Plot of Points sampled")
    plt.show()
sample_point=int(input("Enter the number of sample points to compute pi->Enter a large value 10000<x<10000000"))
flag='y'
if sample_point>10000000:
    flag=input("This value is much above the limit .Allowing this process may hog your memory .Do you still want to proceed?[y/n]")
if flag=='y':
    print("The Computation may take seconds to compute Please wait")
    print("Value of Pi (approximated): ",compute_pi(sample_point))
    draw()
else:
    exit()