# Import required libraries

import numpy as np

import sympy as sym

from scipy.optimize import minimize, shgo, differential_evolution

import plotly.graph_objects as go

import pandas as pd

​

# Definition of the function to be researched

x = sym.Symbol('x')

y = sym.Symbol('y')

f = (x**2 + y - 11)**2 + (x + y**2 - 7)**2

f2 = sym.lambdify((x, y), f)

​

# Generate the domain

def generateDomain():

    X_cord_val = np.linspace(-5, 5, 100)

    Y_cord_val = np.linspace(-5, 5, 100)

    return X_cord_val, Y_cord_val

​

# Function to calculate the function value at a point

def Function2Calc(point2Calc):

    x, y = point2Calc

    return f2(x, y)

​

# Function to calculate the derivatives of the function for Jacobian and Hessian matrices

dFdX = sym.lambdify((x, y), f.diff(x))

dFdY = sym.lambdify((x, y), f.diff(y))

d2FdX2 = sym.lambdify((x, y), f.diff(x, 2))

d2FdY2 = sym.lambdify((x, y), f.diff(y, 2))

d2FdXdY = sym.lambdify((x, y), f.diff(x).diff(y))

​

# Function to calculate the Jacobian matrix of f

def JacobianCalc(point2Calc):

    x, y = point2Calc

    return np.array((dFdX(x, y), dFdY(x, y)))

​

# Function to calculate the Hessian matrix of f

def HesCalc(point2Calc):

    x, y = point2Calc

    return np.array(((d2FdX2(x, y), d2FdXdY(x, y)), (d2FdXdY(x, y), d2FdY2(x, y))))

​

# Function to find local minimization of f using different optimization algorithms

def findLocalMinimizationOfF():

    X_cord_val, Y_cord_val = generateDomain()

    np.random.seed(1000)

    random_x = np.random.uniform(X_cord_val[0], X_cord_val[-1], size=100)

    random_y = np.random.uniform(Y_cord_val[0], Y_cord_val[-1], size=100)

    pointsArray = np.array([random_x, random_y]).transpose()

    methods = ["CG", "BFGS", "Newton-CG", "L-BFGS-B"]

    PointsArrayAnswers = np.zeros((100 * 4, 6))

    for i, point2Calc in zip(range(0, 400, len(methods)), pointsArray):

        for AlgIdx, method in zip(range(1, 5), methods):

            result = minimize(Function2Calc, point2Calc, method=method, jac=JacobianCalc, hess=HesCalc)

            PointsArrayAnswers[i + AlgIdx - 1, 0:2] = point2Calc

            PointsArrayAnswers[i + AlgIdx - 1, 2:4] = result.x

            PointsArrayAnswers[i + AlgIdx - 1, 4] = result.fun

            PointsArrayAnswers[i + AlgIdx - 1, 5] = AlgIdx

​

    return PointsArrayAnswers

​

# Function to perform global optimization of f over D using differential_evolution

def globalOptimizationOfFOverDUsingDifferentialEvolution():

    X_cord_val, Y_cord_val = generateDomain()

    result = differential_evolution(Function2Calc, bounds=[(-5, 5), (-5, 5)])

    xBar, yBar = result.x

    fBar = result.fun

    print(f"f({xBar}; {yBar}) = {fBar}")

    return xBar, yBar

​

# Function to calculate the matrix inverse

def calculateMatrixInverse():

    A = np.array([[3, 1], [1, 2]])

    A_inv = np.linalg.inv(A)

    print("Matrix A:")

    print(A)

    print("Inverse of Matrix A:")

    print(A_inv)

    return A, A_inv

​

# Visualization of the function in 3D using Plotly

def Draw3dVersionFunction():

    X_cord_val, Y_cord_val = generateDomain()

    X_grid, Y_grid = np.meshgrid(X_cord_val, Y_cord_val)

    Z_grid = Function2Calc([X_grid, Y_grid])

​

    fig = go.Figure(data=[go.Surface(x=X_cord_val, y=Y_cord_val, z=Z_grid)])

    fig.update_layout(title="3D Visualization of the Function", scene=dict(xaxis_title="X", yaxis_title="Y", zaxis_title="Z"))

    fig.show()

​

# Draw the function as a 2D matrix using Plotly

def Draw2dMatrixVersionFunction():

    X_cord_val, Y_cord_val = generateDomain()

    Z_grid = Function2Calc([X_cord_val, Y_cord_val])

​

    fig = go.Figure(data=[go.Heatmap(x=X_cord_val, y=Y_cord_val, z=Z_grid)])

    fig.update_layout(title="2D Matrix Visualization of the Function", xaxis_title="X", yaxis_title="Y")

    fig.show()

​

# Main function to run all the tasks

def main():

    # Task 1: Visualization of the function in 3D using Plotly

    Draw3dVersionFunction()

​

    # Task 2: Draw the function as a 2D matrix using Plotly

    Draw2dMatrixVersionFunction()

​

    # Task 3: Local Minimization of the function

    PointsArrayAnswers = findLocalMinimizationOfF()

    df = pd.DataFrame(PointsArrayAnswers, columns=["Initial X", "Initial Y", "Minimized X", "Minimized Y", "Minimized Value", "Algorithm"])

    print("Local Minimization of the Function:")

    print(df)

​

    # Task 4: Global Optimization of the function using differential_evolution

    globalOptimizationOfFOverDUsingDifferentialEvolution()

​

    # Task 5: Comparison of Matrix Inverse

    A, A_inv = calculateMatrixInverse()

​

if __name__ == "__main__":

    main()

import numpy as np

from scipy.optimize import minimize

​

# Define a cubic function to minimize: z = Ax^3 + By + C

def cubic_function(x, A, B, C):

    return A * x[0]**3 + B * x[1] + C

​

# Coefficients for the cubic function

A_coefficient = 2.0

B_coefficient = -3.0

C_constant = 5.0

​

# Initial guess

initial_guess = [1, 1]

​

# Minimize the cubic function

result = minimize(cubic_function, initial_guess, args=(A_coefficient, B_coefficient, C_constant), method='Nelder-Mead')

​

# Print the result

print("Minimum found at x:", result.x)

print("Minimum function value (z):", result.fun)

​

OPTIMIZATION FOR PYTHON: TIP 2 - 4

​

2 - When importing modules you can import them all in a single line:

​

import module_1, module_2, module_3, etc...

​

​

3 - When importing everything from a module use *:

​

from random import *

​

We imported everything from the 'random' module using *, now we dont need to use 'random.'

FUN FACT: Not using module. increases performance since module. uses the get_attr function which

decreases performance

​

​

4 - When importing only a few things from a module combine the two tips above:

​

from random import randint, choice

​

#Now we only import the things we want while also iincreasing performance and start-up time