Взаимодействия среды

print чувствительно к переменным окружения DIGITS, PRETTYPRINT, и TEXTWIDTH, и к выходным настройкам Pref::floatFormat, Pref::keepOrder, и Pref::trailingZeroes.

Пример 1

Этот пример показывает простой вызов print со строками в качестве аргументов. Они распечатаны с кавычками:

print("Hello", "You"." !"):

Пример 2

На наборе поддержки платформ, print может сгенерировать набранный выход:

print(Typeset, int(f(x)/g(x), x = a..b)):

print использует Typeset опция по умолчанию:

print(int(f(x)/g(x), x = a..b)):

ASCII выход доступен с опцией Plain:

print(Plain, int(f(x)/g(x), x = a..b)):

  b
  /
 |  f(x)
 |  ---- dx
/   g(x)
  a

Пример 3

Как большинство других функций, print оценивает его аргументы. В следующем вызове, x оценивает к 0 и cos(0) оценивает к 1:

a := 0: print(cos(a)^2):

Используйте hold если вы хотите распечатать выражение cos(a)^2 буквально:

print(hold(cos(a)^2)):

delete a:

Пример 4

print с опцией Plain чувствительно к текущему значению TEXTWIDTH:

print(Plain, expand((a + b)^4)):

 4      3        2  2        3    4
a  + 4 a  b + 6 a  b  + 4 a b  + b

TEXTWIDTH := 25:
print(Plain, expand((a + b)^4)):

 4      3        2  2
a  + 4 a  b + 6 a  b

          3    4
   + 4 a b  + b

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

PRETTYPRINT:=FALSE:
print(Plain, expand((a + b)^4)):

a^4 + 4*a^3*b + 6*a^2*b^\
2 + 4*a*b^3 + b^4

Символ продолжения линии может быть недопустимым для некоторых строк. Например, когда вы используете генераторы кода, такие как generate::MATLAB и generate::Simscape, отображенный код, содержащий символ продолжения линии, не допустим. Чтобы постараться не вставлять этот символ, измените TEXTWIDTH установка или использование fprint функция вместо print:

fprint(Unquoted, 0, expand((a + b)^4))

a^4 + 4*a^3*b + 6*a^2*b^2 + 4*a*b^3 + b^4

Кроме того, смотрите Пример 4 на fprint страница справки.

PRETTYPRINT := TRUE:
delete TEXTWIDTH:

Пример 5

print с опцией Plain чувствительно к текущему значению PRETTYPRINT:

print(Plain, a/b):
old := PRETTYPRINT: PRETTYPRINT := FALSE:
print(Plain, a/b):
PRETTYPRINT := old:

a
-
b

a/b

delete old:

Пример 6

Мы демонстрируем, как достигнуть отформатированного вывода для элементов пользовательской области. Предположим, что мы хотим записать новый доменный Complex для комплексных чисел. Каждый элемент этой области имеет два операнда: действительная часть r и мнимая часть s:

Complex := newDomain("Complex"): z := new(Complex, 1, 3):
z + 1;
print(Plain, z + 1):

new(Complex, 1, 3) + 1

Теперь мы хотим более хороший выход для элементов этой области, а именно, в форме r+s*I, где I обозначает мнимую единицу. Мы реализуем стандартную программу паза Complex::print обрабатывать это. Эта стандартная программа паза будет вызвана MuPAD с элементом доменного Complex в качестве аргумента каждый раз, когда такой элемент должен быть распечатан на экране:

Complex::print := (z -> extop(z, 1) + extop(z, 2)*I):
z + 1;
print(Plain, z + 1):

1 + 3 I + 1

delete Complex, z:

Пример 7

Результат "print" метод не должен содержать аргумент как подобъект; в противном случае это приводит к бесконечной рекурсии. В следующем примере, стандартная программа паза T::print назывался бы бесконечно часто. MuPAD пытается захватить такие бесконечные рекурсии и распечатывает `????` вместо этого:

T := newDomain(T): T::print := id:
new(T, 1);
print(Plain, new(T, 1)):

