У меня есть функция, которая обрабатывает список с плавающей точкой и возвращает список с плавающей точкой - как мне найти аргументы для него, которые возвращают список 0?

Question

Скорее всего, это исчисление, но я не помню, как делать исчисление.

Я знаю Python, но я не знаю, как делать математику в Python.

Вот почему я здесь.

У меня есть функция, которая делает что-то вроде этого ( EDIT : более представительная логика):

other_lst  = [1.,2.,3.,4.,5.] # A list of 5 floats from elsewhere
target_lst = [10,20,30,40,50] # A list of 5 ints from elsewhere

def get_result(   a_lst, an_other_lst, a_target_lst ):
    zipped = zip( a_lst, an_other_lst )    # no global(s), a pure call-signature

    _l = [ (x*y) / sum( [ x*y for x,y in zipped ] ) for x,y in zipped ]

    return [ i-j for i,j in zip( _l, a_target_lst ) ]

Я хочу найтинекоторые нетривиальные lst, такие что
get_result( lst, other_lst, target_lst ) == [0,0,0,0,0].

РЕДАКТИРОВАТЬ : или даже все значения lst такие, что get_result(lst) == [0,0,0,0,0].В этом нет необходимости, но было бы неплохо, если бы это было возможно.

Как мне это сделать?

Мой первоначальный подход состоял в том, чтобы просто перебирать некоторые значения, чтобы приблизить ответ, но это не совсем дает мне то, что я хочу.

Игнорировать арифметику внутри логики функции - они просто заполнители для другой логики.

Answer 1

Как мне это сделать?

Использование scipy, почему бы не обернуть get_result( aLIST ) в penalty_fun(), который затем мог бы работать внутри набора scipy.optimize.fmin* решателей?

def penalty_fun( x, other_param, yet_another_param ):
    aResultLIST = get_result( x.tolist(), other_param, yet_another_param )
    return sum( [ item**2 for item in aResultLIST )

, где при поиске минимизатора решателя используется вектор x[:] ~ ( a, b, c, d, e ) с некоторыми начальными или случайными значениями:

fmin_l_bfgs_b( func    = penalty_fun,
               x0      = x,
               args    = [ other_lst, target_lst ],
               iprint  = 5,
               pgtol   = 1E-8,    
               factr   = 1E+9,    
               maxiter = 1E+8,    
               maxfun  = 1E+8     
               )

Учитывая, что внутренние уловки внутри get_result() не слишком дикие, эта наивная сила может решитьпотенциально со многими начальными начальными точками в x[:], чтобы служить вашему желанию в качестве готового к использованию решения.

---

Логика, набросанная выше перед редактированием (ями),

def get_result(lst):
    # lst is always a list of 5 floats
    a, b, c, d, e = lst

    # logic goes here
    a = a+b
    b = b-c
    c = min(a,b,c)
    d = a*e
    e = d+b

    return [a, b, c, d, e]

дает бесконечно много решений:

a_OUT = 0 =      a_IN + b_IN                     ->     lin b_IN == -a_IN
b_OUT = 0 =             b_IN - c_IN              ->     lin b_IN ==         c_IN
c_OUT = 0 = min( a_IN,  b_IN,  c_IN )            :: non-lin                                       == min( a_IN, -a_IN, -a_IN ) == abs( a_IN ) == 0
d_OUT = 0 =      a_IN *                    e_IN  :: non-lin      OR( a_IN == 0         e_IN == 0 )
e_OUT = 0 =             b_IN +       d_IN        ::     lin b_IN ==             -d_IN

для ввода:
a == 0, b == 0, c == 0, d == 0, e == < -INF, +INF >

Answer 2

Это не будет связано с исчислением как таковым, как правило, с алгеброй. Но так как вы лишаете нас возможности исследовать любые уравнения, которые вы используете, поэтому я собираюсь предложить вам использовать Алгоритм обнаружения корня Ньютона , чтобы сосредоточиться на терминах по одному за раз в качестве начала .

Edit: Хорошо, это включает дифференциальное исчисление, но это не ужасно сложно, и это исправлено для любого статического набора функций, которые вы хотите в a, b, c, d, e.