Add very simple examples for beginners about pacopy HOT 4 CLOSED

from autograd import numpy
import autograd
import scipy
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

import pacopy

class SimpleProblem2D:
    def __init__(self):
        self.n = 2

    def inner(self, a, b):
        """The inner product of the problem. Can be numpy.dot(a, b), but factoring in
        the mesh width stays true to the PDE.
        """
        return numpy.dot(a, b)

    def norm2_r(self, a):
        """The norm in the range space; used to determine if a solution has been found."""
        return numpy.dot(a, a)

    def f(self, u, lmbda):
        """The evaluation of the function to be solved"""
        out0 = numpy.sin(u[0])      - lmbda
        out1 = numpy.cos(u[1])*u[1] - lmbda
        return numpy.array([out0, out1])

    def df_dlmbda(self, u, lmbda):
        """The function's derivative with respect to the parameter. Used in Euler-Newton
        continuation.
        """
        out = -numpy.ones_like(u)
        return out

    def jacobian_solver(self, u, lmbda, rhs):
        """A solver for the Jacobian problem."""
        df_du = autograd.jacobian(self.f)
        return numpy.linalg.solve(df_du(u, lmbda), rhs)
    
problem = SimpleProblem2D()
# Initial guess
u0 = numpy.zeros(problem.n)
# Initial parameter value
lmbda0 = 0.0

# Init lists
lmbda_list = []
values_list = []

def callback(k, lmbda, sol):
    # Use the callback for plotting, writing data to files etc.
    lmbda_list.append(lmbda)
    values_list.append(sol)

pacopy.euler_newton(problem, u0, lmbda0, callback, max_steps=50, newton_tol=1.0e-10)

# plot solution
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
data = numpy.hstack((numpy.array(values_list),
                     numpy.array(lmbda_list).reshape(-1,1))).T
ax.plot(*data,'.-')
ax.set_xlabel('$u_1$')
ax.set_ylabel('$u_2$')
ax.set_zlabel('$\lambda$')