`????`

`????`

delete T:

Пример 8

Если "print" метод возвращает строку, он будет распечатан закрывший кавычки:

Example := newDomain("Example"):  e := new(Example, 1):
Example::print := x -> "elementOfExample":
print(e):

Если "print"- метод возвращает выражение, он будет распечатан в режиме normal mode. Если выражение будет содержать строки, они будут распечатаны обычным способом с кавычками:

Example::print := x -> ["elementOfExample", extop(x)]:
print(e):

delete Example, e:

Пример 9

Предположим, что вы задали функциональный f это может возвратить себя символически, и вы хотите такие символьные выражения формы f(x,...) быть распечатанным специальным способом. С этой целью встройте свой proceduref в функциональной среде и предоставлении выходная процедура в качестве второго аргумента к соответствующему funcenv вызвать. Каждый раз, когда выражение формы f(x,...) должен быть распечатан, выходная процедура будет вызвана аргументами x,... из выражения:

f := funcenv(f,
         proc(x) begin
            if nops(x) = 2 then
              "f does strange things with its arguments ".
              expr2text(op(x, 1))." and ".expr2text(op(x,2))
            else
              FAIL
            end
         end):

delete a, b:
f(a, b)/2;
f(a, b, c)/2

delete f:

Пример 10

С опцией Unquoted, кавычки не использованы:

print(Unquoted, "Hello", "World"." !"):

Hello, World !

С Unquoted специальные символы \t и \n расширены:

print(Unquoted, "As you can see,\n".
                "'\\n' is the newline character\n".
                "\tand '\\t' a tabulator"):

As you can see,
'\n' is the newline character
  and '\t' a tabulator

Пример 11

Полезно создать выводимые строки с помощью expr2text и оператор конкатенации .:

d := 5:  print(Unquoted, "d plus 3 = ".expr2text(d + 3)):

d plus 3 = 8

delete d:

Пример 12

С опцией NoNL, никакая новая строка не помещается в конце выхода и PRETTYPRINT неявно установлен в FALSE. Кроме этого, поведение совпадает с с опцией Unquoted:

print(NoNL, "Hello"):  print(NoNL, ",  You"." !\n"):
print(NoNL, "As you can see, PRETTYPRINT is FALSE: "):
print(NoNL, x^2-1):  print(NoNL, "\n"):

Hello

,  You !

As you can see, PRETTYPRINT is FALSE: 

x^2 - 1

Пример 13

Если опция KeepOrder дан, суммы распечатаны в их внутреннем порядке:

print(b - a):  print(KeepOrder, b - a):

Пример 14

Исказите перезамену (см. Pref::alias) происходит для нормального результата выходные параметры на интерактивном сеансе, но не для выходных параметров, сгенерированных print:

delete a, b: alias(a = b):
a; print(a):
unalias(a):

В отличие от обычного результата выход, print не реагирует на Pref::output:

old := Pref::output(generate::TeX):
sin(a)^b; print(sin(a)^b):
Pref::output(old):

То же самое верно для Pref::postOutput:

old := Pref::postOutput("postOutput was called"):
a*b; print(a*b):
Pref::postOutput(old):

postOutput was called

delete old:

Пример 15

Выход слагаемых суммы зависит от формы этих слагаемых. Если слагаемым является _mult выражение, только первый и последний операнд продукта учтен для определения знака того термина в выходе. Если один из них является отрицательным числом затем "+" - символ в сумме заменяется "-" - символ:

print(hold(a + b*c*(-2)),
      hold(a + b*(-2)*c),
      hold(a + (-2)*b*c)):

Это должно быть учтено при записи "print"- методы для полиномиальных областей.

Пример 16

Числа с плавающей точкой обычно распечатываются в представлении с фиксированной точкой. Можно изменить это в форму с плавающей точкой с мантиссой и экспонентой через Pref::floatFormat:

print(0.000001, 1000.0): old := Pref::floatFormat("e"):
print(0.000001, 1000.0): Pref::floatFormat(old):

