doc/info/ru/Operators.texi

   1 @c Language=Russian
   2 @c Encoding=UTF-8
   3 @c File=Operators.texi
   4 @c OriginalRevision=1.49
   5 @c TranslatedBy: (c) 2007-11-06 Andrey Siver <ihep-2005@yandex.ru>
   6
   7
   8 @menu
   9 * N-арные операторы (nary)::
  10 * Безфиксные операторы (nofix)::
  11 * Постфиксные операторы (postfix)::
  12 * Префиксные операторы (prefix)::
  13 * Арифметические операторы::
  14 * Операторы отношения::
  15 * Общие операторы::
  16 @end menu
  17
  18 @c FOLLOWING @NODES SHOULD BE CHANGED TO @DEFFN
  19 @c SINCE NARY, NOFIX, POSTFIX, AND PREFIX ARE ALL MAXIMA FUNCTIONS
  20
  21 @node N-арные операторы (nary), Безфиксные операторы (nofix), Операторы, Операторы
  22 @section N-арные операторы (nary)
  23 N-арный @code{nary} оператор используется для того, чтобы задать функцию любого числа аргументов, каждый из которых разделен
  24 оператором, например A+B или A+B+C. Функция @code{nary("x")} - синтаксическое
  25 расширение функции для объявления @code{x} как n-арный оператор.
  26 Функции могут быть объявлены n-арными.
  27 Если @code{declare(j,nary);} выполнено, это указывает упрощателю (simplifier) то,
  28 что требуется упрощение, то есть, например, @code{j(j(a,b),j(c,d))} упростится до @code{j(a, b, c, d)}.
  29
  30 См. также @code{Синтаксис}.
  31
  32 @opencatbox{Категории:}
  33 @category{Операторы}
  34 @category{Синтаксис}
  35 @closecatbox
  36
  37 @node Безфиксные операторы (nofix), Постфиксные операторы (postfix), N-арные операторы (nary), Операторы
  38 @section Безфиксные операторы (nofix)
  39 Безфиксные операторы (@code{nofix}, операторы без аргументов) используются, чтобы обозначить функции без аргументов.
  40 Простое присутствие такого оператора в команде вызовет то, что
  41 соответствующая функция будет вычислена.  Например, когда набирают
  42 "exit;" для выхода из Maxima, "exit" ведет себя аналогично
  43 безфиксному оператору. Функция @code{nofix("x")} - это функция расширения,
  44 которая объявляет @code{x} как безфиксный оператор.
  45
  46 См. также @code{Синтаксис}.
  47
  48 @opencatbox{Категории:}
  49 @category{Операторы}
  50 @category{Синтаксис}
  51 @closecatbox
  52
  53 @node Постфиксные операторы (postfix), Префиксные операторы (prefix), Безфиксные операторы (nofix), Операторы
  54 @section Постфиксные операторы (postfix)
  55 Постфиксные операторы (@code{postfix}), как и префиксные операторы, обозначают функции
  56 одного аргумента, но в этом случае этот аргумент непосредственно
  57 предшествует появлению этого оператора в входной строке, например 3!.
  58 Функция @code{postfix("x")} - это функция синтаксического расширения,
  59 которая объявлять @code{x} как постфиксный оператор.
  60
  61 См. также @code{Синтаксис}.
  62
  63 @opencatbox{Категории:}
  64 @category{Операторы}
  65 @category{Синтаксис}
  66 @closecatbox
  67
  68 @node Префиксные операторы (prefix), Арифметические операторы, Постфиксные операторы (postfix), Операторы
  69 @section Префиксные операторы (prefix)
  70 Префиксный оператор (@code{prefix}) обозначает функцию одного
  71 аргумента, который непосредственно идет за вхождением оператора.
  72 @code{prefix("x")} - это функция синтаксического расширения, которая объявляет @code{x} как префиксный оператор.
  73
  74 См. также @code{Синтаксис}.
  75
  76 @opencatbox{Категории:}
  77 @category{Операторы}
  78 @category{Синтаксис}
  79 @closecatbox
  80
  81 @node Арифметические операторы, Операторы отношения, Префиксные операторы (prefix), Операторы
  82 @section Арифметические операторы
  83
  84 @deffn {Оператор} +
  85 @ifinfo
  86 @fnindex Сложение
  87 @end ifinfo
  88 @deffnx {Оператор} -
  89 @ifinfo
  90 @fnindex Вычитание
  91 @end ifinfo
  92 @deffnx {Оператор} *
  93 @ifinfo
  94 @fnindex Умножение
  95 @end ifinfo
  96 @deffnx {Оператор} /
  97 @ifinfo
  98 @fnindex Деление
  99 @end ifinfo
 100 @deffnx {Оператор} ^
 101 @ifinfo
 102 @fnindex Возведение в степень
 103 @end ifinfo
 104
 105 Символы @code{+}, @code{*}, @code{/} и @code{^} обозначают
 106 суммирование, умножение, деление и возведение в степень, соответственно.
 107 Имена этих операторов @code{"+"}, @code{"*"}, @code{"/"} и @code{"^"}
 108 могут появляться там, где требуется имя функции или оператора.
 109
 110 Символы @code{+} и @code{-} представляют унарное суммирование и вычитание, соответственно,
 111 и имена этих операторов: @code{"+"} и @code{"-"}, соответственно.
 112
 113 Вычитание @code{a - b} представляется в Maxima как суммирование @code{a + (- b)}.
 114 Выражения, такие как @code{a + (- b)}, отображаются как вычитание.
 115 Maxima распознает @code{"-"} только как имя унарного оператора вычитания,
 116 а не как имя бинарного оператора вычитания.
 117
 118 Деление @code{a / b} представляется в Maxima как умножение, @code{a * b^(- 1)}.
 119 Выражения, такие как @code{a * b^(- 1)}, отображаются как деление.
 120 Maxima распознает @code{"/"} как имя оператора деления.
 121
 122 Суммирование и умножение - n-арные (n-ary), коммутативные операторы.
 123 Деление и возведение в степень - бинарные, некоммутативные операторы.
 124
 125 Maxima сортирует операнды коммутативных операторов для конструирования канонического представления.
 126 Во внутреннем хранилище упорядочивание управляется с помощью @code{orderlessp}.
 127 Для отображения, упорядочивание при суммировании управляется с помощью @code{ordergreatp},
 128 а для умножения, флаг тот же, что и для внутреннего упорядочивания.
 129
 130 Арифметические вычисления выполняются для буквальных чисел
 131 (целых, рациональных, обыкновенных чисел с плавающей точкой и чисел с плавающей точкой повышенной точности (bigfloat)).
 132 За исключением возведения в степень, все арифметические операции для чисел упрощаются до чисел.
 133 Возведение в степень упрощается до числа, в случае если, либо операнд является обыкновенным числом с плавающей точкой
 134 или числом с плавающей точкой повышенной точности (bigfloat),
 135 или если результат есть точное целое или рациональное число;
 136 иначе возведение в степень может быть упрощено до @code{sqrt} или другого возведения в степень,
 137 или оставлено неизменным.
 138
 139 В арифметических вычислениях имеет место приведение типов значений результата:
 140 если любой операнд есть bigfloat, то результат будет bigfloat;
 141 или же, если любой операнд есть обыкновенное число с плавающей точкой,
 142 результат будет обыкновенным числом с плавающей точкой;
 143 или же, если операнды являются рациональными или целыми значениями,
 144 то  результат будет рациональным или целым.
 145
 146 Арифметические вычисления являются упрощением, а не в вычислением.
 147 Таким образом, арифметические операции выполняется в экранированных (но упрощенных) выражениях.
 148
 149 Арифметические операции применяются элемент-за-элементом
 150 к спискам, когда глобальный флаг @code{listarith} есть @code{true},
 151 и всегда применяется элемент-за-элементом к матрицам.
 152 Когда один операнд есть список или матрица и другой есть операнд некоторого другого типа,
 153 то другой операнд объединяется с каждым из элементом списка или матрицы.
 154
 155 Примеры:
 156
 157 Суммирование и умножение являются n-арными (n-ary) коммутативными операторами.
 158 Maxima сортирует операнды для того, чтобы сконструировать каноническое представление.
 159 Имена этих операторов @code{"+"} и @code{"*"}.
 160 @c ===beg===
 161 @c c + g + d + a + b + e + f;
 162 @c [op (%), args (%)];
 163 @c c * g * d * a * b * e * f;
 164 @c [op (%), args (%)];
 165 @c apply ("+", [a, 8, x, 2, 9, x, x, a]);
 166 @c apply ("*", [a, 8, x, 2, 9, x, x, a]);
 167 @c ===end===
 168
 169 @example
 170 (%i1) c + g + d + a + b + e + f;
 171 (%o1)               g + f + e + d + c + b + a
 172 (%i2) [op (%), args (%)];
 173 (%o2)              [+, [g, f, e, d, c, b, a]]
 174 (%i3) c * g * d * a * b * e * f;
 175 (%o3)                     a b c d e f g
 176 (%i4) [op (%), args (%)];
 177 (%o4)              [*, [a, b, c, d, e, f, g]]
 178 (%i5) apply ("+", [a, 8, x, 2, 9, x, x, a]);
 179 (%o5)                    3 x + 2 a + 19
 180 (%i6) apply ("*", [a, 8, x, 2, 9, x, x, a]);
 181                                  2  3
 182 (%o6)                       144 a  x
 183 @end example
 184
 185 Деление и возведение в степень - бинарные, некоммутативные операторы.
 186 Имена этих операторов @code{"/"} и @code{"^"}.
 187 @c ===beg===
 188 @c [a / b, a ^ b];
 189 @c [map (op, %), map (args, %)];
 190 @c [apply ("/", [a, b]), apply ("^", [a, b])];
 191 @c ===end===
 192
 193 @example
 194 (%i1) [a / b, a ^ b];
 195                               a   b
 196 (%o1)                        [-, a ]
 197                               b
 198 (%i2) [map (op, %), map (args, %)];
 199 (%o2)              [[/, ^], [[a, b], [a, b]]]
 200 (%i3) [apply ("/", [a, b]), apply ("^", [a, b])];
 201                               a   b
 202 (%o3)                        [-, a ]
 203                               b
 204 @end example
 205
 206 Вычитание и деление внутренне представляются
 207 в терминах суммирования и умножения, соответственно.
 208 @c ===beg===
 209 @c [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
 210 @c [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
 211 @c ===end===
 212
 213 @example
 214 (%i1) [inpart (a - b, 0), inpart (a - b, 1), inpart (a - b, 2)];
 215 (%o1)                      [+, a, - b]
 216 (%i2) [inpart (a / b, 0), inpart (a / b, 1), inpart (a / b, 2)];
 217                                    1
 218 (%o2)                       [*, a, -]
 219                                    b
 220 @end example
 221
 222 Вычисления выполняются над буквальными числами.
 223 Выполняется приведение типов значений результата.
 224 @c ===beg===
 225 @c 17 + b - (1/2)*29 + 11^(2/4);
 226 @c [17 + 29, 17 + 29.0, 17 + 29b0];
 227 @c ===end===
 228
 229 @example
 230 (%i1) 17 + b - (1/2)*29 + 11^(2/4);
 231                                        5
 232 (%o1)                   b + sqrt(11) + -
 233                                        2
 234 (%i2) [17 + 29, 17 + 29.0, 17 + 29b0];
 235 (%o2)                   [46, 46.0, 4.6b1]
 236 @end example
 237
 238 Арифметические вычисления являются упрощением, а не вычислением.
 239 @c ===beg===
 240 @c simp : false;
 241 @c '(17 + 29*11/7 - 5^3);
 242 @c simp : true;
 243 @c '(17 + 29*11/7 - 5^3);
 244 @c ===end===
 245
 246 @example
 247 (%i1) simp : false;
 248 (%o1)                         false
 249 (%i2) '(17 + 29*11/7 - 5^3);
 250                               29 11    3
 251 (%o2)                    17 + ----- - 5
 252                                 7
 253 (%i3) simp : true;
 254 (%o3)                         true
 255 (%i4) '(17 + 29*11/7 - 5^3);
 256                                 437
 257 (%o4)                         - ---
 258                                  7
 259 @end example
 260
 261 Арифметические операции выполняется элемент-за-элементом для списков
 262 (в зависимости от значения @code{listarith}) и матриц.
 263 @c ===beg===
 264 @c matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
 265 @c 5 * matrix ([a, x], [h, u]);
 266 @c listarith : false;
 267 @c [a, c, m, t] / [1, 7, 2, 9];
 268 @c [a, c, m, t] ^ x;
 269 @c listarith : true;
 270 @c [a, c, m, t] / [1, 7, 2, 9];
 271 @c [a, c, m, t] ^ x;
 272 @c ===end===
 273
 274 @example
 275 (%i1) matrix ([a, x], [h, u]) - matrix ([1, 2], [3, 4]);
 276                         [ a - 1  x - 2 ]
 277 (%o1)                   [              ]
 278                         [ h - 3  u - 4 ]
 279 (%i2) 5 * matrix ([a, x], [h, u]);
 280                           [ 5 a  5 x ]
 281 (%o2)                     [          ]
 282                           [ 5 h  5 u ]
 283 (%i3) listarith : false;
 284 (%o3)                         false
 285 (%i4) [a, c, m, t] / [1, 7, 2, 9];
 286                           [a, c, m, t]
 287 (%o4)                     ------------
 288                           [1, 7, 2, 9]
 289 (%i5) [a, c, m, t] ^ x;
 290                                       x
 291 (%o5)                     [a, c, m, t]
 292 (%i6) listarith : true;
 293 (%o6)                         true
 294 (%i7) [a, c, m, t] / [1, 7, 2, 9];
 295                               c  m  t
 296 (%o7)                     [a, -, -, -]
 297                               7  2  9
 298 (%i8) [a, c, m, t] ^ x;
 299                           x   x   x   x
 300 (%o8)                   [a , c , m , t ]
 301 @end example
 302
 303 @opencatbox{Категории:}
 304 @category{Операторы}
 305 @closecatbox
 306
 307 @end deffn
 308
 309 @deffn {Оператор} **
 310 Оператор возведения в степень.
 311 Maxima распознает @code{**} как тот же оператор, что и @code{^} при вводе,
 312 и он отображается как @code{^} в 1D (одномерном) выводе,
 313 или в виде показателя степени как верхний индекс в 2D (двумерном) выводе.
 314
 315 Функция @code{fortran} выводит оператор возведения в степень как @code{**},
 316 не в зависимости от того, как он был задан при вводе, как @code{**} или @code{^}.
 317
 318 Примеры:
 319
 320 @c ===beg===
 321 @c is (a**b = a^b);
 322 @c x**y + x^z;
 323 @c string (x**y + x^z);
 324 @c fortran (x**y + x^z);
 325 @c ===end===
 326 @example
 327 (%i1) is (a**b = a^b);
 328 (%o1)                         true
 329 (%i2) x**y + x^z;
 330                               z    y
 331 (%o2)                        x  + x
 332 (%i3) string (x**y + x^z);
 333 (%o3)                        x^z+x^y
 334 (%i4) fortran (x**y + x^z);
 335       x**z+x**y
 336 (%o4)                         done
 337 @end example
 338
 339 @opencatbox{Категории:}
 340 @category{Операторы}
 341 @closecatbox
 342
 343 @end deffn
 344
 345 @node Операторы отношения, Общие операторы, Арифметические операторы, Операторы
 346 @section Операторы отношения
 347
 348 @deffn {Оператор} <
 349 @ifinfo
 350 @fnindex Меньше
 351 @end ifinfo
 352 @deffnx {Оператор} <=
 353 @ifinfo
 354 @fnindex Меньше или равно
 355 @end ifinfo
 356 @deffnx {Оператор} >=
 357 @ifinfo
 358 @fnindex Больше или равно
 359 @end ifinfo
 360 @deffnx {Оператор} >
 361 @ifinfo
 362 @fnindex Больше
 363 @end ifinfo
 364
 365 Символы @code{<} , @code{<=} , @code{>=} и @code{>} представляют отношения
 366 меньше, меньше или равно, больше или равно и больше, соответственно.
 367 Имена этих операторов есть @code{"<"} , @code{"<="} , @code{">="} и @code{">"}.
 368 Эти имена могут применяться в случае, если требуется имя функции или оператора.
 369
 370 Данные операторы отношения являются бинарными.
 371 Конструкции типа @code{a < b < c} недопустимы в Maxima.
 372
 373 Операторы отношения вычисляются до логических значений функциями @code{is} и @code{maybe},
 374 и программными конструкциями @code{if}, @code{while} и @code{unless}.
 375 В других случаях операторы отношения не вычисляются или упрощаются до логических значений,
 376 хотя аргументы операторов отношения вычисляются
 377 (если вычисление не блокировано при помощи оператора кавычка).
 378
 379 Если выражение отношения не может быть вычислено до логического значения @code{true} или @code{false},
 380 то поведение @code{is} и @code{if} управляется глобальным флагом @code{prederror}.
 381 Если значение @code{prederror} равно @code{true},
 382 то @code{is} и @code{if} вызывает ошибку.
 383 Если значение @code{prederror} равно @code{false},
 384 то @code{is} возвращает @code{unknown}
 385 а @code{if} возвращает частично-вычисленное условное выражение.
 386
 387 @code{maybe} всегда ведет себя так, если бы @code{prederror} равнялось @code{false},
 388 а @code{while} и @code{unless} всегда ведут себя так, если бы @code{prederror} равнялось @code{true}.
 389
 390 Операторы отношения не дистрибутивны по отношению к спискам и другим конструкциям.
 391
 392 См. также @code{=} , @code{#} , @code{equal} и @code{notequal}.
 393
 394 Примеры:
 395
 396 Операторы отношения вычисляются до логических значений некоторыми функциями
 397 и программными конструкциями.
 398
 399 @c ===beg===
 400 @c [x, y, z] : [123, 456, 789];
 401 @c is (x < y);
 402 @c maybe (y > z);
 403 @c if x >= z then 1 else 0;
 404 @c block ([S], S : 0, for i:1 while i <= 100 do S : S + i, return (S));
 405 @c ===end===
 406 @example
 407 (%i1) [x, y, z] : [123, 456, 789];
 408 (%o1)                    [123, 456, 789]
 409 (%i2) is (x < y);
 410 (%o2)                         true
 411 (%i3) maybe (y > z);
 412 (%o3)                         false
 413 (%i4) if x >= z then 1 else 0;
 414 (%o4)                           0
 415 (%i5) block ([S], S : 0, for i:1 while i <= 100 do S : S + i, return (S));
 416 (%o5)                         5050
 417 @end example
 418
 419 Во всех других случаях операторы отношения не вычисляются или упрощаются до логических
 420 значений, хотя их аргументы вычисляются.
 421
 422 @c ===beg===
 423 @c [x, y, z] : [123, 456, 789];
 424 @c [x < y, y <= z, z >= y, y > z];
 425 @c map (is, %);
 426 @c ===end===
 427 @example
 428 (%o1)                    [123, 456, 789]
 429 (%i2) [x < y, y <= z, z >= y, y > z];
 430 (%o2)    [123 < 456, 456 <= 789, 789 >= 456, 456 > 789]
 431 (%i3) map (is, %);
 432 (%o3)               [true, true, true, false]
 433 @end example
 434
 435 @opencatbox{Категории:}
 436 @category{Операторы}
 437 @closecatbox
 438
 439 @end deffn
 440
 441 @node Общие операторы, , Операторы отношения, Операторы
 442 @section Общие операторы
 443
 444 @deffn {Оператор} ^^
 445 @ifinfo
 446 @fnindex Некоммутативное возведение в степень
 447 @end ifinfo
 448
 449 Оператор некоммутативного возведение в степень.
 450 @code{^^} - оператор некоммутативного возведение в степень, соответствующий  некоммутативному умножению @code{.},
 451 ровно так же как обычный оператор возведение в степень @code{^} соответствует коммутативному умножению @code{*}.
 452
 453 Некоммутативное возведение в степень отображается как @code{^^} в 1D (одномерном) выводе,
 454 и в виде показателя степени как верхний индекс в угловых скобка @code{< >} в 2D (двумерном) выводе.
 455
 456 Примеры:
 457
 458 @c ===beg===
 459 @c a . a . b . b . b + a * a * a * b * b;
 460 @c string (a . a . b . b . b + a * a * a * b * b);
 461 @c ===end===
 462 @example
 463 (%i1) a . a . b . b . b + a * a * a * b * b;
 464                         3  2    <2>    <3>
 465 (%o1)                  a  b  + a    . b
 466 (%i2) string (a . a . b . b . b + a * a * a * b * b);
 467 (%o2)                  a^3*b^2+a^^2 . b^^3
 468 @end example
 469
 470 @opencatbox{Категории:}
 471 @category{Операторы}
 472 @closecatbox
 473
 474 @end deffn
 475
 476 @deffn {Оператор} !
 477 @ifinfo
 478 @fnindex Факториал
 479 @end ifinfo
 480 Оператор факториала.
 481 Для всех комплексных чисел @code{x} (включая целые, рациональные, и вещественные числа),
 482 за исключением отрицательных целых, @code{x!} задается как @code{gamma(x+1)}.
 483
 484 Для целого @code{x}, @code{x!} упрощается до произведения целых чисел от
 485  1 до @code{x} включительно.
 486 @code{0!} упрощается до 1.
 487 Для чисел с плавающей точкой @code{x}, @code{x!} упрощается  до значения @code{gamma (x+1)}.
 488 Для @code{x} равных @code{n/2}, где @code{n} - нечетное целое,
 489 @code{x!} упрощается до рационального множителя, умноженного на @code{sqrt (%pi)}
 490 (т. к. @code{gamma (1/2)} равно @code{sqrt (%pi)}).
 491 Если @code{x} - что то еще, то @code{x!} не упрощается.
 492
 493 Переменные @code{factlim}, @code{minfactorial} и @code{factcomb} управляют упрощением выражений,
 494 содержащих факториалы.
 495
 496 Функции @code{gamma}, @code{bffac} и @code{cbffac}
 497 являются разновидностями гамма функции.
 498 @code{makegamma} заменяет @code{gamma} для факториалов и связанных функций.
 499
 500 См. также @code{binomial}.
 501
 502 Факториал целого, полуцелого или аргумента с плавающей точкой, упрощается
 503 если операнд не больше чем @code{factlim}.
 504
 505 @c ===beg===
 506 @c factlim : 10;
 507 @c [0!, (7/2)!, 4.77!, 8!, 20!];
 508 @c ===end===
 509 @example
 510 (%i1) factlim : 10;
 511 (%o1)                          10
 512 (%i2) [0!, (7/2)!, 4.77!, 8!, 20!];
 513             105 sqrt(%pi)
 514 (%o2)   [1, -------------, 81.44668037931199, 40320, 20!]
 515                  16
 516 @end example
 517
 518 Факториал комплексного числа, известной константы, или выражение общего вида не упрощается.
 519 Но в этом случае возможно упростить факториал после вычисления операнда.
 520
 521 @c ===beg===
 522 @c [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
 523 @c ev (%, numer, %enumer);
 524 @c ===end===
 525 @example
 526 (%i1) [(%i + 1)!, %pi!, %e!, (cos(1) + sin(1))!];
 527 (%o1)      [(%i + 1)!, %pi!, %e!, (sin(1) + cos(1))!]
 528 (%i2) ev (%, numer, %enumer);
 529 (%o2) [(%i + 1)!, 7.188082728976037, 4.260820476357,
 530                                                1.227580202486819]
 531 @end example
 532
 533 Факториал символа, не имеющего значения, не упрощается.
 534
 535 @c ===beg===
 536 @c kill (foo);
 537 @c foo!;
 538 @c ===end===
 539 @example
 540 (%i1) kill (foo);
 541 (%o1)                         done
 542 (%i2) foo!;
 543 (%o2)                         foo!
 544 @end example
 545
 546 Факториалы упрощаются, а не вычисляются.
 547 Таким образом, @code{x!} можно заменять даже в экранированном (quoted) выражении.
 548
 549 @c ===beg===
 550 @c '([0!, (7/2)!, 4.77!, 8!, 20!]);
 551 @c ===end===
 552 @example
 553 (%i1) '([0!, (7/2)!, 4.77!, 8!, 20!]);
 554           105 sqrt(%pi)
 555 (%o1) [1, -------------, 81.44668037931199, 40320,
 556                16
 557                                              2432902008176640000]
 558 @end example
 559
 560 @opencatbox{Категории:}
 561 @category{Операторы}
 562 @category{Гамма функции и факториалы}
 563 @closecatbox
 564
 565 @end deffn
 566
 567 @deffn {Оператор} !!
 568 @ifinfo
 569 @fnindex Двойной факториал
 570 @end ifinfo
 571 Оператор двойного факториала.
 572
 573 Для целого, числа с плавающей точкой или рационального числа @code{n},
 574 @code{n!!} вычисляется как произведение @code{n (n-2) (n-4) (n-6) ... (n - 2 (k-1))}
 575 где @code{k} равно @code{entier (n/2)},
 576 то есть, наибольшее целое меньше или равное @code{n/2}.
 577 Заметим, что это определение не совпадает с другими опубликованными определениями
 578 для нецелых аргументов.
 579 @c REPORTED TO BUG TRACKER AS BUG # 1093138 !!!
 580
 581 Для четного (или нечетного) целого @code{n}, @code{n!!} вычисляется как произведение
 582 всех последовательных четных (или нечетных) целых от 2 (или 1) до @code{n} включительно.
 583
 584 Для аргумента @code{n}, который не является целым, числом с плавающей точкой, или рациональным числом,
 585 @code{n!!} дает невычисляемую форму @code{genfact (n, n/2, 2)}.
 586 @c n!! IS NEITHER SIMPLIFIED NOR EVALUATED IN THIS CASE -- MENTION THAT? OR TOO MUCH DETAIL ???
 587
 588 @opencatbox{Категории:}
 589 @category{Операторы}
 590 @category{Гамма функции и факториалы}
 591 @closecatbox
 592
 593 @end deffn
 594
 595 @deffn {Оператор} #
 596 @ifinfo
 597 @fnindex Не равно (синтаксическое неравенство)
 598 @end ifinfo
 599 Обозначает отрицание синтаксического равенства @code{=}.
 600
 601 Заметим, что из-за правил для вычисления предикатных выражений
 602 (в частности из-за того, что @code{not @var{expr}} вызывает вычисление  @var{expr}),
 603 @code{not @var{a} = @var{b}} эквивалентно @code{is(@var{a} # @var{b})},
 604 вместо @code{@var{a} # @var{b}}.
 605
 606 Примеры:
 607
 608 @c ===beg===
 609 @c a = b;
 610 @c is (a = b);
 611 @c a # b;
 612 @c not a = b;
 613 @c is (a # b);
 614 @c is (not a = b);
 615 @c ===end===
 616 @example
 617 (%i1) a = b;
 618 (%o1)                         a = b
 619 (%i2) is (a = b);
 620 (%o2)                         false
 621 (%i3) a # b;
 622 (%o3)                         a # b
 623 (%i4) not a = b;
 624 (%o4)                         true
 625 (%i5) is (a # b);
 626 (%o5)                         true
 627 (%i6) is (not a = b);
 628 (%o6)                         true
 629 @end example
 630
 631 @opencatbox{Категории:}
 632 @category{Операторы}
 633 @closecatbox
 634
 635 @end deffn
 636
 637 @deffn {Оператор} .
 638 @ifinfo
 639 @fnindex Некоммутативное умножение
 640 @end ifinfo
 641 Оператор "точка" предназначен для матричного (некоммутативного) умножения.
 642 Когда @code{"."} используется таким образом, пробелы должны присутствовать с обеих сторон,
 643 то есть @code{A . B}.  Это позволяет различать оператор от десятичной точки в числе с плавающей точкой.
 644
 645 См. также
 646 @code{dot},
 647 @code{dot0nscsimp},
 648 @code{dot0simp},
 649 @code{dot1simp},
 650 @code{dotassoc},
 651 @code{dotconstrules},
 652 @code{dotdistrib},
 653 @code{dotexptsimp},
 654 @code{dotident},
 655 и
 656 @code{dotscrules}.
 657
 658 @opencatbox{Категории:}
 659 @category{Операторы}
 660 @closecatbox
 661
 662 @end deffn
 663
 664 @deffn {Оператор} :
 665 @ifinfo
 666 @fnindex Присваивание
 667 @end ifinfo
 668 Оператор присваивания.
 669
 670 Если левая сторона есть простая переменная (не переменная с индексом),
 671 то @code{:} вычисляет правую сторону присваивания
 672 и присваивает значение с левой частью.
 673
 674 Если левая строна есть индексированный элемент списка, матрица, объявленного Maxima массива или Lisp массива,
 675 то значение правой части присваивается этому элементу.
 676 Индекс должен выделять существующий элемент.
 677 Подобные конструкции нельзя расширить на несуществующие элементы.
 678
 679 Если левая сторона есть индексированный элемент необъявленного массива,
 680 то значение правой части присваивается этому элементу, если таковой уже существует,
 681 или вновь созданному объекту, если он еще не существует.
 682
 683 Если левая строна присваивания есть список простых переменных и/или переменных с индексом, то
 684 правая часть должна вычисляться в список, и элементы этого списка присваиваются
 685 элементам левой части параллельно.
 686
 687 См. также @code{kill} и @code{remvalue},
 688 которые отменяют присваивание.
 689
 690 Примеры:
 691
 692 Присваивание простой переменной.
 693
 694 @c ===beg===
 695 @c a;
 696 @c a : 123;
 697 @c a;
 698 @c ===end===
 699 @example
 700 (%i1) a;
 701 (%o1)                           a
 702 (%i2) a : 123;
 703 (%o2)                          123
 704 (%i3) a;
 705 (%o3)                          123
 706 @end example
 707
 708 Присваивание элементу списка.
 709
 710 @c ===beg===
 711 @c b : [1, 2, 3];
 712 @c b[3] : 456;
 713 @c b;
 714 @c ===end===
 715 @example
 716 (%i1) b : [1, 2, 3];
 717 (%o1)                       [1, 2, 3]
 718 (%i2) b[3] : 456;
 719 (%o2)                          456
 720 (%i3) b;
 721 (%o3)                      [1, 2, 456]
 722 @end example
 723
 724 Присваивание создает необъявленный массив.
 725
 726 @c ===beg===
 727 @c c[99] : 789;
 728 @c c[99];
 729 @c c;
 730 @c arrayinfo (c);
 731 @c listarray (c);
 732 @c ===end===
 733 @example
 734 (%i1) c[99] : 789;
 735 (%o1)                          789
 736 (%i2) c[99];
 737 (%o2)                          789
 738 (%i3) c;
 739 (%o3)                           c
 740 (%i4) arrayinfo (c);
 741 (%o4)                   [hashed, 1, [99]]
 742 (%i5) listarray (c);
 743 (%o5)                         [789]
 744 @end example
 745
 746 Множественные присваивания.
 747
 748 @c ===beg===
 749 @c [a, b, c] : [45, 67, 89];
 750 @c a;
 751 @c b;
 752 @c c;
 753 @c ===end===
 754 @example
 755 (%i1) [a, b, c] : [45, 67, 89];
 756 (%o1)                     [45, 67, 89]
 757 (%i2) a;
 758 (%o2)                          45
 759 (%i3) b;
 760 (%o3)                          67
 761 (%i4) c;
 762 (%o4)                          89
 763 @end example
 764
 765 Множественные присваивания выполняются параллельно.
 766 В этом примере переменные @code{a} и @code{b} обмениваются значениями.
 767
 768 @c ===beg===
 769 @c [a, b] : [33, 55];
 770 @c [a, b] : [b, a];
 771 @c a;
 772 @c b;
 773 @c ===end===
 774 @example
 775 (%i1) [a, b] : [33, 55];
 776 (%o1)                       [33, 55]
 777 (%i2) [a, b] : [b, a];
 778 (%o2)                       [55, 33]
 779 (%i3) a;
 780 (%o3)                          55
 781 (%i4) b;
 782 (%o4)                          33
 783 @end example
 784
 785 @opencatbox{Категории:}
 786 @category{Вычисление}
 787 @category{Операторы}
 788 @closecatbox
 789
 790 @end deffn
 791
 792 @deffn {Оператор} ::
 793 @ifinfo
 794 @fnindex Присваивание (с вычислением левого выражения)
 795 @end ifinfo
 796 Оператор присваивания.
 797
 798 Оператор @code{::} аналогичен оператору присваивания @code{:}
 799 за исключением того, что @code{::} вычисляет свою левую часть наряду с вычислением правой части.
 800
 801 Примеры:
 802
 803 @c ===beg===
 804 @c x : 'foo;
 805 @c x :: 123;
 806 @c foo;
 807 @c x : '[a, b, c];
 808 @c x :: [11, 22, 33];
 809 @c a;
 810 @c b;
 811 @c c;
 812 @c ===end===
 813 @example
 814 (%i1) x : 'foo;
 815 (%o1)                          foo
 816 (%i2) x :: 123;
 817 (%o2)                          123
 818 (%i3) foo;
 819 (%o3)                          123
 820 (%i4) x : '[a, b, c];
 821 (%o4)                       [a, b, c]
 822 (%i5) x :: [11, 22, 33];
 823 (%o5)                     [11, 22, 33]
 824 (%i6) a;
 825 (%o6)                          11
 826 (%i7) b;
 827 (%o7)                          22
 828 (%i8) c;
 829 (%o8)                          33
 830 @end example
 831
 832 @opencatbox{Категории:}
 833 @category{Вычисление}
 834 @category{Операторы}
 835 @closecatbox
 836
 837 @end deffn
 838
 839 @deffn {Оператор} ::=
 840 @ifinfo
 841 @fnindex Определение макро функции
 842 @end ifinfo
 843 Оператор определения макро функции.
 844 @code{::=} задает функцию (называемую "макрос" по историческим причинам)
 845 которое экранирует (quote) свои аргументы,
 846 и выражение, которое она возвращает (называемое "макро расширение"),
 847 вычисляется в том контексте, из которого этот макрос был вызван.
 848 В других отношениях макро функция такая же как и обыкновенная функция.
 849
 850 Функция @code{macroexpand} возвращает макро расширение (без ее вычисления).
 851 @code{macroexpand (foo (x))} следующее за @code{''%} эквивалентно @code{foo (x)},
 852 где @code{foo} есть макро функция.
 853
 854 Оператор @code{::=} помещает имя новой макро функции в глобальный список @code{macros}.
 855 Функции @code{kill}, @code{remove} и @code{remfunction} удаляет определения макро функций
 856 и удаляет имена из @code{macros}.
 857
 858 Функции @code{fundef} или @code{dispfun}, соответственно,
 859 возвращает определение макро функции или присваивает его метке.
 860
 861 Макро функции обычно содержат @code{buildq} и @code{splice}
 862 выражения для конструирования выражения,
 863 которое затем вычисляется.
 864
 865 Примеры.
 866
 867 Макро функция экранирует свои аргументы,
 868 так что сообщение (1) показывает выражение @code{y - z}, а не значение @code{y - z}.
 869 Макро расширение (экранированное выражение @code{'(print ("(2) x  равно ", x))}
 870 вычисляется в том контексте, из которого этот макрос был вызван,
 871 печатая сообщение (2).
 872
 873 @c ===beg===
 874 @c x: %pi;
 875 @c y: 1234;
 876 @c z: 1729 * w;
 877 @c printq1 (x) ::= block (print ("(1) x is equal to", x),
 878 @c                                 '(print ("(2) x is equal to", x)));
 879 @c printq1 (y - z);
 880 @c ===end===
 881 @example
 882 (%i1) x: %pi;
 883 (%o1)                          %pi
 884 (%i2) y: 1234;
 885 (%o2)                         1234
 886 (%i3) z: 1729 * w;
 887 (%o3)                        1729 w
 888 (%i4) printq1 (x) ::= block (print ("(1) x is equal to", x),
 889       '(print ("(2) x is equal to", x)));
 890 (%o4) printq1(x) ::= block(print("(1) x is equal to", x),
 891                                 '(print("(2) x is equal to", x)))
 892 (%i5) printq1 (y - z);
 893 (1) x is equal to y - z
 894 (2) x is equal to %pi
 895 (%o5)                          %pi
 896 @end example
 897
 898 Обыкновенная функция вычисляет свои аргументы, так что сообщение (1) показывает значение @code{y - z}.
 899 Возвращаемое значение не вычисляется, так что сообщение (2) не печатается
 900 до момента явного вычисления @code{''%}.
 901
 902 @c ===beg===
 903 @c x: %pi;
 904 @c y: 1234;
 905 @c z: 1729 * w;
 906 @c printe1 (x) := block (print ("(1) x is equal to", x),
 907 @c       '(print ("(2) x is equal to", x)));
 908 @c printe1 (y - z);
 909 @c ''%;
 910 @c ===end===
 911 @example
 912 (%i1) x: %pi;
 913 (%o1)                          %pi
 914 (%i2) y: 1234;
 915 (%o2)                         1234
 916 (%i3) z: 1729 * w;
 917 (%o3)                        1729 w
 918 (%i4) printe1 (x) := block (print ("(1) x is equal to", x),
 919       '(print ("(2) x is equal to", x)));
 920 (%o4) printe1(x) := block(print("(1) x is equal to", x),
 921                                 '(print("(2) x is equal to", x)))
 922 (%i5) printe1 (y - z);
 923 (1) x is equal to 1234 - 1729 w
 924 (%o5)              print((2) x is equal to, x)
 925 (%i6) ''%;
 926 (2) x is equal to %pi
 927 (%o6)                          %pi
 928 @end example
 929
 930 Функция @code{macroexpand} возвращает макро расширение.
 931 Выражение @code{macroexpand (foo (x))}, идущее перед @code{''%} эквивалентно @code{foo (x)},
 932 когда @code{foo} есть макро функция.
 933
 934 @c ===beg===
 935 @c x: %pi;
 936 @c y: 1234;
 937 @c z: 1729 * w;
 938 @c g (x) ::= buildq ([x], print ("x is equal to", x));
 939 @c macroexpand (g (y - z));
 940 @c ''%;
 941 @c g (y - z);
 942 @c ===end===
 943 @example
 944 (%i1) x: %pi;
 945 (%o1)                          %pi
 946 (%i2) y: 1234;
 947 (%o2)                         1234
 948 (%i3) z: 1729 * w;
 949 (%o3)                        1729 w
 950 (%i4) g (x) ::= buildq ([x], print ("x is equal to", x));
 951 (%o4)    g(x) ::= buildq([x], print("x is equal to", x))
 952 (%i5) macroexpand (g (y - z));
 953 (%o5)              print(x is equal to, y - z)
 954 (%i6) ''%;
 955 x is equal to 1234 - 1729 w
 956 (%o6)                     1234 - 1729 w
 957 (%i7) g (y - z);
 958 x is equal to 1234 - 1729 w
 959 (%o7)                     1234 - 1729 w
 960 @end example
 961
 962 @opencatbox{Категории:}
 963 @category{Определение функций}
 964 @category{Операторы}
 965 @closecatbox
 966
 967 @end deffn
 968
 969 @anchor{:=}
 970 @deffn {Оператор} :=
 971 @ifinfo
 972 @fnindex Определение функции
 973 @end ifinfo
 974
 975 Оператор определения функции.
 976
 977 @code{@var{f}(@var{x_1}, ..., @var{x_n}) := @var{expr}}
 978 определяет функцию с именем @var{f}, аргументами @var{x_1}, ..., @var{x_n} и телом функции @var{expr}.
 979 Оператор @code{:=} никогда не вычисляет тело функции (если только вычисление не задано явно оператором
 980 кавычка-кавычка @code{'@w{}'}).
 981 Функция заданная таким образом может быть обыкновенной Maxima функцией (с аргументами, заключенными в скобки)
 982 или функцией массивом (с аргументами, заключенными в квадратные скобки).
 983
 984 Когда последний или единственный аргумент функции @var{x_n} есть список из одного элемента,
 985 функция, заданная @code{:=} принимает переменное число аргументов.
 986 Фактические аргументы присваиваются один-в-один формальным аргументам @var{x_1}, ..., @var{x_(n - 1)},
 987 и любые дальнейшие фактические аргументы, если присутствуют, присваиваются к @var{x_n} как список.
 988
 989 Все определения функций появляются в том же пространстве имен;
 990 задав функцию @code{f} внутри другой функции @code{g}, определение
 991 не ограничивает зону видимости @code{f} в @code{g}.
 992
 993 Если некоторый формальный аргумент @var{x_k} есть экранированный (quoted) символ,
 994 функция, заданная с помощью @code{:=}, не вычисляет соответствующий фактический аргумент.
 995 В противном случае, все фактические аргументы вычисляются.
 996
 997 См. также @code{define} и @code{::=}.
 998
 999 Примеры:
1000
1001 @code{:=} никогда не вычисляет тело функции (если только явно не задано вычисление).
1002
1003 @c ===beg===
1004 @c expr : cos(y) - sin(x);
1005 @c F1 (x, y) := expr;
1006 @c F1 (a, b);
1007 @c F2 (x, y) := ''expr;
1008 @c F2 (a, b);
1009 @c ===end===
1010 @example
1011 (%i1) expr : cos(y) - sin(x);
1012 (%o1)                    cos(y) - sin(x)
1013 (%i2) F1 (x, y) := expr;
1014 (%o2)                   F1(x, y) := expr
1015 (%i3) F1 (a, b);
1016 (%o3)                    cos(y) - sin(x)
1017 (%i4) F2 (x, y) := ''expr;
1018 (%o4)              F2(x, y) := cos(y) - sin(x)
1019 (%i5) F2 (a, b);
1020 (%o5)                    cos(b) - sin(a)
1021 @end example
1022
1023 Функция, заданная @code{:=}, может быть обыкновенной Maxima функцией или функцией массивом.
1024
1025 @c ===beg===
1026 @c G1 (x, y) := x.y - y.x;
1027 @c G2 [x, y] := x.y - y.x;
1028 @c ===end===
1029 @example
1030 (%i1) G1 (x, y) := x.y - y.x;
1031 (%o1)               G1(x, y) := x . y - y . x
1032 (%i2) G2 [x, y] := x.y - y.x;
1033 (%o2)                G2     := x . y - y . x
1034                        x, y
1035 @end example
1036
1037 Когда последний или единственный аргумент функции @var{x_n} есть список из одного элемента,
1038 функция, заданная @code{:=}, принимает переменное число аргументов.
1039
1040 @c ===beg===
1041 @c H ([L]) := apply ("+", L);
1042 @c H (a, b, c);
1043 @c ===end===
1044 @example
1045 (%i1) H ([L]) := apply ("+", L);
1046 (%o1)                H([L]) := apply("+", L)
1047 (%i2) H (a, b, c);
1048 (%o2)                       c + b + a
1049 @end example
1050
1051 @opencatbox{Категории:}
1052 @category{Определение функций}
1053 @category{Операторы}
1054 @closecatbox
1055
1056 @end deffn
1057
1058 @deffn {Оператор} =
1059 @ifinfo
1060 @fnindex Оператор равенства
1061 @fnindex Равенство (синтаксическое равенство)
1062 @end ifinfo
1063 Оператор равенства.
1064
1065 Выражение @code{@var{a} = @var{b}}, само по себе, представляет собой
1066 невычисляемое уравнение, которое может или может не выполняться.
1067 Невычисляемые уравнения могут появляться как аргументы в @code{solve} и @code{algsys},
1068 или в некоторых других функциях.
1069
1070 Функция @code{is} вычисляет @code{=} до логического значения.
1071 @code{is(@var{a} = @var{b})} вычисляет @code{@var{a} = @var{b}} в @code{true}, когда @var{a} и @var{b}
1072 тождественны. То есть, @var{a} и @var{b} есть атомы, которые идентичны,
1073 или они не атомы и их операторы идентичны и их аргументы идентичны.
1074 В противном случае, @code{is(@var{a} = @var{b})} вычисляется в @code{false};
1075 он никогда не вычисляется в @code{unknown}.
1076 Когда @code{is(@var{a} = @var{b})} есть @code{true}, говорят что @var{a} и @var{b} синтаксически равны,
1077 в противоположность эквивалентным выражениям, для которых @code{is(equal(@var{a}, @var{b}))} есть @code{true}.
1078 Выражения могут быть равны, но синтаксически не равны.
1079
1080 Отрицание @code{=} представляется как @code{#}.
1081 Как и в случае с @code{=}, выражение @code{@var{a} # @var{b}}, само по себе, не вычисляется.
1082 @code{is(@var{a} # @var{b})} вычисляется @code{@var{a} # @var{b}} до
1083 @code{true} или @code{false}.
1084
1085 Кроме @code{is},
1086 некоторые другие операторы вычисляют @code{=} и @code{#} до @code{true} или @code{false},
1087 а именно @code{if}, @code{and}, @code{or} и @code{not}.
1088
1089 Заметим, что из-за правил для вычисления предикатных выражений
1090 (в частности из-за того, что @code{not @var{expr}} вызывает вычисление @var{expr}),
1091 @code{not @var{a} = @var{b}} эквивалентно @code{is(@var{a} # @var{b})},
1092 а не @code{@var{a} # @var{b}}.
1093
1094 @code{rhs} и @code{lhs} возвращают правую и левую часть
1095 уравнения или неравенства соответственно.
1096
1097 См. также @code{equal} или @code{notequal}.
1098
1099 Примеры:
1100
1101 Выражение @code{@var{a} = @var{b}}, само по себе, представляет
1102 невычисляемое уравнение, которое может или может не выполняться.
1103
1104 @c ===beg===
1105 @c eq_1 : a * x - 5 * y = 17;
1106 @c eq_2 : b * x + 3 * y = 29;
1107 @c solve ([eq_1, eq_2], [x, y]);
1108 @c subst (%, [eq_1, eq_2]);
1109 @c ratsimp (%);
1110 @c ===end===
1111 @example
1112 (%i1) eq_1 : a * x - 5 * y = 17;
1113 (%o1)                    a x - 5 y = 17
1114 (%i2) eq_2 : b * x + 3 * y = 29;
1115 (%o2)                    3 y + b x = 29
1116 (%i3) solve ([eq_1, eq_2], [x, y]);
1117                         196         29 a - 17 b
1118 (%o3)          [[x = ---------, y = -----------]]
1119                      5 b + 3 a       5 b + 3 a
1120 (%i4) subst (%, [eq_1, eq_2]);
1121          196 a     5 (29 a - 17 b)
1122 (%o4) [--------- - --------------- = 17,
1123        5 b + 3 a      5 b + 3 a
1124                                   196 b     3 (29 a - 17 b)
1125                                 --------- + --------------- = 29]
1126                                 5 b + 3 a      5 b + 3 a
1127 (%i5) ratsimp (%);
1128 (%o5)                  [17 = 17, 29 = 29]
1129 @end example
1130
1131 @code{is(@var{a} = @var{b})} вычисляет @code{@var{a} = @var{b}} в @code{true},
1132 когда @var{a} и @var{b} тождественны (синтаксически равны).
1133 Выражения могут быть равны, но синтаксически не равны.
1134
1135 @c ===beg===
1136 @c a : (x + 1) * (x - 1);
1137 @c b : x^2 - 1;
1138 @c [is (a = b), is (a # b)];
1139 @c [is (equal (a, b)), is (notequal (a, b))];
1140 @c ===end===
1141 @example
1142 (%i1) a : (x + 1) * (x - 1);
1143 (%o1)                    (x - 1) (x + 1)
1144 (%i2) b : x^2 - 1;
1145                               2
1146 (%o2)                        x  - 1
1147 (%i3) [is (a = b), is (a # b)];
1148 (%o3)                     [false, true]
1149 (%i4) [is (equal (a, b)), is (notequal (a, b))];
1150 (%o4)                     [true, false]
1151 @end example
1152
1153 Некоторые операторы вычисляют @code{=} и @code{#} до @code{true} или @code{false}.
1154
1155 @c ===beg===
1156 @c if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
1157 @c       BAR;
1158 @c eq_3 : 2 * x = 3 * x;
1159 @c eq_4 : exp (2) = %e^2;
1160 @c [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
1161 @c ===end===
1162 @example
1163 (%i1) if expand ((x + y)^2) = x^2 + 2 * x * y + y^2 then FOO else
1164       BAR;
1165 (%o1)                          FOO
1166 (%i2) eq_3 : 2 * x = 3 * x;
1167 (%o2)                       2 x = 3 x
1168 (%i3) eq_4 : exp (2) = %e^2;
1169                               2     2
1170 (%o3)                       %e  = %e
1171 (%i4) [eq_3 and eq_4, eq_3 or eq_4, not eq_3];
1172 (%o4)                  [false, true, true]
1173 @end example
1174
1175 Из-за того, что @code{not @var{expr}} вызывает вычисление @var{expr},
1176 @code{not @var{a} = @var{b}} эквивалентно @code{is(@var{a} # @var{b})}.
1177
1178 @c ===beg===
1179 @c [2 * x # 3 * x, not (2 * x = 3 * x)];
1180 @c is (2 * x # 3 * x);
1181 @c ===end===
1182 @example
1183 (%i1) [2 * x # 3 * x, not (2 * x = 3 * x)];
1184 (%o1)                   [2 x # 3 x, true]
1185 (%i2) is (2 * x # 3 * x);
1186 (%o2)                         true
1187 @end example
1188
1189 @opencatbox{Категории:}
1190 @category{Операторы}
1191 @closecatbox
1192
1193 @end deffn
1194
1195 @c NEEDS EXAMPLES
1196 @deffn {Оператор} and
1197 @ifinfo
1198 @fnindex Логическое умножение
1199 @end ifinfo
1200 Оператор логического умножения.
1201 Оператор @code{and} есть n-арный инфиксный оператор.
1202 Его операнды есть логические выражения и его результат есть логическое значение.
1203
1204 Оператор @code{and} вызывает вычисление (как и @code{is}) одного или более операндов,
1205 и может вызвать вычисление всех операндов.
1206
1207 Операнды вычисляются в том же порядка, к котором они встречаются.
1208 Оператор @code{and} вычисляет только столько своих операндов, сколько необходимо для того,
1209 чтобы определить результат.
1210 Если хотя бы один операнд есть @code{false},
1211 результат есть @code{false}, и более ни один из операндов не вычисляется.
1212
1213 Глобальный флаг @code{prederror} управляет поведением @code{and},
1214 когда вычисляемый операнд не может быть определен как @code{true} или @code{false}.
1215 Оператор @code{and} печатает сообщение об ошибке, когда @code{prederror} есть @code{true}.
1216 Иначе, операнды, которые не могут быть вычислены как @code{true} или @code{false}, принимаются,
1217 и результат есть логическое выражение.
1218
1219 Оператор @code{and} не является коммутативным:
1220 @code{a and b} может быть не равно @code{b and a} из-за трактовки неопределенных операндов.
1221
1222 @opencatbox{Категории:}
1223 @category{Операторы}
1224 @closecatbox
1225
1226 @end deffn
1227
1228 @c NEEDS EXAMPLES
1229 @deffn {Оператор} or
1230 @ifinfo
1231 @fnindex Логическое сложение
1232 @end ifinfo
1233 Оператор логического сложения.
1234 @code{or} есть n-арный инфиксный оператор.
1235 Его операнды есть логические выражения и его результат есть логическое значение.
1236
1237 @code{or} вызывает вычисление (как и @code{is}) одного или более операндов,
1238 и может вызвать вычисление всех операндов.
1239
1240 Операнды вычисляются в том же порядка, к котором они встречаются.
1241 @code{or} вычисляет только столько своих операндов, сколько необходимо для того, чтобы определить результат.
1242 Если хотя бы один операнд есть @code{true},
1243 результат есть @code{true}, и более ни один из операндов не вычисляется.
1244
1245 Глобальный флаг @code{prederror} управляет поведением @code{or},
1246 когда вычисляемый операнд не может быть определен как @code{true} или @code{false}.
1247 Оператор @code{or} печатает сообщение об ошибке, когда @code{prederror} есть @code{true}.
1248 Иначе, операнды, которые не могут быть вычислены как @code{true} или @code{false}, принимаются,
1249 и результат есть логическое выражение.
1250
1251 Оператор @code{or} не является коммутативным:
1252 @code{a or b} может быть не равно @code{b or a} из-за трактовки неопределенных операндов.
1253
1254 @opencatbox{Категории:}
1255 @category{Операторы}
1256 @closecatbox
1257
1258 @end deffn
1259
1260 @c NEEDS EXAMPLES
1261 @deffn {Оператор} not
1262 @ifinfo
1263 @fnindex Логическое отрицание
1264 @end ifinfo
1265 Оператор логического отрицания.
1266 Оператор @code{not} есть префиксный оператор.
1267 Его операнд есть логическое выражение и его результат есть логическое значение.
1268
1269 Оператор @code{not} вызывает вычисление (как и @code{is}) своего операнда.
1270
1271 Глобальный флаг @code{prederror} управляет поведением @code{not},
1272 когда его операнд не может быть определен как значения @code{true} или @code{false}.
1273 Оператор @code{not} печатает сообщение об ошибке, когда @code{prederror} есть @code{true}.
1274 Иначе, операнды, которые не могут быть вычислены как @code{true} или @code{false}, принимаются,
1275 и результат есть логическое выражение.
1276
1277 @opencatbox{Категории:}
1278 @category{Операторы}
1279 @closecatbox
1280
1281 @end deffn
1282
1283 @anchor{abs}
1284 @deffn {Функция} abs (@var{expr})
1285 Возвращает абсолютное значение @var{expr} (модуль выражения).
1286 Если @var{expr} - комплексное, возвращается комплексный модуль @var{expr}.
1287
1288 @opencatbox{Категории:}
1289 @category{Математические функции}
1290 @closecatbox
1291
1292 @end deffn
1293
1294 @defvr {Ключевое слово} additive
1295 Если @code{declare(f,additive)} было выполнено, то:
1296
1297 (1) Если @code{f} одномерно, пока упрощение не столкнулось с @code{f} примененному к сумме,
1298 @code{f} будет распространено вдоль этой суммы.  То есть, @code{f(y+x)} будет
1299 упрощено как @code{f(y)+f(x)}.
1300
1301 (2) Если @code{f} есть функция двух или более аргументов, аддитивность задается как
1302 аддитивность по первому аргументу @code{f}, как в случае @code{sum} или
1303 @code{integrate}, то есть @code{f(h(x)+g(x),x)} будет упрощено как @code{f(h(x),x)+f(g(x),x)}.
1304 Это упрощение не произойдет, когда @code{f} применена к выражению вида @code{sum(x[i],i,lower-limit,upper-limit)}.
1305
1306 @opencatbox{Категории:}
1307 @category{Операторы}
1308 @category{Факты и выводы}
1309 @closecatbox
1310
1311 @end defvr
1312
1313 @c NEEDS TO BE REWORKED. NOT CONVINCED THIS SYMBOL NEEDS ITS OWN ITEM
1314 @c (SHOULD BE DESCRIBED IN CONTEXT OF EACH FUNCTION WHICH RECOGNIZES IT)
1315 @defvr {Ключевое слово} allbut
1316 Работает с командами @code{part} (например, @code{part}, @code{inpart}, @code{substpart},
1317 @code{substinpart}, @code{dpart} и @code{lpart}).  Например:
1318
1319 @c ===beg===
1320 @c expr : e + d + c + b + a;
1321 @c part (expr, [2, 5]);
1322 @c ===end===
1323 @example
1324 (%i1) expr : e + d + c + b + a;
1325 (%o1)                   e + d + c + b + a
1326 (%i2) part (expr, [2, 5]);
1327 (%o2)                         d + a
1328 @end example
1329
1330 хотя
1331
1332 @c ===beg===
1333 @c expr : e + d + c + b + a;
1334 @c part (expr, allbut (2, 5));
1335 @c ===end===
1336 @example
1337 (%i1) expr : e + d + c + b + a;
1338 (%o1)                   e + d + c + b + a
1339 (%i2) part (expr, allbut (2, 5));
1340 (%o2)                       e + c + b
1341 @end example
1342
1343 @code{allbut} также распознается @code{kill}.
1344
1345 @c ===beg===
1346 @c [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
1347 @c kill (allbut (cc, dd));
1348 @c [aa, bb, cc, dd];
1349 @c ===end===
1350 @example
1351 (%i1) [aa : 11, bb : 22, cc : 33, dd : 44, ee : 55];
1352 (%o1)                 [11, 22, 33, 44, 55]
1353 (%i2) kill (allbut (cc, dd));
1354 (%o0)                         done
1355 (%i1) [aa, bb, cc, dd];
1356 (%o1)                   [aa, bb, 33, 44]
1357 @end example
1358
1359 @code{kill(allbut(@var{a_1}, @var{a_2}, ...))} имеет тот же эффект, что  @code{kill(all)}
1360 за исключением того, что это не очищает символы @var{a_1}, @var{a_2}, ... .
1361
1362 @end defvr
1363
1364 @defvr {Декларация} antisymmetric
1365 Если @code{declare(h,antisymmetric)} выполнена, этот говорит
1366 упрощателю, что @code{h} - антисимметричная.  Например, @code{h(x,z,y)}  упростится до
1367 @code{- h(x, y, z)}.  То есть, это дает (-1)^n умноженное на @code{symmetric}
1368 или @code{commutative} результат, где n есть число перестановок двух
1369 аргументов необходимых для того, чтобы перевести к конечной форме.
1370
1371 @opencatbox{Категории:}
1372 @category{Операторы}
1373 @category{Факты и выводы}
1374 @closecatbox
1375
1376 @end defvr
1377
1378 @deffn {Функция} cabs (@var{expr})
1379 Возвращает комплексное абсолютное значение (комплексный модуль) @var{expr}.
1380
1381 @opencatbox{Категории:}
1382 @category{Комплексные переменные}
1383 @closecatbox
1384
1385 @end deffn
1386
1387 @deffn {Функция} ceiling (@var{x})
1388
1389 Когда @var{x} есть вещественное число - возвращает наименьшее целое, которое
1390 больше чем или равно @var{x}.
1391
1392 Если @var{x} - константное выражение (@code{10 * %pi}, например),
1393 @code{ceiling} вычисляет @var{x} используя большие числа с плавающей точкой и
1394 применяет @code{ceiling} к конечному большому числу с плавающей точкой.
1395 Из-за того, что @code{ceiling} использует вычисления
1396 с числами с плавающей точкой, возможно, хотя маловероятно,
1397 что @code{ceiling} может вернуть ошибочное значение для константных
1398 входных данных. Чтобы защититься от ошибок, вычисление с числами с плавающей точкой
1399 выполняется с использованием трех значений для @code{fpprec}.
1400
1401 Для неконстантных входных данных, @code{ceiling} пытается вернуть упрощенное
1402 значение. Вот примеры упрощений, о которых @code{ceiling}
1403 знает:
1404
1405 @c ===beg===
1406 @c ceiling (ceiling (x));
1407 @c ceiling (floor (x));
1408 @c declare (n, integer)$
1409 @c [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
1410 @c assume (x > 0, x < 1)$
1411 @c ceiling (x);
1412 @c tex (ceiling (a));
1413 @c ===end===
1414 @example
1415 (%i1) ceiling (ceiling (x));
1416 (%o1)                      ceiling(x)
1417 (%i2) ceiling (floor (x));
1418 (%o2)                       floor(x)
1419 (%i3) declare (n, integer)$
1420 (%i4) [ceiling (n), ceiling (abs (n)), ceiling (max (n, 6))];
1421 (%o4)                [n, abs(n), max(n, 6)]
1422 (%i5) assume (x > 0, x < 1)$
1423 (%i6) ceiling (x);
1424 (%o6)                           1
1425 (%i7) tex (ceiling (a));
1426 $$\left \lceil a \right \rceil$$
1427 (%o7)                         false
1428 @end example
1429
1430 Функция @code{ceiling} автоматически не распространяется (map) для списков или матриц.
1431 Наконец, для всех входных данных, которые объявлены комплексными,
1432 @code{ceiling} возвращает невычисляемую форму.
1433
1434 Если диапазон функции есть подмножество целых, она может быть
1435 объявлена как @code{integervalued}. Обе функции @code{ceiling} и @code{floor}
1436 могут использовать эту информацию. Например:
1437
1438 @c ===beg===
1439 @c declare (f, integervalued)$
1440 @c floor (f(x));
1441 @c ceiling (f(x) - 1);
1442 @c ===end===
1443 @example
1444 (%i1) declare (f, integervalued)$
1445 (%i2) floor (f(x));
1446 (%o2)                         f(x)
1447 (%i3) ceiling (f(x) - 1);
1448 (%o3)                       f(x) - 1
1449 @end example
1450
1451 @opencatbox{Категории:}
1452 @category{Математические функции}
1453 @closecatbox
1454
1455 @end deffn
1456
1457 @deffn {Функция} charfun (@var{p})
1458
1459 Возвращает 0, когда предикат @var{p} вычисляется как @code{false}; возвращает
1460 1, когда предикат вычисляется как @code{true}.  Когда предикат
1461 вычисляется до чего-то другого, чем @code{true} или @code{false} (unknown),
1462 возвращает невычисляемую форму.
1463
1464 Примеры:
1465
1466 @c ===beg===
1467 @c charfun (x < 1);
1468 @c subst (x = -1, %);
1469 @c e : charfun ('"and" (-1 < x, x < 1))$
1470 @c [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1471 @c ===end===
1472 @example
1473 (%i1) charfun (x < 1);
1474 (%o1)                    charfun(x < 1)
1475 (%i2) subst (x = -1, %);
1476 (%o2)                           1
1477 (%i3) e : charfun ('"and" (-1 < x, x < 1))$
1478 (%i4) [subst (x = -1, e), subst (x = 0, e), subst (x = 1, e)];
1479 (%o4)                       [0, 1, 0]
1480 @end example
1481
1482 @opencatbox{Категории:}
1483 @category{Математические функции}
1484 @closecatbox
1485
1486 @end deffn
1487
1488 @defvr {Декларация} commutative
1489 Если @code{declare(h,commutative)} выполнено, это говорит
1490 упрощателю, что @code{h} есть коммутативная функция.  То есть @code{h(x,z,y)}
1491 упроститься до @code{h(x, y, z)}.  Это тоже самое, что и @code{symmetric}.
1492
1493 @opencatbox{Категории:}
1494 @category{Операторы}
1495 @category{Факты и выводы}
1496 @closecatbox
1497
1498 @end defvr
1499
1500 @deffn {Функция} compare (@var{x}, @var{y})
1501
1502 Возвращает оператор отношения @var{op}
1503 (@code{<}, @code{<=}, @code{>}, @code{>=}, @code{=} или @code{#}) так что
1504 @code{is (@var{x} @var{op} @var{y})} вычисляется до @code{true};
1505 когда @var{x} или @var{y} зависит от @code{%i} и
1506 @code{@var{x} # @var{y}}, возвращает @code{notcomparable};
1507 когда нет такого оператора или
1508 Maxima не может определить оператор, возвращает @code{unknown}.
1509
1510 Примеры:
1511
1512 @c ===beg===
1513 @c compare (1, 2);
1514 @c compare (1, x);
1515 @c compare (%i, %i);
1516 @c compare (%i, %i + 1);
1517 @c compare (1/x, 0);
1518 @c compare (x, abs(x));
1519 @c ===end===
1520 @example
1521 (%i1) compare (1, 2);
1522 (%o1)                           <
1523 (%i2) compare (1, x);
1524 (%o2)                        unknown
1525 (%i3) compare (%i, %i);
1526 (%o3)                           =
1527 (%i4) compare (%i, %i + 1);
1528 (%o4)                     notcomparable
1529 (%i5) compare (1/x, 0);
1530 (%o5)                           #
1531 (%i6) compare (x, abs(x));
1532 (%o6)                          <=
1533 @end example
1534
1535 Функция @code{compare} не пытается определить, действительно ли области определения ее аргументов непусты.
1536 Таким образом
1537
1538 @c ===beg===
1539 @c compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1540 @c ===end===
1541 @example
1542 (%i1) compare (acos (x^2 + 1), acos (x^2 + 1) + 1);
1543 (%o1)                           <
1544 @end example
1545
1546 @c IT IS NOT QUITE TRUE, WHAT ABOUT x=0 ?
1547 Действительная область определения @code{acos (x^2 + 1)} пуста.
1548
1549 @opencatbox{Категории:}
1550 @category{Факты и выводы}
1551 @closecatbox
1552
1553 @end deffn
1554
1555 @deffn {Функция} entier (@var{x})
1556 Возвращает наибольшее целое меньше или равное чем @var{x}, где @var{x} - численное.
1557 Функция @code{fix} (как и в @code{fixnum}) есть синоним,
1558 так что @code{fix(@var{x})} в точности тоже самое.
1559
1560 @opencatbox{Категории:}
1561 @category{Математические функции}
1562 @closecatbox
1563
1564 @end deffn
1565
1566 @deffn {Функция} equal (@var{a}, @var{b})
1567 Представляет эквивалентность, то есть, равное значение.
1568
1569 Само по себе, @code{equal} не вычисляется или упрощается.
1570 Функция @code{is} пытается вычислить @code{equal} до логического значения.
1571 Функция @code{is(equal(@var{a}, @var{b}))}
1572 возвращает @code{true} (или @code{false}), если
1573 и только если, @var{a} и @var{b} равны (или не равны) для всех возможных
1574 значений своих переменных, как определено вычислением @code{ratsimp(@var{a} - @var{b})}.
1575 Если @code{ratsimp} возвращает 0, два выражения рассматриваются эквивалентными.
1576 Два выражения могут быть эквивалентными даже если они не являются синтаксически равными (то есть, идентичными).
1577
1578 Когда @code{is} не может упростить @code{equal} до @code{true} или @code{false},
1579 результат управляется глобальным флагом @code{prederror}.
1580 Когда @code{prederror} есть @code{true},
1581 @code{is} выдает сообщение об ошибке.
1582 Иначе, @code{is} возвращает @code{unknown}.
1583
1584 В добавление к @code{is},
1585 некоторые другие операторы вычисляют @code{equal} и @code{notequal} до @code{true} или @code{false},
1586 а именно @code{if}, @code{and}, @code{or} и @code{not}.
1587
1588 @c FOLLOWING STATEMENT IS MORE OR LESS TRUE BUT I DON'T THINK THE DETAILS ARE CORRECT
1589 @c Declarations (integer, complex, etc)
1590 @c for variables appearing in @var{a} and @var{b} are ignored by @code{equal}.
1591 @c All variables are effectively assumed to be real-valued.
1592
1593 Отрицанием @code{equal} является @code{notequal}.
1594
1595 Примеры:
1596
1597 Само по себе, @code{equal} не вычисляет и не упрощает.
1598
1599 @c ===beg===
1600 @c equal (x^2 - 1, (x + 1) * (x - 1));
1601 @c equal (x, x + 1);
1602 @c equal (x, y);
1603 @c ===end===
1604 @example
1605 (%i1) equal (x^2 - 1, (x + 1) * (x - 1));
1606                         2
1607 (%o1)            equal(x  - 1, (x - 1) (x + 1))
1608 (%i2) equal (x, x + 1);
1609 (%o2)                    equal(x, x + 1)
1610 (%i3) equal (x, y);
1611 (%o3)                      equal(x, y)
1612 @end example
1613
1614 Функция @code{is} пытается вычислить @code{equal} до логического значения.
1615 @code{is(equal(@var{a}, @var{b}))} возвращает @code{true} когда @code{ratsimp(@var{a} - @var{b})} возвращает 0.
1616 Два выражения могут быть эквивалентными даже если они синтаксически не равны (то есть, не идентичны).
1617
1618 @c ===beg===
1619 @c ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1620 @c is (equal (x^2 - 1, (x + 1) * (x - 1)));
1621 @c is (x^2 - 1 = (x + 1) * (x - 1));
1622 @c ratsimp (x - (x + 1));
1623 @c is (equal (x, x + 1));
1624 @c is (x = x + 1);
1625 @c ratsimp (x - y);
1626 @c is (equal (x, y));
1627 @c is (x = y);
1628 @c ===end===
1629 @example
1630 (%i1) ratsimp (x^2 - 1 - (x + 1) * (x - 1));
1631 (%o1)                           0
1632 (%i2) is (equal (x^2 - 1, (x + 1) * (x - 1)));
1633 (%o2)                         true
1634 (%i3) is (x^2 - 1 = (x + 1) * (x - 1));
1635 (%o3)                         false
1636 (%i4) ratsimp (x - (x + 1));
1637 (%o4)                          - 1
1638 (%i5) is (equal (x, x + 1));
1639 (%o5)                         false
1640 (%i6) is (x = x + 1);
1641 (%o6)                         false
1642 (%i7) ratsimp (x - y);
1643 (%o7)                         x - y
1644 (%i8) is (equal (x, y));
1645 (%o8)                        unknown
1646 (%i9) is (x = y);
1647 (%o9)                         false
1648 @end example
1649
1650 Когда @code{is} не может упростить @code{equal} до @code{true} или @code{false},
1651 результат управляется глобальным флагом @code{prederror}.
1652
1653 @c ===beg===
1654 @c [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1655 @c ratsimp (aa - bb);
1656 @c prederror : true;
1657 @c is (equal (aa, bb));
1658 @c prederror : false;
1659 @c is (equal (aa, bb));
1660 @c ===end===
1661 @example
1662 (%i1) [aa : x^2 + 2*x + 1, bb : x^2 - 2*x - 1];
1663                     2             2
1664 (%o1)             [x  + 2 x + 1, x  - 2 x - 1]
1665 (%i2) ratsimp (aa - bb);
1666 (%o2)                        4 x + 2
1667 (%i3) prederror : true;
1668 (%o3)                         true
1669 (%i4) is (equal (aa, bb));
1670 Maxima was unable to evaluate the predicate:
1671        2             2
1672 equal(x  + 2 x + 1, x  - 2 x - 1)
1673  -- an error.  Quitting.  To debug this try debugmode(true);
1674 (%i5) prederror : false;
1675 (%o5)                         false
1676 (%i6) is (equal (aa, bb));
1677 (%o6)                        unknown
1678 @end example
1679
1680 Некоторые операторы вычисляют @code{equal} или @code{notequal} до @code{true} или @code{false}.
1681
1682 @c ===beg===
1683 @c if equal (y, y - 1) then FOO else BAR;
1684 @c eq_1 : equal (x, x + 1);
1685 @c eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1686 @c [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1687 @c ===end===
1688 @example
1689 (%i1) if equal (y, y - 1) then FOO else BAR;
1690 (%o1)                          BAR
1691 (%i2) eq_1 : equal (x, x + 1);
1692 (%o2)                    equal(x, x + 1)
1693 (%i3) eq_2 : equal (y^2 + 2*y + 1, (y + 1)^2);
1694                          2                   2
1695 (%o3)             equal(y  + 2 y + 1, (y + 1) )
1696 (%i4) [eq_1 and eq_2, eq_1 or eq_2, not eq_1];
1697 (%o4)                  [false, true, true]
1698 @end example
1699
1700 Из-за того, что @code{not @var{expr}} вызывает вычисление @var{expr},
1701 @code{not equal(@var{a}, @var{b})} эквивалентно @code{is(notequal(@var{a}, @var{b}))}.
1702
1703 @c ===beg===
1704 @c [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1705 @c is (notequal (2*z, 2*z - 1));
1706 @c ===end===
1707 @example
1708 (%i1) [notequal (2*z, 2*z - 1), not equal (2*z, 2*z - 1)];
1709 (%o1)            [notequal(2 z, 2 z - 1), true]
1710 (%i2) is (notequal (2*z, 2*z - 1));
1711 (%o2)                         true
1712 @end example
1713
1714 @opencatbox{Категории:}
1715 @category{Операторы}
1716 @closecatbox
1717
1718 @end deffn
1719
1720 @deffn {Функция} floor (@var{x})
1721
1722 Когда @var{x} есть вещественное число - возвращает наибольшее целое, которое
1723 меньше или равно @var{x}.
1724
1725 Если @var{x} есть константное выражение (@code{10 * %pi}, например),
1726 @code{floor} вычисляет @var{x} используя большие числа с плавающей точкой и
1727 применяет @code{floor} к результирующему значению.
1728 Из-за того, что @code{floor} использует вычисления с числами с плавающей точкой, возможно, хотя маловероятно,
1729 что @code{floor} может вернуть ошибочное значение для константных
1730 входных данных. Чтобы застраховаться от ошибок, вычисление с числами с плавающей точкой выполняется,
1731 используя три значения для @code{fpprec}.
1732
1733 Для неконстантных входных данных, @code{floor} пытается вернуть упрощенное
1734 значение.  Вот примеры упрощений, о которых @code{floor}
1735 знает:
1736
1737 @c ===beg===
1738 @c floor (ceiling (x));
1739 @c floor (floor (x));
1740 @c declare (n, integer)$
1741 @c [floor (n), floor (abs (n)), floor (min (n, 6))];
1742 @c assume (x > 0, x < 1)$
1743 @c floor (x);
1744 @c tex (floor (a));
1745 @c ===end===
1746 @example
1747 (%i1) floor (ceiling (x));
1748 (%o1)                      ceiling(x)
1749 (%i2) floor (floor (x));
1750 (%o2)                       floor(x)
1751 (%i3) declare (n, integer)$
1752 (%i4) [floor (n), floor (abs (n)), floor (min (n, 6))];
1753 (%o4)                [n, abs(n), min(n, 6)]
1754 (%i5) assume (x > 0, x < 1)$
1755 (%i6) floor (x);
1756 (%o6)                           0
1757 (%i7) tex (floor (a));
1758 $$\left \lfloor a \right \rfloor$$
1759 (%o7)                         false
1760 @end example
1761
1762 Функция @code{floor} автоматически не распространяется (map) для списков или матриц.
1763 Наконец, для всех входных данных, которые заданы как комплексные, @code{floor} возвращает невычисляемую форму.
1764
1765 Если диапазон функции есть подмножество целых, она может быть
1766 объявлена как @code{integervalued}. Обе функции @code{ceiling} и @code{floor}
1767 могут использовать эту информацию. Например:
1768
1769 @c ===beg===
1770 @c declare (f, integervalued)$
1771 @c floor (f(x));
1772 @c ceiling (f(x) - 1);
1773 @c ===end===
1774 @example
1775 (%i1) declare (f, integervalued)$
1776 (%i2) floor (f(x));
1777 (%o2)                         f(x)
1778 (%i3) ceiling (f(x) - 1);
1779 (%o3)                       f(x) - 1
1780 @end example
1781
1782 @opencatbox{Категории:}
1783 @category{Математические функции}
1784 @closecatbox
1785
1786 @end deffn
1787
1788 @deffn {Функция} notequal (@var{a}, @var{b})
1789 Представляет собой отрицание @code{equal(@var{a}, @var{b})}.
1790
1791 Примеры:
1792
1793 @c ===beg===
1794 @c equal (a, b);
1795 @c maybe (equal (a, b));
1796 @c notequal (a, b);
1797 @c not equal (a, b);
1798 @c maybe (notequal (a, b));
1799 @c assume (a > b);
1800 @c equal (a, b);
1801 @c maybe (equal (a, b));
1802 @c notequal (a, b);
1803 @c maybe (notequal (a, b));
1804 @c ===end===
1805 @example
1806 (%i1) equal (a, b);
1807 (%o1)                      equal(a, b)
1808 (%i2) maybe (equal (a, b));
1809 (%o2)                        unknown
1810 (%i3) notequal (a, b);
1811 (%o3)                    notequal(a, b)
1812 (%i4) not equal (a, b);
1813 (%o4)                    notequal(a, b)
1814 (%i5) maybe (notequal (a, b));
1815 (%o5)                        unknown
1816 (%i6) assume (a > b);
1817 (%o6)                        [a > b]
1818 (%i7) equal (a, b);
1819 (%o7)                      equal(a, b)
1820 (%i8) maybe (equal (a, b));
1821 (%o8)                         false
1822 (%i9) notequal (a, b);
1823 (%o9)                    notequal(a, b)
1824 (%i10) maybe (notequal (a, b));
1825 (%o10)                        true
1826 @end example
1827
1828 @opencatbox{Категории:}
1829 @category{Операторы}
1830 @closecatbox
1831
1832 @end deffn
1833
1834 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
1835 @c NOTE THAT eval IS RECOGNIZED ONLY AS AN ARGUMENT TO ev,
1836 @c BUT FOR SOME REASON eval DOES NOT HAVE THE evflag PROPERTY
1837 @deffn {Оператор} eval
1838 Как аргумент в вызове к @code{ev (@var{expr})},
1839 @code{eval} вызывает дополнительное вычисление @var{expr}.
1840 См. @code{ev}.
1841
1842 @opencatbox{Категории:}
1843 @category{Флаги вычисления}
1844 @closecatbox
1845
1846 @end deffn
1847
1848 @deffn {Функция} evenp (@var{expr})
1849 Возвращает @code{true} если @var{expr} есть четное целое.
1850 @c THIS IS STRANGE -- SHOULD RETURN NOUN FORM IF INDETERMINATE
1851 @code{false} возвращается во всех других случаях.
1852
1853 @opencatbox{Категории:}
1854 @category{Функции предикаты}
1855 @closecatbox
1856
1857 @end deffn
1858
1859 @deffn {Функция} fix (@var{x})
1860 Синоним для @code{entier (@var{x})}.
1861
1862 @opencatbox{Категории:}
1863 @category{Математические функции}
1864 @closecatbox
1865
1866 @end deffn
1867
1868 @anchor{fullmap}
1869 @deffn {Функция} fullmap (@var{f}, @var{expr_1}, ...)
1870 Аналогично @code{map}, но @code{fullmap} продолжает процедуру распространения
1871 для всех подвыражений до тех пор, пока основные операторы более не остаются теми же самыми.
1872
1873 Функция @code{fullmap} используется Maxima
1874 упрощателем для некоторых матричных манипуляций. Таким образом, Maxima иногда генерирует
1875 сообщение об ошибке, касающееся @code{fullmap} хотя @code{fullmap} явно не вызывалась пользователем.
1876
1877 Примеры:
1878
1879 @c ===beg===
1880 @c a + b * c;
1881 @c fullmap (g, %);
1882 @c map (g, %th(2));
1883 @c ===end===
1884 @example
1885 (%i1) a + b * c;
1886 (%o1)                        b c + a
1887 (%i2) fullmap (g, %);
1888 (%o2)                   g(b) g(c) + g(a)
1889 (%i3) map (g, %th(2));
1890 (%o3)                     g(b c) + g(a)
1891 @end example
1892
1893 @opencatbox{Категории:}
1894 @category{Применение функций}
1895 @category{Выражения}
1896 @closecatbox
1897
1898 @end deffn
1899
1900 @anchor{fullmapl}
1901 @deffn {Функция} fullmapl (@var{f}, @var{list_1}, ...)
1902 Аналогично @code{fullmap}, но @code{fullmapl} только распространяется на
1903 списки и матрицы.
1904
1905 Пример:
1906
1907 @c ===beg===
1908 @c fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
1909 @c ===end===
1910 @example
1911 (%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
1912 (%o1)                [[a + 3, 4], [4, 3.5]]
1913 @end example
1914
1915 @opencatbox{Категории:}
1916 @category{Применение функций}
1917 @category{Выражения}
1918 @closecatbox
1919
1920 @end deffn
1921
1922 @deffn {Функция} is (@var{expr})
1923 Пытается определить, является ли предикат @var{expr}
1924 доказуемым из фактов в базе данных @code{assume}.
1925
1926 Если этот предикат является доказуемым как @code{true} или @code{false},
1927 @code{is} возвращает @code{true} или @code{false}, соответственно.
1928 Иначе, возвращаемое значение управляется глобальным флагом @code{prederror}.
1929 Когда @code{prederror} есть @code{true},
1930 @code{is} выдает сообщение об ошибке.
1931 Иначе, @code{is} возвращает @code{unknown}.
1932
1933 Выражение @code{ev(@var{expr}, pred)}
1934 (который можно переписать как @code{@var{expr}, pred} в интерактивной строке)
1935 эквивалентно @code{is(@var{expr})}.
1936
1937 См. также @code{assume}, @code{facts} и @code{maybe}.
1938
1939 Примеры:
1940
1941 @code{is} вызывает вычисление предикатов.
1942
1943 @c ===beg===
1944 @c %pi > %e;
1945 @c is (%pi > %e);
1946 @c ===end===
1947 @example
1948 (%i1) %pi > %e;
1949 (%o1)                       %pi > %e
1950 (%i2) is (%pi > %e);
1951 (%o2)                         true
1952 @end example
1953
1954 @code{is} пытается вывести предикаты из базы данных @code{assume}.
1955
1956 @c ===beg===
1957 @c assume (a > b);
1958 @c assume (b > c);
1959 @c is (a < b);
1960 @c is (a > c);
1961 @c is (equal (a, c));
1962 @c ===end===
1963 @example
1964 (%i1) assume (a > b);
1965 (%o1)                        [a > b]
1966 (%i2) assume (b > c);
1967 (%o2)                        [b > c]
1968 (%i3) is (a < b);
1969 (%o3)                         false
1970 (%i4) is (a > c);
1971 (%o4)                         true
1972 (%i5) is (equal (a, c));
1973 (%o5)                         false
1974 @end example
1975
1976 Если @code{is} не может доказать или опровергнуть предикат из базы данных @code{assume},
1977 глобальный флаг @code{prederror} управляет поведением @code{is}.
1978
1979 @c ===beg===
1980 @c assume (a > b);
1981 @c prederror: true$
1982 @c is (a > 0);
1983 @c prederror: false$
1984 @c is (a > 0);
1985 @c ===end===
1986 @example
1987 (%i1) assume (a > b);
1988 (%o1)                        [a > b]
1989 (%i2) prederror: true$
1990 (%i3) is (a > 0);
1991 Maxima was unable to evaluate the predicate:
1992 a > 0
1993  -- an error.  Quitting.  To debug this try debugmode(true);
1994 (%i4) prederror: false$
1995 (%i5) is (a > 0);
1996 (%o5)                        unknown
1997 @end example
1998
1999 @opencatbox{Категории:}
2000 @category{Функции предикаты}
2001 @category{Факты и выводы}
2002 @closecatbox
2003
2004 @end deffn
2005
2006 @deffn {Функция} maybe (@var{expr})
2007 Пытается определить, является ли предикат @var{expr}
2008  доказуемым исходя из фактов в базе данных @code{assume}.
2009
2010 Если этот предикат доказуем как @code{true} или @code{false},
2011 @code{maybe} возвращает @code{true} или @code{false}, соответственно.
2012 Иначе, @code{maybe} возвращает @code{unknown}.
2013
2014 @code{maybe} функционально эквивалентен @code{is} с @code{prederror: false},
2015 но результат вычислен без реального присвоение значения @code{prederror}.
2016
2017 См. также @code{assume}, @code{facts} и @code{is}.
2018
2019 Примеры:
2020
2021 @c ===beg===
2022 @c maybe (x > 0);
2023 @c assume (x > 1);
2024 @c maybe (x > 0);
2025 @c ===end===
2026 @example
2027 (%i1) maybe (x > 0);
2028 (%o1)                        unknown
2029 (%i2) assume (x > 1);
2030 (%o2)                        [x > 1]
2031 (%i3) maybe (x > 0);
2032 (%o3)                         true
2033 @end example
2034
2035 @opencatbox{Категории:}
2036 @category{Функции предикаты}
2037 @category{Факты и выводы}
2038 @closecatbox
2039
2040 @end deffn
2041
2042 @deffn {Функция} isqrt (@var{x})
2043 Возвращает "целый квадратный корень"
2044 абсолютного значения @var{x},
2045 которое есть целое.
2046
2047 @opencatbox{Категории:}
2048 @category{Математические функции}
2049 @closecatbox
2050
2051 @end deffn
2052
2053 @deffn {Функция} lmax (@var{L})
2054
2055 Когда @var{L} есть список или множество, возвращает @code{apply ('max, args (@var{L}))}.  Когда @var{L} не является
2056 списком или множеством, выдает ошибку.
2057
2058 @opencatbox{Категории:}
2059 @category{Математические функции}
2060 @category{Списки}
2061 @category{Множества}
2062 @closecatbox
2063
2064 @end deffn
2065
2066 @deffn {Функция} lmin (@var{L})
2067
2068 Когда @var{L} есть список или множество, возвращает @code{apply ('min, args (@var{L}))}. Когда @var{L} не является
2069 списком или множеством, выдает ошибку.
2070
2071 @opencatbox{Категории:}
2072 @category{Математические функции}
2073 @category{Списки}
2074 @category{Множества}
2075 @closecatbox
2076
2077 @end deffn
2078
2079 @deffn {Функция} max (@var{x_1}, ..., @var{x_n})
2080
2081 Возвращает упрощенное значение максимума выражений от @var{x_1} до @var{x_n}.
2082 Когда @code{get (trylevel, maxmin)} есть 2 или больше, @code{max} использует  упрощение
2083 @code{max (e, -e) --> |e|}.  Когда @code{get (trylevel, maxmin)} есть 3 или больше, @var{max} старается
2084 исключить выражения, заключенные по значению между двумя другими аргументами. Например,
2085 @code{max (x, 2*x, 3*x) --> max (x, 3*x)}. Для установки значения  @code{trylevel} в 2, используется
2086 @code{put (trylevel, 2, maxmin)}.
2087
2088 @opencatbox{Категории:}
2089 @category{Математические функции}
2090 @closecatbox
2091
2092 @end deffn
2093
2094 @deffn {Функция} min (@var{x_1}, ..., @var{x_n})
2095
2096 Возвращает упрощенное значение минимума выражений от @var{x_1} до @var{x_n}.
2097 Когда @code{get (trylevel, maxmin)} есть 2 или больше, @code{min} использует  упрощение
2098 @code{min (e, -e) --> -|e|}.  Когда @code{get (trylevel, maxmin)} есть 3 или больше, @var{min} старается
2099 исключить выражения, заключенные по значению между двумя другими аргументами. Например,
2100 @code{min (x, 2*x, 3*x) --> min (x, 3*x)}. Для установки значения  @code{trylevel} в 2, используется
2101 @code{put (trylevel, 2, maxmin)}.
2102
2103 @opencatbox{Категории:}
2104 @category{Математические функции}
2105 @closecatbox
2106
2107 @end deffn
2108
2109 @deffn {Функция} polymod (@var{p})
2110 @deffnx {Функция} polymod (@var{p}, @var{m})
2111 Конвертирует многочлен @var{p} в модулярное представление,
2112 с учетом текущего модуля, которое является значением переменной
2113 @code{modulus}.
2114
2115 @code{polymod (@var{p}, @var{m})} определяет модуль @var{m}, который будет использоваться
2116 вместо текущего значения @code{modulus}.
2117
2118 См. @code{modulus}.
2119
2120 @opencatbox{Категории:}
2121 @category{Многочлены}
2122 @closecatbox
2123
2124 @end deffn
2125
2126 @deffn {Функция} mod (@var{x}, @var{y})
2127
2128 Если @var{x} и @var{y} есть вещественные числа и @var{y} не отрицательно,
2129 возвращает @code{@var{x} - @var{y} * floor(@var{x} / @var{y})}.
2130 Далее для всех вещественных @var{x} имеем @code{mod (@var{x}, 0) = @var{x}}. Подробное обсуждение
2131 определения @code{mod (@var{x}, 0) = @var{x}} есть в разделе 3.4 "Concrete Mathematics,"
2132 авторов Graham, Knuth и Patashnik. Функция @code{mod (@var{x}, 1)}
2133 есть пилообразная функция с периодом 1, @code{mod (1, 1) = 0} и
2134 @code{mod (0, 1) = 0}.
2135
2136 Чтобы найти главный аргумент (число в интервале @code{(-%pi, %pi]}) для комплексного числа,
2137 используется функция @code{@var{x} |-> %pi - mod (%pi - @var{x}, 2*%pi)}, где
2138 @var{x} есть аргумент.
2139
2140 Когда @var{x} и @var{y} есть константные выражения (например @code{10 * %pi}), @code{mod}
2141 использует то же вычисления с числами с плавающей точкой повышенной точности, что и,  @code{floor} и @code{ceiling}.
2142 Опять же, возможно, хотя маловероятно, что @code{mod} может вернуть ошибочное значение в таких случаях.
2143
2144 Для не численных аргументов @var{x} или @var{y}, @code{mod} знает несколько правил упрощения:
2145
2146 @c ===beg===
2147 @c mod (x, 0);
2148 @c mod (a*x, a*y);
2149 @c mod (0, x);
2150 @c ===end===
2151 @example
2152 (%i1) mod (x, 0);
2153 (%o1)                           x
2154 (%i2) mod (a*x, a*y);
2155 (%o2)                      a mod(x, y)
2156 (%i3) mod (0, x);
2157 (%o3)                           0
2158 @end example
2159
2160 @opencatbox{Категории:}
2161 @category{Математические функции}
2162 @closecatbox
2163
2164 @end deffn
2165
2166 @deffn {Функция} oddp (@var{expr})
2167 есть @code{true} если @var{expr} есть нечетное целое.
2168 @c THIS IS STRANGE -- SHOULD RETURN NOUN FORM IF INDETERMINATE
2169 @code{false} возвращается во всех других случаях.
2170
2171 @opencatbox{Категории:}
2172 @category{Функции предикаты}
2173 @closecatbox
2174
2175 @end deffn
2176
2177 @c NEEDS EXPANSION, CLARIFICATION, AND EXAMPLES
2178 @c NOTE THAT pred IS RECOGNIZED ONLY AS AN ARGUMENT TO ev,
2179 @c BUT FOR SOME REASON pred DOES NOT HAVE THE evflag PROPERTY
2180 @deffn {Оператор} pred
2181 В качестве аргумента в вызове @code{ev (@var{expr})},
2182 @code{pred} вызывает вычисление предикатов (выражений, которые вычисляются в @code{true}
2183 или @code{false}) .
2184 См. @code{ev}.
2185
2186 @opencatbox{Категории:}
2187 @category{Флаги вычисления}
2188 @closecatbox
2189
2190 @end deffn
2191
2192 @deffn {Функция} make_random_state (@var{n})
2193 @deffnx {Функция} make_random_state (@var{s})
2194 @deffnx {Функция} make_random_state (true)
2195 @deffnx {Функция} make_random_state (false)
2196 @c OMIT THIS FOR NOW. SEE COMMENT BELOW.
2197 @c @defunx make_random_state (@var{a})
2198
2199 Объект случайного состояния представляет собой состояние генератора случайных чисел.
2200 Оно содержит 627 32-битных слова.
2201
2202 @code{make_random_state (@var{n})} возвращает новое случайное состояние объекта
2203 созданного из затравочного целого числа, равного @var{n} по модулю 2^32.
2204 @var{n} может быть отрицательным.
2205
2206 @c OMIT THIS FOR NOW. NOT SURE HOW THIS IS SUPPOSED TO WORK.
2207 @c @code{make_random_state (@var{a})} returns a new random state object
2208 @c created from an array @var{a}, which must be a Lisp array of 32 unsigned bytes.
2209
2210 @code{make_random_state (@var{s})} возвращает копию случайного состояния @var{s}.
2211
2212 @code{make_random_state (true)} возвращает новое случайное состояние объекта,
2213 используя текущее значение часов компьютера в качестве затравочного числа.
2214
2215 @code{make_random_state (false)} возвращает копию текущего состояния
2216 генератора случайных чисел.
2217
2218 @opencatbox{Категории:}
2219 @category{Случайные числа}
2220 @closecatbox
2221
2222 @end deffn
2223
2224 @deffn {Функция} set_random_state (@var{s})
2225 Копирует @var{s} в состояние генератора случайных чисел.
2226
2227 @code{set_random_state} всегда возвращает @code{done}.
2228
2229 @opencatbox{Категории:}
2230 @category{Случайные числа}
2231 @closecatbox
2232
2233 @end deffn
2234
2235 @deffn {Функция} random (@var{x})
2236 Возвращает псевдослучайное число. Если @var{x} есть целое, @code{random (@var{x})} возвращает
2237 целое в пределах от 0 до @code{@var{x} - 1} включительно. Если @var{x} есть число с плавающей точкой,
2238 @code{random (@var{x})} возвращает неотрицательное число с плавающей точкой меньше чем @var{x}.
2239 Функция @code{random} выдает сообщение об ошибке, если @var{x} не есть целое, или не число с плавающей точкой,
2240 или если @var{x} неположительное.
2241
2242 Функции @code{make_random_state} и @code{set_random_state}
2243 сохраняют состояние генератора случайных чисел.
2244
2245 Генератор случайных чисел Maxima - это реализация Mersenne twister MT 19937.
2246
2247 Примеры:
2248
2249 @c ===beg===
2250 @c s1: make_random_state (654321)$
2251 @c set_random_state (s1);
2252 @c random (1000);
2253 @c random (9573684);
2254 @c random (2^75);
2255 @c s2: make_random_state (false)$
2256 @c random (1.0);
2257 @c random (10.0);
2258 @c random (100.0);
2259 @c set_random_state (s2);
2260 @c random (1.0);
2261 @c random (10.0);
2262 @c random (100.0);
2263 @c ===end===
2264 @example
2265 (%i1) s1: make_random_state (654321)$
2266 (%i2) set_random_state (s1);
2267 (%o2)                         done
2268 (%i3) random (1000);
2269 (%o3)                          768
2270 (%i4) random (9573684);
2271 (%o4)                        7657880
2272 (%i5) random (2^75);
2273 (%o5)                11804491615036831636390
2274 (%i6) s2: make_random_state (false)$
2275 (%i7) random (1.0);
2276 (%o7)                   .2310127244107132
2277 (%i8) random (10.0);
2278 (%o8)                   4.394553645870825
2279 (%i9) random (100.0);
2280 (%o9)                   32.28666704056853
2281 (%i10) set_random_state (s2);
2282 (%o10)                        done
2283 (%i11) random (1.0);
2284 (%o11)                  .2310127244107132
2285 (%i12) random (10.0);
2286 (%o12)                  4.394553645870825
2287 (%i13) random (100.0);
2288 (%o13)                  32.28666704056853
2289 @end example
2290
2291 @opencatbox{Категории:}
2292 @category{Случайные числа}
2293 @category{Численные методы}
2294 @closecatbox
2295
2296 @end deffn
2297
2298 @deffn {Функция} rationalize (@var{expr})
2299
2300 Конвертирует все числа с плавающей точкой двойной точности и повышенной точности в выражении
2301 @var{expr} в рациональные эквивалентны. Если вы не знакомы с
2302 бинарным представлением чисел с плавающей точкой, вы может
2303 быть удивлены тем, что @code{rationalize (0.1)} не равно 1/10.  Это поведение
2304 имеет место не только в Maxima -- число 1/10 имеет периодическое, не заканчивающееся,
2305 двоичное представление.
2306
2307 @c ===beg===
2308 @c rationalize (0.5);
2309 @c rationalize (0.1);
2310 @c fpprec : 5$
2311 @c rationalize (0.1b0);
2312 @c fpprec : 20$
2313 @c rationalize (0.1b0);
2314 @c rationalize (sin (0.1*x + 5.6));
2315 @c ===end===
2316 @example
2317 (%i1) rationalize (0.5);
2318                                 1
2319 (%o1)                           -
2320                                 2
2321 (%i2) rationalize (0.1);
2322                                1
2323 (%o2)                          --
2324                                10
2325 (%i3) fpprec : 5$
2326 (%i4) rationalize (0.1b0);
2327                              209715
2328 (%o4)                        -------
2329                              2097152
2330 (%i5) fpprec : 20$
2331 (%i6) rationalize (0.1b0);
2332                      236118324143482260685
2333 (%o6)                ----------------------
2334                      2361183241434822606848
2335 (%i7) rationalize (sin (0.1*x + 5.6));
2336                               x    28
2337 (%o7)                     sin(-- + --)
2338                               10   5
2339 @end example
2340
2341 Пример использования:
2342
2343 @c ===beg===
2344 @c unitfrac(r) := block([uf : [], q],
2345 @c     if not(ratnump(r)) then
2346 @c        error("The input to 'unitfrac' must be a rational number"),
2347 @c     while r # 0 do (
2348 @c         uf : cons(q : 1/ceiling(1/r), uf),
2349 @c         r : r - q),
2350 @c     reverse(uf));
2351 @c unitfrac (9/10);
2352 @c apply ("+", %);
2353 @c unitfrac (-9/10);
2354 @c apply ("+", %);
2355 @c unitfrac (36/37);
2356 @c apply ("+", %);
2357 @c ===end===
2358 @example
2359 (%i1) unitfrac(r) := block([uf : [], q],
2360     if not(ratnump(r)) then
2361        error("The input to 'unitfrac' must be a rational number"),
2362     while r # 0 do (
2363         uf : cons(q : 1/ceiling(1/r), uf),
2364         r : r - q),
2365     reverse(uf));
2366 (%o1) unitfrac(r) := block([uf : [], q],
2367 if not ratnump(r) then
2368    error("The input to 'unitfrac' must be a rational number"),
2369                                   1
2370 while r # 0 do (uf : cons(q : ----------, uf), r : r - q),
2371                                       1
2372                               ceiling(-)
2373                                       r
2374 reverse(uf))
2375 (%i2) unitfrac (9/10);
2376                             1  1  1
2377 (%o2)                      [-, -, --]
2378                             2  3  15
2379 (%i3) apply ("+", %);
2380                                9
2381 (%o3)                          --
2382                                10
2383 (%i4) unitfrac (-9/10);
2384                                   1
2385 (%o4)                       [- 1, --]
2386                                   10
2387 (%i5) apply ("+", %);
2388                                 9
2389 (%o5)                         - --
2390                                 10
2391 (%i6) unitfrac (36/37);
2392                         1  1  1  1    1
2393 (%o6)                  [-, -, -, --, ----]
2394                         2  3  8  69  6808
2395 (%i7) apply ("+", %);
2396                                36
2397 (%o7)                          --
2398                                37
2399 @end example
2400
2401 @opencatbox{Категории:}
2402 @category{Численное вычисление}
2403 @closecatbox
2404
2405 @end deffn
2406
2407
2408 @deffn {Функция} round (@var{x})
2409
2410 Если @var{x} является вещественным числом, то возвращает ближайшее к @var{x}
2411 целое.  Числа, кратные 1/2, округляются до ближайшего четного целого.
2412 Вычисление @var{x} аналогично функциям @code{floor} и @code{ceiling}.
2413
2414 @opencatbox{Категории:}
2415 @category{Математические функции}
2416 @closecatbox
2417 @end deffn
2418
2419 @deffn {Функция} sign (@var{expr})
2420 Пытается определить знак @var{expr}
2421 на основе фактов в текущей базе данных. Она возвращает один из
2422 следующих ответов: @code{pos} (положительное), @code{neg} (отрицательное), @code{zero} (нулевое), @code{pz}
2423 (положительное или ноль), @code{nz} (отрицательное или ноль), @code{pn} (положительное или отрицательное),
2424 или @code{pnz} (положительное, отрицательное или ноль, т.е. ничего не известно).
2425
2426 @opencatbox{Категории:}
2427 @category{Факты и выводы}
2428 @closecatbox
2429
2430 @end deffn
2431
2432 @deffn {Функция} signum (@var{x})
2433 Для численного значения @var{x}, возвращает 0, если @var{x} есть 0, иначе возвращает -1 или +1,
2434 когда @var{x} меньше чем или больше чем 0, соответственно.
2435
2436 Если @var{x} не есть численное значение, то возвращается эквивалентная, но упрощенная форма.
2437 Например, @code{signum(-x)} дает @code{-signum(x)}.
2438 @c UMM, THIS ISN'T THE WHOLE STORY, AS IT APPEARS signum CONSULTS THE assume DATABASE FOR SYMBOLIC ARGUMENT
2439
2440 @opencatbox{Категории:}
2441 @category{Математические функции}
2442 @closecatbox
2443
2444 @end deffn
2445
2446 @deffn {Функция} sort (@var{L}, @var{P})
2447 @deffnx {Функция} sort (@var{L})
2448 Сортирует список @var{L} согласно предикату @code{P} двух аргументов,
2449 так чтобы @code{@var{P} (@var{L}[k], @var{L}[k + 1])} было равно @code{true}
2450 для любых двух последовательных элементов.
2451 Предикат может быть задан как имя функции или бинарный инфиксный оператор,
2452 или как лямбда-выражение.
2453 Если он задан как имя оператора,
2454 это имя берется в "двойные кавычки".
2455
2456 Отсортированный список возвращается как новый объект;
2457 аргумент @var{L} не изменяется.
2458 При возврате значения,
2459 @code{sort} делает копию верхнего уровня (shallow copy) элементов @var{L}.
2460 @c DUNNO IF WE NEED TO GO INTO THE IMPLICATIONS OF SHALLOW COPY HERE ...
2461
2462 @c MIGHT CONSIDER A REF FOR TOTAL ORDER HERE
2463 Если предикат @var{P} не задает полное упорядочивание элементов @var{L},
2464 то @code{sort} может пробежать до конца без ошибки,
2465 но результат будет неопределенный.
2466 @code{sort} выдает сообщение, если предикат вычисляется до чего-то отличного
2467 от @code{true} или @code{false}.
2468
2469 @code{sort (@var{L})} эквивалентно @code{sort (@var{L}, orderlessp)}.
2470 То есть, порядок сортировки по умолчанию будет восходящим,
2471 как определено для @code{orderlessp}.
2472 Все Maxima атомы и выражения сравнимы по @code{orderlessp},
2473 хотя есть отдельные примеры выражений, для которых @code{orderlessp} не транзитивна
2474 (это ошибка).
2475
2476 Примеры:
2477
2478 @c ===beg===
2479 @c sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
2480 @c       19 - 3 * x]);
2481 @c sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c, 19 - 3 * x],
2482 @c       ordergreatp);
2483 @c sort ([%pi, 3, 4, %e, %gamma]);
2484 @c sort ([%pi, 3, 4, %e, %gamma], "<");
2485 @c my_list : [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]];
2486 @c sort (my_list);
2487 @c sort (my_list, lambda ([a, b], orderlessp (reverse (a),
2488 @c       reverse (b))));
2489 @c ===end===
2490 @example
2491 (%i1) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9 * c,
2492       19 - 3 * x]);
2493                5
2494 (%o1) [- 17, - -, 3, 7.55, 11, 2.9b1, b + a, 9 c, 19 - 3 x]
2495                2
2496 (%i2) sort ([11, -17, 29b0, 7.55, 3, -5/2, b + a, 9*c, 19 - 3*x],
2497       ordergreatp);
2498                                                    5
2499 (%o2) [19 - 3 x, 9 c, b + a, 2.9b1, 11, 7.55, 3, - -, - 17]
2500                                                    2
2501 (%i3) sort ([%pi, 3, 4, %e, %gamma]);
2502 (%o3)                [3, 4, %e, %gamma, %pi]
2503 (%i4) sort ([%pi, 3, 4, %e, %gamma], "<");
2504 (%o4)                [%gamma, %e, 3, %pi, 4]
2505 (%i5) my_list: [[aa,hh,uu], [ee,cc], [zz,xx,mm,cc], [%pi,%e]];
2506 (%o5) [[aa, hh, uu], [ee, cc], [zz, xx, mm, cc], [%pi, %e]]
2507 (%i6) sort (my_list);
2508 (%o6) [[%pi, %e], [aa, hh, uu], [ee, cc], [zz, xx, mm, cc]]
2509 (%i7) sort (my_list, lambda ([a, b], orderlessp (reverse (a),
2510       reverse (b))));
2511 (%o7) [[%pi, %e], [ee, cc], [zz, xx, mm, cc], [aa, hh, uu]]
2512 @end example
2513
2514 @opencatbox{Категории:}
2515 @category{Списки}
2516 @closecatbox
2517
2518 @end deffn
2519
2520 @anchor{sqrt}
2521 @deffn {Функция} sqrt (@var{x})
2522 Квадратный корень @var{x}. Внутренне представляется как
2523 @code{@var{x}^(1/2)}.  См. также @code{rootscontract}.
2524
2525 @code{radexpand}, если @code{true}, вызовет то, что n-ные корни множителей произведения,
2526 которые есть степени n, будут вынесены за пределы радикала. Например,
2527 @code{sqrt(16*x^2)} станет @code{4*x}, только если @code{radexpand} есть @code{true}.
2528
2529 @opencatbox{Категории:}
2530 @category{Математические функции}
2531 @closecatbox
2532
2533 @end deffn
2534
2535 @defvr {Управляющая переменная} sqrtdispflag
2536 Значение по умолчанию: @code{true}
2537
2538 Когда @code{sqrtdispflag} есть @code{false},
2539 то @code{sqrt} выводится как степень с показателем 1/2.
2540 @c AND OTHERWISE ... ??
2541
2542 @opencatbox{Категории:}
2543 @category{Математические функции}
2544 @category{Переменные и флаги вывода}
2545 @closecatbox
2546
2547 @end defvr
2548
2549 @c NEEDS EXPANSION, CLARIFICATION, MORE EXAMPLES
2550 @c sublis CAN ONLY SUBSTITUTE FOR ATOMS, RIGHT ?? IF SO, SAY SO
2551 @deffn {Функция} sublis (@var{list}, @var{expr})
2552 Производит множественные параллельные подстановки в выражение.
2553
2554 Переменная @code{sublis_apply_lambda} управляет упрощением после
2555 @code{sublis}.
2556
2557 Пример:
2558
2559 @c ===beg===
2560 @c sublis ([a=b, b=a], sin(a) + cos(b));
2561 @c ===end===
2562 @example
2563 (%i1) sublis ([a=b, b=a], sin(a) + cos(b));
2564 (%o1)                    sin(b) + cos(a)
2565 @end example
2566
2567 @opencatbox{Категории:}
2568 @category{Выражения}
2569 @closecatbox
2570
2571 @end deffn
2572
2573 @deffn {Функция} sublist (@var{list}, @var{p})
2574 Возвращает список элементов @var{list}, для которого
2575 предикат @code{p} возвращает @code{true}.
2576
2577 Пример:
2578
2579 @c ===beg===
2580 @c L: [1, 2, 3, 4, 5, 6];
2581 @c sublist (L, evenp);
2582 @c ===end===
2583 @example
2584 (%i1) L: [1, 2, 3, 4, 5, 6];
2585 (%o1)                  [1, 2, 3, 4, 5, 6]
2586 (%i2) sublist (L, evenp);
2587 (%o2)                       [2, 4, 6]
2588 @end example
2589
2590 @opencatbox{Категории:}
2591 @category{Списки}
2592 @closecatbox
2593
2594 @end deffn
2595
2596 @defvr {Управляющая переменная} sublis_apply_lambda
2597 Значение по умолчанию: @code{true}
2598
2599 Управляет, будет ли подстановки для @code{lambda} применены в упрощении,
2600 после того как используется @code{sublis} или
2601 нужно ли выполнить @code{ev}, чтобы эти элементы применились.
2602 @code{true} означает - выполнить применение.
2603
2604 @opencatbox{Категории:}
2605 @category{Выражения}
2606 @closecatbox
2607
2608 @end defvr
2609
2610 @c NEEDS CLARIFICATION, MORE EXAMPLES
2611 @anchor{subst}
2612 @deffn {Функция} subst (@var{a}, @var{b}, @var{c})
2613 Делает подстановку @var{a} для @var{b} в @var{c}.
2614 @var{b} должен быть атомом или полным подвыражением в @var{c}.  Например, @code{x+y+z} есть полное
2615 подвыражение @code{2*(x+y+z)/w}, а @code{x+y} нет. Когда @var{b} не имеет
2616 эти характеристики, можно иногда использовать @code{substpart} или @code{ratsubst}
2617 (см. ниже).  Альтернативно, если @var{b} задано в форме @code{e/f}, то можно
2618 использовать @code{subst (a*f, e, c)}, в то время как, если @var{b} задано в  форме @code{e^(1/f)}, то можно
2619 использовать @code{subst (a^f, e, c)}.  @code{subst} также различает @code{x^y} в @code{x^-y},
2620 так что @code{subst (a, sqrt(x), 1/sqrt(x))} дает @code{1/a}.  Аргументы @var{a} и @var{b} могут также быть
2621 операторами выражения, заключенными в двойные кавычки @code{"}, или могут быть именами функций.
2622 Если есть желание подставить независимую переменную в
2623 производных формах, то следует использовать функцию @code{at} (см. ниже).
2624
2625 @c UMM, REVERSE THIS AND MOVE IT TO substitute ??
2626 @code{subst} - это псевдоним для @code{substitute}.
2627
2628 Выражения @code{subst (@var{eq_1}, @var{expr})} или @code{subst ([@var{eq_1}, ..., @var{eq_k}], @var{expr})}
2629 - есть другие допустимые формы.
2630 @var{eq_i} - уравнения, указывающие какие подстановки нужно сделать.
2631 Для каждого уравнения, правая сторона будет подставлена вместо левой в выражении @var{expr}.
2632
2633 Если @code{exptsubst} равно @code{true}, то позволяются подстановки,
2634 на подобии @code{y} для @code{%e^x} в @code{%e^(a*x)}.
2635
2636 @c WHAT IS THIS ABOUT ??
2637 Когда @code{opsubst} есть @code{false},
2638 @code{subst} не пытается подставить в оператор выражения.
2639 Например, @code{(opsubst: false, subst (x^2, r, r+r[0]))} будет работать.
2640
2641 Примеры:
2642
2643 @c ===beg===
2644 @c subst (a, x+y, x + (x+y)^2 + y);
2645 @c subst (-%i, %i, a + b*%i);
2646 @c ===end===
2647 @example
2648 (%i1) subst (a, x+y, x + (x+y)^2 + y);
2649                                     2
2650 (%o1)                      y + x + a
2651 (%i2) subst (-%i, %i, a + b*%i);
2652 (%o2)                       a - %i b
2653 @end example
2654
2655 @noindent
2656 Чтобы узнать о других примерах, выполните @code{example (subst)}.
2657
2658 @opencatbox{Категории:}
2659 @category{Выражения}
2660 @closecatbox
2661
2662 @end deffn
2663
2664 @c NEEDS CLARIFICATION
2665 @deffn {Функция} substinpart (@var{x}, @var{expr}, @var{n_1}, ..., @var{n_k})
2666 Аналогично @code{substpart}, но @code{substinpart} работает с
2667 внутренним представление @var{expr}.
2668
2669 Примеры:
2670
2671 @c ===beg===
2672 @c x . 'diff (f(x), x, 2);
2673 @c substinpart (d^2, %, 2);
2674 @c substinpart (f1, f[1](x + 1), 0);
2675 @c ===end===
2676 @example
2677 (%i1) x . 'diff (f(x), x, 2);
2678                               2
2679                              d
2680 (%o1)                   x . (--- (f(x)))
2681                                2
2682                              dx
2683 (%i2) substinpart (d^2, %, 2);
2684                                   2
2685 (%o2)                        x . d
2686 (%i3) substinpart (f1, f[1](x + 1), 0);
2687 (%o3)                       f1(x + 1)
2688 @end example
2689
2690 Если последний аргумент функции @code{part} есть список индексов, то будут выбраны
2691 несколько подвыражений, каждый из которых будет соответствовать
2692 индексу в списке. Таким образом
2693
2694 @c ===beg===
2695 @c part (x + y + z, [1, 3]);
2696 @c ===end===
2697 @example
2698 (%i1) part (x + y + z, [1, 3]);
2699 (%o1)                         z + x
2700 @end example
2701
2702 Переменная @code{piece} содержит значение последнего выражения, выбранного при использовании функции @code{part}.
2703 Оно устанавливается во время выполнения функции и,
2704 таким образом, может быть передано в саму функцию как показано ниже.
2705 Если @code{partswitch} равно @code{true}, то @code{end} возвращается когда
2706 выбранная часть выражения не существует, иначе
2707 выдается сообщение об ошибке.
2708
2709 @c ===beg===
2710 @c expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
2711 @c part (expr, 2, [1, 3]);
2712 @c sqrt (piece/54);
2713 @c substpart (factor (piece), expr, [1, 2, 3, 5]);
2714 @c expr: 1/x + y/x - 1/z;
2715 @c substpart (xthru (piece), expr, [2, 3]);
2716 @c ===end===
2717 @example
2718 (%i1) expr: 27*y^3 + 54*x*y^2 + 36*x^2*y + y + 8*x^3 + x + 1;
2719               3         2       2            3
2720 (%o1)     27 y  + 54 x y  + 36 x  y + y + 8 x  + x + 1
2721 (%i2) part (expr, 2, [1, 3]);
2722                                   2
2723 (%o2)                         54 y
2724 (%i3) sqrt (piece/54);
2725 (%o3)                        abs(y)
2726 (%i4) substpart (factor (piece), expr, [1, 2, 3, 5]);
2727                                3
2728 (%o4)               (3 y + 2 x)  + y + x + 1
2729 (%i5) expr: 1/x + y/x - 1/z;
2730                              1   y   1
2731 (%o5)                      - - + - + -
2732                              z   x   x
2733 (%i6) substpart (xthru (piece), expr, [2, 3]);
2734                             y + 1   1
2735 (%o6)                       ----- - -
2736                               x     z
2737 @end example
2738
2739 Также, установка опции @code{inflag} в @code{true} и вызов @code{part} или @code{substpart} есть
2740 тоже самое, что и вызов @code{inpart} или @code{substinpart}.
2741
2742 @opencatbox{Категории:}
2743 @category{Выражения}
2744 @closecatbox
2745
2746 @end deffn
2747
2748 @c NEEDS CLARIFICATION
2749 @deffn {Функция} substpart (@var{x}, @var{expr}, @var{n_1}, ..., @var{n_k})
2750 Делает подстановку @var{x} в подвыражение,
2751 выбираемое последними аргументами, как в @code{part}. Возвращает
2752 новое значение @var{expr}.  @var{x} может быть некоторым оператором для подстановки вместо
2753 оператора в @var{expr}. В некоторых случаях @var{x} нужно заключать в двойной кавычки @code{"}
2754 (Например, @code{substpart ("+", a*b, 0)} дает @code{b + a}).
2755
2756 @c ===beg===
2757 @c 1/(x^2 + 2);
2758 @c substpart (3/2, %, 2, 1, 2);
2759 @c a*x + f(b, y);
2760 @c substpart ("+", %, 1, 0);
2761 @c ===end===
2762 @example
2763 (%i1) 1/(x^2 + 2);
2764                                1
2765 (%o1)                        ------
2766                               2
2767                              x  + 2
2768 (%i2) substpart (3/2, %, 2, 1, 2);
2769                                1
2770 (%o2)                       --------
2771                              3/2
2772                             x    + 2
2773 (%i3) a*x + f(b, y);
2774 (%o3)                     a x + f(b, y)
2775 (%i4) substpart ("+", %, 1, 0);
2776 (%o4)                    x + f(b, y) + a
2777 @end example
2778
2779 Также, установка опции @code{inflag} в @code{true} и вызов @code{part} или @code{substpart}, есть
2780 тоже самое, что и вызов @code{inpart} или @code{substinpart}.
2781
2782 @opencatbox{Категории:}
2783 @category{Выражения}
2784 @closecatbox
2785
2786 @end deffn
2787
2788 @c NEEDS EXPANSION AND EXAMPLES
2789 @deffn {Функция} subvarp (@var{expr})
2790 Возвращает @code{true}, если @var{expr} есть переменная с индексом,
2791 например @code{a[i]}.
2792
2793 @opencatbox{Категории:}
2794 @category{Функции предикаты}
2795 @closecatbox
2796
2797 @end deffn
2798
2799 @deffn {Функция} symbolp (@var{expr})
2800 Возвращает @code{true}, если @var{expr} есть символ, иначе @code{false}.
2801 На самом деле, @code{symbolp(x)} эквивалентно предикату @code{atom(x) and not numberp(x)}.
2802
2803 @c FOLLOWING REALLY WANTS TO BE @xref{Identiifers} BUT THAT
2804 @c LEAVES THE UNPLEASANT RESIDUE *Note ...:: IN THE OUTPUT OF describe
2805 См. также @ref{Идентификаторы}.
2806
2807 @opencatbox{Категории:}
2808 @category{Функции предикаты}
2809 @closecatbox
2810
2811 @end deffn
2812
2813 @deffn {Функция} unorder ()
2814 Блокирует связывания, созданные последним вызовом упорядочивающих
2815 команд @code{ordergreat} и @code{orderless}. @code{ordergreat} и @code{orderless} не могут
2816 использоваться больше одного раза каждый, без вызова @code{unorder}.
2817 См. также @code{ordergreat} и @code{orderless}.
2818
2819 Примеры:
2820
2821 @c HMM, IN THIS EXAMPLE, WHY ISN'T %o5 EQUAL TO ZERO ???
2822 @c ===beg===
2823 @c unorder();
2824 @c b*x + a^2;
2825 @c ordergreat (a);
2826 @c b*x + a^2;
2827 @c  %th(1) - %th(3);
2828 @c unorder();
2829 @c ===end===
2830 @example
2831 (%i1) unorder();
2832 (%o1)                          []
2833 (%i2) b*x + a^2;
2834                                    2
2835 (%o2)                       b x + a
2836 (%i3) ordergreat (a);
2837 (%o3)                         done
2838 (%i4) b*x + a^2;
2839  %th(1) - %th(3);
2840                              2
2841 (%o4)                       a  + b x
2842 (%i5) unorder();
2843                               2    2
2844 (%o5)                        a  - a
2845 @end example
2846
2847 @opencatbox{Категории:}
2848 @category{Выражения}
2849 @closecatbox
2850
2851 @end deffn
2852
2853 @c THIS ITEM SEEMS OUT OF PLACE -- IS IT FROM A SHARE PACKAGE ??
2854 @c NEEDS EXAMPLES
2855 @deffn {Функция} vectorpotential (@var{givencurl})
2856 Возвращает векторный потенциал заданного
2857 вектора кручения, в текущей системе координат.
2858 @code{potentialzeroloc} имеет аналогичную роль для @code{potential}, но порядок
2859 левосторонних частей уравнений должен быть циклической перестановкой
2860 координатных переменных.
2861
2862 @opencatbox{Категории:}
2863 @category{Пакет vect}
2864 @closecatbox
2865
2866 @end deffn
2867
2868 @deffn {Функция} xthru (@var{expr})
2869 Объединяет все члены @var{expr} (которое должно быть суммой) для общего знаменателя
2870 без раскрытия произведений и степеней сумм,
2871 что делает @code{ratsimp}.  Функция @code{xthru} сокращает общие множители в числителе и
2872 знаменателе рациональных выражений, но только если эти множители явные.
2873
2874 @c REPHRASE IN NEUTRAL TONE (GET RID OF "IT IS BETTER")
2875 Иногда лучше использовать @code{xthru} перед выражением, упрощенным с помощью @code{ratsimp},
2876 для того чтобы вызывать сокращение явных множителей наибольшего общего делителя
2877 числителя и знаменателя, таким образом, упрощая выражение перед @code{ratsimp}.
2878
2879 @c ===beg===
2880 @c ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
2881 @c xthru (%);
2882 @c ===end===
2883 @example
2884 (%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
2885                                 20
2886                  1       (x + 2)   - 2 y       x
2887 (%o1)        --------- + --------------- - ---------
2888                     19             20             20
2889              (y + x)        (y + x)        (y + x)
2890 (%i2) xthru (%);
2891                                  20
2892                           (x + 2)   - y
2893 (%o2)                     -------------
2894                                    20
2895                             (y + x)
2896 @end example
2897
2898 @opencatbox{Категории:}
2899 @category{Выражения}
2900 @closecatbox
2901
2902 @end deffn
2903
2904 @c THIS FUNCTION APPEARS TO BE A HACK; SEE 4'TH ITEM BELOW
2905 @c DUNNO WHETHER WE CAN CLEAR THIS UP
2906 @deffn {Функция} zeroequiv (@var{expr}, @var{v})
2907 Проверяет эквивалентно ли выражение @var{expr} в переменной
2908 @var{v} нулю, возвращает @code{true}, @code{false} или
2909 @code{dontknow}.
2910
2911 @code{zeroequiv} имеет следующие ограничения:
2912 @enumerate
2913 @item
2914 Не используйте функции, для которых Maxima не знает как
2915 их дифференцировать и вычислять.
2916 @item
2917 Если выражение имеет полюсы на вещественной прямой, могут быть ошибки
2918 в результате (это может произойти с малой вероятностью).
2919 @item
2920 Если выражение содержит функции, который не являются решением
2921 дифференциальных уравнений первого порядка (например, функции Бесселя),
2922 могут быть некорректные результаты.
2923 @item
2924 Этот алгоритм использует вычисление в случайно выбранных точках для
2925 аккуратно выбранных подвыражений. Это всегда, в некотором смысле,
2926 рискованное дело, хотя алгоритм пытается минимизировать возможность ошибки.
2927 @end enumerate
2928
2929 Например @code{zeroequiv (sin(2*x) - 2*sin(x)*cos(x), x)} возвращает
2930 @code{true} и @code{zeroequiv (%e^x + x, x)} возвращает @code{false}.
2931 С другой стороны @code{zeroequiv (log(a*b) - log(a) - log(b), a)} возвращает
2932 @code{dontknow} из-за присутствия дополнительного параметра @code{b}.
2933
2934 @opencatbox{Категории:}
2935 @category{Функции предикаты}
2936 @closecatbox
2937
2938 @end deffn