(wx)Maxima: как получить согласованные выражения с помощью `args`?

Я пытаюсь написать небольшой скрипт, который будет смотреть на первый член выражения и определять, является ли он положительным или отрицательным, а затем печатать + или - перед этим выражением соответственно; однако у меня возникли некоторые проблемы с написанием его таким образом, чтобы он надежно извлекал первый член выражения.

Я экспериментировал с part и args. Я склоняюсь к args, потому что не нашел способа определить глубину parts для произвольного выражения (т.е. я не уверен, как можно определить, следует ли использовать, например, part(expr,1) или part(expr,1,1) или part(expr, 1,1,1) и т. д.).

Проблема с args заключается в том, что, например,

declare(cos, posfun)$
args(-2*cos(x));
    > [2 cos(x)]

т.е. отрицание отбрасывается, предположительно из-за шепелявого представления выражения (тот же результат мы получаем от part(-2*cos(x),1); более того, part(-2*cos(x),2) отваливается от конца -- кажется, part просто не видно - ).

Напротив,

args(-2*cos(x)+x);
    > [x, -2cos(x) ]

как и ожидалось.

Независимо от того, является ли это желаемым поведением для этих функций, я надеялся найти способ обойти это, чтобы у меня была функция, которая имела бы следующее поведение:

addOp(x) > ["+", x]
addOp(-x) > ["-", x]

addOp(1+2*x+x^2) > ["+", 1+2*x+x^2]
addOp(-2+2*x+x^2) > ["-", 2+2*x+x^2] /* NB: only the first term is scaled by -1, not the entire expression */

addOp(cos(...)) > ["+", cos(...)]
addOp(-2x*cos(...)) > ["-", 2x*cos(x) ]

Я также пытался использовать функцию op вместе с известным числом; однако внутреннее представление отрицательных чисел означает, что что-то вроде op(1-3*cos(x)) возвращает +.

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


arguments maxima wxmaxima
person Rax Adaam    schedule 02.03.2021    source источник

Ответы (2)


arrow_upward
2
arrow_downward

Вот моя первая попытка. Кажется, в основном это работает так, как вы описываете, за исключением %o11, потому что -2 перемещается с начала в конец.

(%i1) f(e):= if atom(e) then ["+", e]
 else if op(e) = "-" then ["-", -e]
 elseif op(e) = "+" then [f(first(e)), rest(e)]
 else ["+", e];
(%o1) f(e) := if atom(e) then ["+", e] else (if op(e) = "-" then ["-", - e]
                  elseif op(e) = "+" then [f(first(e)), rest(e)] else ["+", e])
(%i2) f(x);
(%o2)                               [+, x]
(%i3) f(-x);
(%o3)                               [-, x]
(%i4) f(-2*x);
(%o4)                              [-, 2 x]
(%i5) f(-2*cos(x));
(%o5)                            [-, 2 cos(x)]
(%i6) f(1-2*cos(x));
(%o6)                        [[+, 1], - 2 cos(x)]
(%i7) f(-1+2*cos(x));
(%o7)                        [[+, 2 cos(x)], - 1]
(%i8) f(-1-2*cos(x));
(%o8)                        [[-, 2 cos(x)], - 1]
(%i9) f(a*b+c*d-e*f*g);
(%o9)                       [[-, e f g], c d + a b]
(%i10) f(1+2*x+x^2);
                                    2
(%o10)                        [[+, x ], 2 x + 1]
(%i11) f(-2+2*x+x^2);
                                    2
(%o11)                        [[+, x ], 2 x - 2]
(%i12) f(cos(a*b-c));
(%o12)                         [+, cos(c - a b)]
(%i13) f(-2*cos(x-y*z));
(%o13)                        [-, 2 cos(y z - x)]
(%i14) f(-2*x*cos(b-c));
(%o14)                        [-, 2 cos(c - b) x]
(%i15) -2+2*x+x^2;
                                  2
(%o15)                           x  + 2 x - 2
(%i16) f(-2 + 2*x - x^2);
                                    2
(%o16)                        [[-, x ], 2 x - 2]
(%i17) -2 + 2*x - x^2;
                                   2
(%o17)                         (- x ) + 2 x - 2
(%i18) f(a-b);
(%o18)                           [[+, a], - b]
(%i19) f(b-a);
(%o19)                           [[+, b], - a]

Дело в том, что op(e) = "-" состоит в том, что такие вещи, как -2*cos(x), реорганизуются в -(2*cos(x)) до того, как args над ним поработает (хотя я думаю, что inpart отключает это поведение или модифицирует его).

РЕДАКТИРОВАТЬ: Возьмем 2. atom(-2) возвращает true, поэтому -2 улавливается первым случаем в предыдущем определении. Вот еще одна попытка, где отрицательные числа отличаются от других атомов.

