Introdução a Linha de Comando (Manual do Maxima)

Next: Funções e Variáveis Definidas para Linha de Comando, Previous: Linha de Comando, Up: Linha de Comando [Contents][Index]

### 4.1 Introdução a Linha de Comando

Operador: '

  O operador apóstrofo `'` evita avaliação.

  Aplicado a um símbolo, o apóstrofo evita avaliação do símbolo.

  Aplicado a uma chamada de função, o apóstrofo evita avaliação da chamada de função, embora os argumentos da função sejam ainda avaliados (se a avaliação não for de outra forma evitada). O resultado é a forma substantiva da chamada de função.

  Aplicada a uma espressão com parêntesis, o apóstrofo evita avaliação de todos os símbolos e chamadas de função na expressão. E.g., `'(f(x))` significa não avalie a expressão `f(x)`. `'f(x)` (com apóstrofo aplicado a `f` em lugar de `f(x)`) retorna a forma substantiva de `f` aplicada a `[x]`.

  O apóstrofo nao evita simplificação.

  Quando o sinalizador global `noundisp` for `true`, substantivos são mostrados com um apóstrofo. Esse comutador é sempre `true` quando mostrando definições de funções.

  Veja também operador apóstrofo-apóstrofo `''` e `nouns`.

  Exemplos:

  Aplicado a um símbolo, o apóstrofo evita avaliação do símbolo.

      (%i1) aa: 1024;
      (%o1)                         1024
      (%i2) aa^2;
      (%o2)                        1048576
      (%i3) 'aa^2;
                                       2
      (%o3)                          aa
      (%i4) ''%;
      (%o4)                        1048576

  Aplicado a uma chamada de função, o apóstrofo evita avaliação da chamada de função. O resultado é a forma substantiva da chamada de função.

      (%i1) x0: 5;
      (%o1)                           5
      (%i2) x1: 7;
      (%o2)                           7
      (%i3) integrate (x^2, x, x0, x1);
                                     218
      (%o3)                          ---
                                      3
      (%i4) 'integrate (x^2, x, x0, x1);
                                   7
                                  /
                                  [   2
      (%o4)                       I  x  dx
                                  ]
                                  /
                                   5
      (%i5) %, nouns;
                                     218
      (%o5)                          ---
                                      3

  Aplicado a uma expressão com parêntesis, o apóstrofo evita avaliação de todos os símbolos e chamadas de função na expressão.

      (%i1) aa: 1024;
      (%o1)                         1024
      (%i2) bb: 19;
      (%o2)                          19
      (%i3) sqrt(aa) + bb;
      (%o3)                          51
      (%i4) '(sqrt(aa) + bb);
      (%o4)                     bb + sqrt(aa)
      (%i5) ''%;
      (%o5)                          51

  O apóstrofo não evita simplificação.

      (%i1) sin (17 * %pi) + cos (17 * %pi);
      (%o1)                          - 1
      (%i2) '(sin (17 * %pi) + cos (17 * %pi));
      (%o2)                          - 1

