Gekko & Fsolve function - Inconsistency on results with python

Question

I’m working on a nonlinear equation system with 12 parameters and 12 equations, I have started with FSolve but because results were different between application and computers, I move forward to Gekko… but the problem persists.

I have one routine which the same input data from one excel, running into the same machine (with Jupiter §notebook, or spider or on application compiled with Visual studio, each program produces different outputs! With same Jupiter notebook same input but on different PC, results are also different??? Does anyone have the same experience? How can I solve this?

# Import Libraries
import numpy as np
from gekko import GEKKO
import pandas as pd

# Read Excel File To DataFrame
df = pd.read_excel('INPUT_ML_LIN000_00000.xlsx', header = None)

# Get A
AO = df.iloc[0][1]
# Get Number Of Drives
number_of_drives = df.iloc[1][1]

# First SPL Source
FSS = df.iloc[4][2]
# First Phase Source
FPS = df.iloc[4 + number_of_drives + 2][2]
# First G Source
FGS = df.iloc[4 + (number_of_drives * 2) + 3][3]

# Load G Values
g_matriz = []
for g_cursor in range(number_of_drives):
    g_matriz.append(df.iloc[4 + (number_of_drives * 2) + 3 + g_cursor][3])
g_matriz = np.array(g_matriz)

print(AO, number_of_drives, FSS, FPS, FGS, g_matriz)

print(df)

def gekko_sistema():

    find_solution = False
    counter = 0.0
    
    while not find_solution:
        
        counter += 0.001
    
        m = GEKKO()             # create GEKKO model

        G12 = m.Var()           # define new variable default=0
        G11 = m.Var()           # define new variable default=0
        G10 = m.Var()           # define new variable default=0
        G9 = m.Var()            # define new variable default=0
        G8 = m.Var()            # define new variable default=0
        G7 = m.Var()            # define new variable default=0
        G6 = m.Var()            # define new variable default=0
        G5 = m.Var()            # define new variable default=0
        G4 = m.Var()            # define new variable default=0
        G3 = m.Var()            # define new variable default=0
        G2 = m.Var()            # define new variable default=0
        G1 = m.Var()            # define new variable default=0

        DU = round(counter, 3)            # Deviation
        DL = round(counter, 3)            # Deviation

        A12 = m.CV(AO, AO - DL, AO + DU)
        A11 = m.CV(AO, AO - DL, AO + DU)
        A10 = m.CV(AO, AO - DL, AO + DU)
        A9 = m.CV(AO, AO - DL, AO + DU)
        A8 = m.CV(AO, AO - DL, AO + DU)
        A7 = m.CV(AO, AO - DL, AO + DU)
        A6 = m.CV(AO, AO - DL, AO + DU)
        A5 = m.CV(AO, AO - DL, AO + DU)
        A4 = m.CV(AO, AO - DL, AO + DU)
        A3 = m.CV(AO, AO - DL, AO + DU)
        A2 = m.CV(AO, AO - DL, AO + DU)
        A1 = m.CV(AO, AO - DL, AO + DU)
        #A = AO

        m.Equations( \
                [(-(10**(A12/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 0] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[5][2 + 0] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[6][2 + 0] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[7][2 + 0] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[8][2 + 0] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[9][2 + 0] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[10][2 + 0] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[11][2 + 0] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[12][2 + 0] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[13][2 + 0] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[14][2 + 0] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[15][2 + 0] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 0])))**2 \
                + \
                ((10**((df.iloc[4][2 + 0] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[5][2 + 0] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[6][2 + 0] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[7][2 + 0] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[8][2 + 0] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[9][2 + 0] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[10][2 + 0] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[11][2 + 0] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[12][2 + 0] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[13][2 + 0] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[14][2 + 0] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 0])) + \
                (10**((df.iloc[15][2 + 0] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 0])))**2 == 0, \
                (-(10**(A11/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 1] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[5][2 + 1] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[6][2 + 1] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[7][2 + 1] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[8][2 + 1] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[9][2 + 1] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[10][2 + 1] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[11][2 + 1] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[12][2 + 1] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[13][2 + 1] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[14][2 + 1] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[15][2 + 1] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 1])))**2 \
                + \
                ((10**((df.iloc[4][2 + 1] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[5][2 + 1] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[6][2 + 1] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[7][2 + 1] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[8][2 + 1] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[9][2 + 1] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[10][2 + 1] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[11][2 + 1] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[12][2 + 1] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[13][2 + 1] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[14][2 + 1] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 1])) + \
                (10**((df.iloc[15][2 + 1] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 1])))**2 == 0, \
                (-(10**(A10/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 2] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[5][2 + 2] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[6][2 + 2] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[7][2 + 2] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[8][2 + 2] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[9][2 + 2] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[10][2 + 2] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[11][2 + 2] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[12][2 + 2] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[13][2 + 2] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[14][2 + 2] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[15][2 + 2] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 2])))**2 \
                + \
                ((10**((df.iloc[4][2 + 2] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[5][2 + 2] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[6][2 + 2] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[7][2 + 2] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[8][2 + 2] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[9][2 + 2] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[10][2 + 2] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[11][2 + 2] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[12][2 + 2] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[13][2 + 2] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[14][2 + 2] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 2])) + \
                (10**((df.iloc[15][2 + 2] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 2])))**2 == 0, \
                (-(10**(A9/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 3] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[5][2 + 3] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[6][2 + 3] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[7][2 + 3] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[8][2 + 3] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[9][2 + 3] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[10][2 + 3] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[11][2 + 3] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[12][2 + 3] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[13][2 + 3] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[14][2 + 3] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[15][2 + 3] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 3])))**2 \
                + \
                ((10**((df.iloc[4][2 + 3] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[5][2 + 3] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[6][2 + 3] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[7][2 + 3] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[8][2 + 3] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[9][2 + 3] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[10][2 + 3] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[11][2 + 3] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[12][2 + 3] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[13][2 + 3] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[14][2 + 3] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 3])) + \
                (10**((df.iloc[15][2 + 3] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 3])))**2 == 0, \
                (-(10**(A8/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 4] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[5][2 + 4] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[6][2 + 4] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[7][2 + 4] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[8][2 + 4] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[9][2 + 4] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[10][2 + 4] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[11][2 + 4] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[12][2 + 4] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[13][2 + 4] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[14][2 + 4] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[15][2 + 4] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 4])))**2 \
                + \
                ((10**((df.iloc[4][2 + 4] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[5][2 + 4] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[6][2 + 4] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[7][2 + 4] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[8][2 + 4] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[9][2 + 4] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[10][2 + 4] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[11][2 + 4] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[12][2 + 4] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[13][2 + 4] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[14][2 + 4] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 4])) + \
                (10**((df.iloc[15][2 + 4] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 4])))**2 == 0, \
                (-(10**(A7/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 5] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[5][2 + 5] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[6][2 + 5] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[7][2 + 5] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[8][2 + 5] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[9][2 + 5] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[10][2 + 5] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[11][2 + 5] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[12][2 + 5] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[13][2 + 5] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[14][2 + 5] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[15][2 + 5] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 5])))**2 \
                + \
                ((10**((df.iloc[4][2 + 5] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[5][2 + 5] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[6][2 + 5] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[7][2 + 5] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[8][2 + 5] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[9][2 + 5] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[10][2 + 5] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[11][2 + 5] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[12][2 + 5] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[13][2 + 5] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[14][2 + 5] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 5])) + \
                (10**((df.iloc[15][2 + 5] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 5])))**2 == 0, \
                (-(10**(A6/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 6] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[5][2 + 6] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[6][2 + 6] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[7][2 + 6] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[8][2 + 6] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[9][2 + 6] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[10][2 + 6] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[11][2 + 6] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[12][2 + 6] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[13][2 + 6] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[14][2 + 6] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[15][2 + 6] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 6])))**2 \
                + \
                ((10**((df.iloc[4][2 + 6] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[5][2 + 6] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[6][2 + 6] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[7][2 + 6] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[8][2 + 6] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[9][2 + 6] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[10][2 + 6] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[11][2 + 6] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[12][2 + 6] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[13][2 + 6] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[14][2 + 6] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 6])) + \
                (10**((df.iloc[15][2 + 6] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 6])))**2 == 0, \
                (-(10**(A5/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 7] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[5][2 + 7] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[6][2 + 7] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[7][2 + 7] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[8][2 + 7] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[9][2 + 7] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[10][2 + 7] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[11][2 + 7] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[12][2 + 7] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[13][2 + 7] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[14][2 + 7] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[15][2 + 7] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 7])))**2 \
                + \
                ((10**((df.iloc[4][2 + 7] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[5][2 + 7] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[6][2 + 7] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[7][2 + 7] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[8][2 + 7] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[9][2 + 7] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[10][2 + 7] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[11][2 + 7] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[12][2 + 7] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[13][2 + 7] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[14][2 + 7] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 7])) + \
                (10**((df.iloc[15][2 + 7] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 7])))**2 == 0, \
                (-(10**(A4/20))**2) \
                + \
                ((10**((df.iloc[4][2 + 8] + G12) / 20) * np.cos(df.iloc[4 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[5][2 + 8] + G11) / 20) * np.cos(df.iloc[5 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[6][2 + 8] + G10) / 20) * np.cos(df.iloc[6 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[7][2 + 8] + G9) / 20) * np.cos(df.iloc[7 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[8][2 + 8] + G8) / 20) * np.cos(df.iloc[8 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[9][2 + 8] + G7) / 20) * np.cos(df.iloc[9 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[10][2 + 8] + G6) / 20) * np.cos(df.iloc[10 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[11][2 + 8] + G5) / 20) * np.cos(df.iloc[11 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[12][2 + 8] + G4) / 20) * np.cos(df.iloc[12 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[13][2 + 8] + G3) / 20) * np.cos(df.iloc[13 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[14][2 + 8] + G2) / 20) * np.cos(df.iloc[14 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[15][2 + 8] + G1) / 20) * np.cos(df.iloc[15 + number_of_drives + 2][2 + 8])))**2 \
                + \
                ((10**((df.iloc[4][2 + 8] + G12) / 20) * np.sin(df.iloc[4 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[5][2 + 8] + G11) / 20) * np.sin(df.iloc[5 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[6][2 + 8] + G10) / 20) * np.sin(df.iloc[6 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[7][2 + 8] + G9) / 20) * np.sin(df.iloc[7 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[8][2 + 8] + G8) / 20) * np.sin(df.iloc[8 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[9][2 + 8] + G7) / 20) * np.sin(df.iloc[9 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[10][2 + 8] + G6) / 20) * np.sin(df.iloc[10 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[11][2 + 8] + G5) / 20) * np.sin(df.iloc[11 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[12][2 + 8] + G4) / 20) * np.sin(df.iloc[12 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[13][2 + 8] + G3) / 20) * np.sin(df.iloc[13 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[14][2 + 8] + G2) / 20) * np.sin(df.iloc[14 + number_of_drives + 2][2 + 8])) + \
                (10**((df.iloc[15][2 + 8] + G1) / 20) * np.sin(df.iloc[15 + number_of_drives + 2][2 + 8])))**2 == 0, \
                (-(10**(A3/20))**2) 