В выходе по умолчанию чисел с плавающей запятой отключены конечные нули. Это поведение может быть изменено через Pref::trailingZeroes:

print(0.000001, 1000.0): old := Pref::trailingZeroes(TRUE):
print(0.000001, 1000.0): Pref::trailingZeroes(old):

0.000001, 1000.0

0.000001000000000, 1000.000000

Количество цифр чисел с плавающей запятой в выходе зависит от переменной окружения DIGITS:

print(float(PI)):
DIGITS := 20:  print(float(PI)):
DIGITS := 30:  print(float(PI)):

delete old, DIGITS:

Пример 17

Выходной порядок sets отличается от внутреннего порядка наборов, который возвращен op:

s := {a, b, 1}:
s;
print(Plain, s):
op(s)

{1, a, b}

Оператор индекса [] может использоваться, чтобы получить доступ к элементам набора относительно выходного порядка:

s[1], s[2], s[3]

delete s:

Пример 18

Выход области определяется ее "Name" паз, если это существует, и в противном случае его ключом:

T := newDomain("T"):
T;
print(Plain, T):

T

T::Name := "domain T":
T;
print(Plain, T):

domain T

delete T:

Пример 19

Иногда желательно объединить строки с “симпатичными” выражениями в выходе. Это не возможно через expr2text. С другой стороны, выход с запятыми как диафрагмы обычно рассматривается как ужасный. Следующая фиктивная последовательность выражения может использоваться, чтобы достигнуть желаемого результата. Это использует MuPAD внутренняя функция в стандартном операторе выход builtin(1100,...), с приоритетом 20— приоритет _exprseq— и с пустым символом оператора "":

myexprseq := funcenv(myexprseq,
                     builtin(1100, 20, "", "myexprseq")):
print(Unquoted,
      myexprseq("String and pretty expression ", a^b, ".")):

                              b
String and pretty expression a .

delete myexprseq:

Пример 20

Если опция Typeset объединен с Unquoted или NoNL, предупреждение дано и Typeset проигнорирован:

print(Typeset, Unquoted, "1"):

Warning: Conflicting options, ignoring 'Typeset' [print]

Пример 21

Для более тщательно продуманных конструкций можно хотеть объединить многострочные строки с выражениями MuPAD. Первая попытка может быть похожей на следующее:

myexprseq := funcenv(myexprseq,
                     builtin(1100, 20, "", "myexprseq")):
Example := newDomain("Example"):
Example::print :=
  x -> myexprseq("--- \n--\n-\n--\n---", op(x)):
e := new(Example, 1):
print(Plain, e):

"--- \n--\n-\n--\n---"1

Очевидно, этот подход не работает. Возвращаемое значение "print" метод, заданный выше, не является строкой, это - (специальная) последовательность, таким образом, специальные правила для печати строки не применяются. Нам была бы нужна другая область, которая просто берет строку и возвращает точно эту строку в ее "print" паз. К счастью, MuPAD уже имеет такую область, stdlib::Exposed:

Example::print :=
  x -> myexprseq(stdlib::Exposed("--- \n--\n-\n--\n---"),
                 op(x)):
print(e):

---
--
-   1
--
---

Для выражений с более высоким выходом вы видите, что выравнивание строки является постоянным:

new(Example,x^(1/n));
new(Example,x/y)

---
--   1/n
-   x
--
---

---
--  x
-   -
--  y
---

Чтобы изменить это выравнивание, замените \n \b, таким образом, делая линию это отключает “базовую линию” строки:

Example::print :=
  x -> myexprseq(stdlib::Exposed("--- \b--\n-\n--\n---"),
                 op(x)):
print(e+2):

--- 1 + 2
--
-
--
---

Когда несколько \b появитесь в строке, первый взят в качестве определения базисной линии:

Example::print :=
  x -> myexprseq(stdlib::Exposed("--- \n--\n-\b--\b---"),
                 op(x)):
print(e+2):

---
--
-   1 + 2
--
---

Возвращаемые значения

print возвращает пустой объект null() из типа DOM_NULL.

Перегруженный

object1, object2