f(e):= 
if atom(e)
 then (if numberp(e) and e < 0 then ["-", -e] else ["+", e])
 else if op(e) = "-" then ["-", -e]
 elseif op(e) = "+" then [f(first(e)), rest(e)]
 else ["+", e];

Я не пробовал этот код, но, возможно, вы можете сказать, работает ли он.

person Robert Dodier    schedule 03.03.2021
comment
Ух ты! Спасибо, Роберт. Похоже, %i7 заменяется как %i11; Интересно, может ли negsumdispflag позаботиться об этом. Я попробую. Я также присмотрюсь к inpart. Надеюсь, с вашей стороны все хорошо! - person Rax Adaam; 03.03.2021
comment
Отлично, рад слышать, что это помогает. Что касается inflag (ой, извините, я хотел сказать inflag вместо inpart, хотя это тоже рядом) эффект заключается в том, что функции взлома выражений работают с внутренним представлением, а не с тем, что отображается. В каком-то смысле внутреннее представление более последовательно, так что, может быть, это в чем-то полезно. - person Robert Dodier; 03.03.2021
comment
Я пытался powerdisp:true решить такие случаи, как -2+2*x+x^2; однако он возвращает [ [+, -2], 2x+x^2 ]. Немного поиграл с inflag и negsumdispflag, но не могу заставить его поймать -2. Моя мысль заключалась в том, чтобы добавить проверку numberp перед atom -- имеет ли это смысл или может быть более прямой/надежный способ поймать этот случай? - person Rax Adaam; 03.03.2021
comment
Хм, интересно. Я обновил ответ еще одной попыткой. - person Robert Dodier; 03.03.2021
comment
Да - я проверял, когда вы ответили (как только заметил, что atom(-2) было правдой. Кажется, он ведет себя правильно. Как последняя проверка: подход, проблема, которую я пытаюсь решить, заключается в том, чтобы отображать правильный оператор при объединении цветные термины, такие как colour(a, 0) + colour(-b, 2) (где заранее неизвестно, b> 0 или ‹0). Я пытался использовать subst, а также несколько других подходов, но это казалось наиболее Знание Максима. - person Rax Adaam; 03.03.2021

arrow_upward
0
arrow_downward

Дополнения к ответу Роберта на случай, если это может быть полезно другим. Ниже приведены примеры сценариев для извлечения значений и их повторной сборки (после некоторого преобразования).

NB вместо "+" и "-", с целью повторной сборки, я переопределил функцию, чтобы она вместо этого возвращала 1 или -1.

Функция Роберта (измененная):

f(e):=  
        if numberp(e) 
        then  if e >= 0
              then [1, e]
              else [-1, -e]
        else  if atom(e) 
              then [1, e]
              else  if op(e) = "-" 
                    then [-1, -e]
                    else  if op(e) = "+" 
                          then [f(first(e)), rest(e)]
                          else [1, e];

Извлечь знак

Принимает выражение в форме [+/-1, e] или [ [+/-1, e], r] и возвращает +/-1.

fExtSg(expr):=
  block([expr:expr],
  if listp(expr[1])
  then expr[1][1]
  else expr[1]);

Извлечь термин

Принимает выражение в форме [+/-1, e] или [ [+/-1, e], r] и возвращает e.

fExtTerm(expr):=
  block([expr:expr],
  if listp(expr[1])
  then expr[1][2]
  else expr[2]
  );

Извлечь остаток

Принимает выражение в форме [+/-1, e] или [ [+/-1, e], r] и возвращает r или 0.

fExtRest(expr):=
  block([expr:expr],
  if listp(expr[1])
  then expr[2]
  else 0
  );

Пример разбиения выражения на части и повторной сборки:

Test:[-1+c,c-1,-b,3,-7*sin(x)-10*cos(x), -7*sin(x)+10*cos(x), 7*sin(x)-10*cos(x)];

/* apply `f` to all terms of the test list */
fTest: makelist(f(Test[i]), i, length(Test));

/* collect the signs into a list */
First_Term_Signs: makelist(fExtSg(fTest[i]), i, length(Test));

/* collect the first terms */
First_Terms: makelist(fExtTerm(fTest[i]), i, length(Test));

/* collect the rest */
Rests: makelist(fExtRest(fTest[i]), i, length(Test));

/* recombine and compare to original list, to ensure proper functioning */
reassembled_test: makelist(First_Term_Signs[i]*First_Terms[i] + Rests[i], i, length(Test));

NB -1 + c и c - 1 будут обрабатываться Maxima одинаково, полученная повторно собранная версия будет соответствовать выходным данным, возвращаемым Maxima...

person Rax Adaam    schedule 03.03.2021