... cropped for Stack Overflow character limit
                )  # equations

        m.options.MAX_ITER=250
        m.options.IMODE = 3
        #m.solve(disp=False)    # solve
        try:
            m.solve(disp=False)    # solve
            find_solution = True
            print(f'Solution Found: U {counter} L -{counter}')
        except:
            print(f'Solution Not Found: U {counter} L -{counter}')

    return [G12.value[0], G11.value[0], G10.value[0], G9.value[0], G8.value[0], G7.value[0], G6.value[0], G5.value[0], G4.value[0], G3.value[0], G2.value[0], G1.value[0]] # print solution

result = gekko_sistema()
print(result)

Data Table

John Hedengren · Answer 1 · 2022-11-23T22:03:17.777

One possible issue is if there are multiple local solutions to the equations. Another potential issue to check is if they both report a successful solution. Try giving the same initial conditions to both. Please post the code that produces the different results. Because there is no code in the question, here is an example.

Python Scipy Optimize fsolve

import numpy as np
from scipy.optimize import fsolve

def myFunction(z):
   x = z[0]
   y = z[1]
   w = z[2]

   F = np.empty((3))
   F[0] = x**2+y**2-20
   F[1] = y - x**2
   F[2] = w + 5 - x*y
   return F

zGuess = np.array([1,1,1])
z = fsolve(myFunction,zGuess)
print(z)