Operador: ''

  O operador apóstrofo-apóstrofo `''` (dois apóstrofost) modifica avaliação em expressões de entrada.

  Aplicado a uma expressão geral expr, apóstrofo-apóstrofo faz com que o valor de expr seja substituído por expr na expressão de entrada.

  Aplicado ao operadro de uma expressão, apóstrofo-apóstrofo modifica o operadro de um susbstantivo para um verbo (se esse operador não for já um verbo).

  O operador apóstrofo-apóstrofo é aplicado através do passador de entrada; o apóstrofo-apóstrofo não é armazenado como parte de uma expressão de entrada passada. O operador apóstrofo-apóstrofo é sempre aplicado tão rapidamente quanto for passado, e não pode receber um terceiro apóstrofo. Dessa forma faz com que ocorra avaliação quando essa avaliação for de outra forma suprimida, da mesma forma que em definições de função, definições de expressãoes lambda, e expressões que recebem um apóstrofo simples `'`.

  Apóstrofo-apóstrofo é reconhecido por `batch` e `load`.

  Veja também o operador apóstrofo `'` e `nouns`.

  Exemplos:

  Aplicado a uma expressão geral expr, apóstrofo-apóstrofo fazem com que o valor de expr seja substituido por expr na expressão de entrada.

      (%i1) expand ((a + b)^3);
                           3        2      2      3
      (%o1)               b  + 3 a b  + 3 a  b + a
      (%i2) [_, ''_];
                               3    3        2      2      3
      (%o2)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
      (%i3) [%i1, ''%i1];
                               3    3        2      2      3
      (%o3)     [expand((b + a) ), b  + 3 a b  + 3 a  b + a ]
      (%i4) [aa : cc, bb : dd, cc : 17, dd : 29];
      (%o4)                   [cc, dd, 17, 29]
      (%i5) foo_1 (x) := aa - bb * x;
      (%o5)                 foo_1(x) := aa - bb x
      (%i6) foo_1 (10);
      (%o6)                      cc - 10 dd
      (%i7) ''%;
      (%o7)                         - 273
      (%i8) ''(foo_1 (10));
      (%o8)                         - 273
      (%i9) foo_2 (x) := ''aa - ''bb * x;
      (%o9)                 foo_2(x) := cc - dd x
      (%i10) foo_2 (10);
      (%o10)                        - 273
      (%i11) [x0 : x1, x1 : x2, x2 : x3];
      (%o11)                    [x1, x2, x3]
      (%i12) x0;
      (%o12)                         x1
      (%i13) ''x0;
      (%o13)                         x2
      (%i14) '' ''x0;
      (%o14)                         x3

  Aplicado ao operador de uma expressão, apóstrofo-apóstrofo muda o operadro de um substantivo para um verbo (se esse operadro não for já um verbo).

      (%i1) sin (1);
      (%o1)                        sin(1)
      (%i2) ''sin (1);
      (%o2)                    0.8414709848079
      (%i3) declare (foo, noun);
      (%o3)                         done
      (%i4) foo (x) := x - 1729;
      (%o4)                 ''foo(x) := x - 1729
      (%i5) foo (100);
      (%o5)                       foo(100)
      (%i6) ''foo (100);
      (%o6)                        - 1629

  O operador apóstrofo-apóstrofo é aplicado por meio de um passador de entrada; operador-apóstrofo não é armazenado como parte da expressão de entrada.

      (%i1) [aa : bb, cc : dd, bb : 1234, dd : 5678];
      (%o1)                 [bb, dd, 1234, 5678]
      (%i2) aa + cc;
      (%o2)                        dd + bb
      (%i3) display (_, op (_), args (_));
                                 _ = cc + aa

                               op(cc + aa) = +

                          args(cc + aa) = [cc, aa]

      (%o3)                         done
      (%i4) ''(aa + cc);
      (%o4)                         6912
      (%i5) display (_, op (_), args (_));
                                 _ = dd + bb

                               op(dd + bb) = +

                          args(dd + bb) = [dd, bb]

      (%o5)                         done

  Apóstrofo apóstrofo faz com que ocorra avaliação quando a avaliação tiver sido de outra forma suprimida, da mesma forma que em definições de função, da mesma forma que em definições de função lambda expressions, E expressões que recebem o apóstrofo simples `'`.

      (%i1) foo_1a (x) := ''(integrate (log (x), x));
      (%o1)               foo_1a(x) := x log(x) - x
      (%i2) foo_1b (x) := integrate (log (x), x);
      (%o2)           foo_1b(x) := integrate(log(x), x)
      (%i3) dispfun (foo_1a, foo_1b);
      (%t3)               foo_1a(x) := x log(x) - x

      (%t4)           foo_1b(x) := integrate(log(x), x)

      (%o4)                      [%t3, %t4]
      (%i4) integrate (log (x), x);
      (%o4)                     x log(x) - x
      (%i5) foo_2a (x) := ''%;
      (%o5)               foo_2a(x) := x log(x) - x
      (%i6) foo_2b (x) := %;
      (%o6)                    foo_2b(x) := %
      (%i7) dispfun (foo_2a, foo_2b);
      (%t7)               foo_2a(x) := x log(x) - x

      (%t8)                    foo_2b(x) := %

      (%o8)                      [%t7, %t8]
      (%i8) F : lambda ([u], diff (sin (u), u));
      (%o8)             lambda([u], diff(sin(u), u))
      (%i9) G : lambda ([u], ''(diff (sin (u), u)));
      (%o9)                  lambda([u], cos(u))
      (%i10) '(sum (a[k], k, 1, 3) + sum (b[k], k, 1, 3));
      (%o10)         sum(b , k, 1, 3) + sum(a , k, 1, 3)
                          k                  k
      (%i11) '(''(sum (a[k], k, 1, 3)) + ''(sum (b[k], k, 1, 3)));
      (%o11)             b  + a  + b  + a  + b  + a
                          3    3    2    2    1    1

Next: Funções e Variáveis Definidas para Linha de Comando, Previous: Linha de Comando, Up: Linha de Comando [Contents][Index]