Python Gekko

from gekko import GEKKO
m = GEKKO()
x,y,w = [m.Var(1) for i in range(3)]
m.Equations([x**2+y**2==20,\
             y-x**2==0,\
             w+5-x*y==0])
m.solve(disp=False)
print(x.value,y.value,w.value)

These both produce the same solution. The two packages use different solution techniques.

Response to Edit

There are no major problems with the source code, but 10**(a*variable+b) is a very nonlinear equation. The other optimization solution is compiled executable so it cannot be directly compared. Here are a couple suggestions:

Taking m.log10() of both sides of the equation may help find a solution faster.
The solver runs for a maximum of 250 iterations each cycle and counter increments to expand the upper and lower limits of the variables. The iterations stop when a solution is found and the problem is feasible.

counter += 0.001

m = GEKKO()             # create GEKKO model

G12 = m.Var()           # define new variable default=0
G11 = m.Var()           # define new variable default=0
G10 = m.Var()           # define new variable default=0
G9 = m.Var()            # define new variable default=0
G8 = m.Var()            # define new variable default=0
G7 = m.Var()            # define new variable default=0
G6 = m.Var()            # define new variable default=0
G5 = m.Var()            # define new variable default=0
G4 = m.Var()            # define new variable default=0
G3 = m.Var()            # define new variable default=0
G2 = m.Var()            # define new variable default=0
G1 = m.Var()            # define new variable default=0

DU = round(counter, 3)            # Deviation
DL = round(counter, 3)            # Deviation

A12 = m.CV(AO, AO - DL, AO + DU)
A11 = m.CV(AO, AO - DL, AO + DU)
A10 = m.CV(AO, AO - DL, AO + DU)
A9 = m.CV(AO, AO - DL, AO + DU)
A8 = m.CV(AO, AO - DL, AO + DU)
A7 = m.CV(AO, AO - DL, AO + DU)
A6 = m.CV(AO, AO - DL, AO + DU)
A5 = m.CV(AO, AO - DL, AO + DU)
A4 = m.CV(AO, AO - DL, AO + DU)
A3 = m.CV(AO, AO - DL, AO + DU)
A2 = m.CV(AO, AO - DL, AO + DU)
A1 = m.CV(AO, AO - DL, AO + DU)

A couple suggestions for this section are:

use m.Var() instead of m.CV() for A1 to A12
expand the upper and lower limits to get a feasible solution faster
there are currently 24 variables with A1 to A12 and G1 to G12
if you need to solve 12 equations and 12 variables then use IMODE=1 to check the degrees of freedom
there is no objective function to guide the selection of the additional 12 variables

The optimization code is missing Coverage.xlsx. I recommend that you create a new question for the optimization problem. This question focuses on the simulation and solution of the 12 equations.

the problem is that we know there is at least one solution and with both approaches in some computers it finds the solution on other ones no!!! you can down load on the link below. both should find a solution one array of 12 values https://www.dropbox.com/s/siaxlabbzv4240f/Apps.zip?dl=0 — Ricardo Castro, Nov 22 '22 at 22:24
on the link you will find the code for our optimizer. I would be very surprised if you have same results, running both application. thanks for your interest to help! https://www.dropbox.com/s/sslp481lxos0o50/Optimize_v2.0.py?dl=0 — Ricardo Castro, Nov 23 '22 at 09:05
Thanks for your comments and suggestions! I'll try it!, just fYI A1 to A12, in fact it can be ONLY A ( the average value that we know and for the one we want to Optimize) what we realized is that making A as only and a fix number, assuming G1 to G12 the 12 variables, and each one with his own equation equal to "A" can be too rigid and the solution can be impossible... that's why we add some "extra" flexibility, based on a controlled delta that we increment up and down - — Ricardo Castro, Nov 23 '22 at 22:59
BUT note A1-A12 are numbers known on each iteration... that's why I think they are not properly unknown variables. finally note that we add delta up and down until a maximum that we know it exists... it's the starting condition! and during the up-and down if the function doesn't find a solution, we assume the initial condition! this means there's no room for optimizations which is fine and it can happen! — Ricardo Castro, Nov 23 '22 at 22:59
last but very important, just note that we started with a normal approach (FSolve) 12 equations, 12 variables, and initially we found for the same input, in some computers was possible to get a solution, and with everything same on other computer NOT!!!!... that's why we moved for new approaches with gekko. and something that we saw also with Fsolve theres a particular frequency 2000Hz where we found very good results, then we extend, same routine / same code / same input, to several frequencies including 2000Hz... and the full routine was not detecting the 2000Hz. — Ricardo Castro, Nov 23 '22 at 23:05
and here is where we stand now, not only some of the known optimizations if we try a full routine doesn't find it, or as we have been seeing even the ones that it finds, if we are working with different computers, the results can be VERY different!!!! AGAIN if you have more ideas they are very welcome! — Ricardo Castro, Nov 23 '22 at 23:07
If A1-A12 are known on each iteration then set them as `m.Param()` values. This will fix them at that value instead of giving them to the optimizer to determine the value. — John Hedengren, Nov 24 '22 at 04:54

Gekko & Fsolve function - Inconsistency on results with python

1 Answers1