Записи с меткой «функцию»

Тригонометрическая регрессия — TrigFit

Тригонометрическая регрессия — TrigFit
Многие выражения содержат периодические тригонометрические функции, например sin(X) или cos(X). Помимо обычного спектрального представления выражений, подпакет TrigFit пакета NumericalMath имеет функции для тригонометрической регрессии:

  • TrigFit [data, n, x] — дает тригонометрическую регрессию для данных data с использованием косинусов и синусов вплоть до cos(n x) и sin(n x) и с периодом 2л;
  • TrigFit [data, n, {x,L}] — дает тригонометрическую регрессию для данных data с использованием косинусов и синусов вплоть до cos(2лuc/L) и sm(2лnx/L) и с периодом I;
  • TrigFit [data, n, {x, x0, xl} ] — дает тригонометрическую регрессию для данных data с использованием косинусов и синусов вплоть до cos(2лn(x — х 0 )/ (x-x0)) и sin(2лn(x-x 0 )/(x 1 -x 0 )) и с периодом (x1-x0).

Примеры выполнения тригонометрической регрессии даны ниже:
<<Numerical Math’TrigFit’
data = Table[l+2Sin[x]+3Cos[2x],{x, 0, 2Pi-2Pi/7, 2Pi/7}];
TrigFit[data, 0, x]
1.
TrigFit[data, 1, {x, L}]
l.+ 0.Cos 2[лx/L]+ 2. Sin [2лx/L]
Fit[Transpose!{Range[0, 2Pi-2Pi/7, 2Pi/7], data}],
{1, Cos[x], Sin[x]}, x]
1. — 4.996xl(T16Cos[x] + 2. Sin[x]
TrigFit[data, 3, {x, x0, xl}];
Chop[%]
l. + 3.Cos [4л (x-x0)/(-x0+x1)]+2. Sin [2л (x-x0)/(-x0+x1)]

Векторный анализ — VectorAnalysis

Векторный анализ —VectorAnalysis
Подпакет VectorAnalysis содержит множество функций, используемых при выполнении векторного анализа. Здесь надо иметь в виду, что речь идет не о векторах как представителях одномерных массивов, которые рассматривались ранее. В данном случае вектор — это направленный отрезок прямой в пространстве, заданном той или иной системой координат.
Системы координат и их преобразования
Заметная часть функций подпакета VectorAnalysis относится к заданию и преобразованию координат:

  • Coordinates [ ] — возвращает имена переменных текущей системы координат;
  • Coordinates [coordsys] — возвращает имена переменных системы координат coordsys;
  • SetCoordinates [coordsys] — устанавливает систему координат coordsys с текущими переменными;
  • Coordinates [coordsys, {vars}] — устанавливает систему координат coordsys с переменными, заданными списком {vars }.

Ниже даны названия систем координат и соответствующие им представления.

Наименование

Представление

Прямоугольные

Cartesian [х, у, z]

Цилиндрические

Cylindrical [r, theta, z]

Сферические

Spherical [r, theta, phi]

Параболические цилиндрические

ParabolicCylindrical [u, v, z]

Параболические

Paraboloidal [u, v, phi]

Эллиптические цилиндрические

EllipticCylindrical [u, v, z, a]

Вытянутые сфероидальные

ProlateSpheroidal [xi, eta, phi, a]

Сплющенные сфероидальные

OblateSpheroidal [xi, eta, phi, a]

Биполярные

Bipolar[u, v, z, a]

Бисферические

Bispherical [u, v, phi, a]

Тороидальные

Toroidal [u, v, phi, a]

Конические

Conical [lambda, mu, nu, a, b]

Конфокальные эллипсоидальные

ConfocalEllipsoidal [lambda, rnu, nu, a, b, c]

Конфокальные параболические

ConfocalParaboloidal [lambda, mu, nu, a, bj

Например, параболическую систему координат можно задать следующим образом:
SetCoordinates[Paraboloidal[x, у, z] ]
Paraboloidal [x, у, z]
{CoordinateSystem, Coordinates[]}
{Paraboloidal, {x, y, z}}
Ряд функций служит для контроля и установки параметров систем координат:

  • CoordinateRanges [ ] — возвращает пределы изменения переменных текущей координатной системы;
  • Parameters [ ] — возвращает параметры текущей координатной системы;
  • ParametersRanges [ ] — возвращает пределы изменения параметров текущей координатной системы;
  • CoordinateRanges [coordsys] — возвращает пределы изменения переменных координатной системы coordsys;
  • Parameters [coordsys] — возвращает параметры координатной системы coordsys;
  • ParametersRanges [coordsys] — возвращает пределы изменения параметров координатной системы coordsys;
  • SetCoordinates [coordsys, {vars,param} ] — устанавливает параметры текущей координатной системы как параметры coordsys с переменными vars и параметрами param.

Ниже представлены примеры применения этих функций:
CoordinateRanges[]
{0<Х<бесконечности,0<Y<бесконечность,-л<Z<=л}
Parameters[]
{}
ParameterRanges[ ]
Coordinates[Conical], CoordinateRanges[Conical]
{{Llanibda, Мmu, Nnu}, {-бесконечность< Llambda< бесконечность, l< Mmu2 < 4, Nnu2< 1}}
Parameters[Bipolar],ParameterRanges[Bipolar]
{{1}, 0< #1<бесконечность}
Для преобразования координат служат следующие функции:

  • CoordinatesToCartesian [pt] — преобразование текущих координат в декартовы;
  • CoordinatesToCartesian [pt, coordsys] — преобразование координат coordsys в декартовы;
  • CoordinatesFromCartesian [pt] — преобразование из декартовых координат в текущие;
  • CoordinatesFromCartesian [pt, coordsys] — преобразование из декартовых координат в координаты coordsys.

Эти примеры демонстрируют преобразования координат:
CoordinatesToCartesian[{I, Pi/3, Pi/3}, Spherical]
CoordinatesToCartesian [u, v, phi}, Bipolar]
CoordinatesFromCartesian [ {x, y, z} , Bipolar]

{-2Im[ArcCoth[x+ Iy]] , 2Re[ArcCoth[x+ Iy] ] , z}

Операции с полиномами

Операции с полиномами
Если конечные поля — понятие достаточно экзотическое, то полиномы встреча- ются сплошь и рядом во многих математических и научно-технических расчетах. В пакете расширения Algebra определен ряд новых операций над полиномами. Начнем их рассмотрение с функции PolynomialExtendedGCD:

  • PolynomialExtendedGCD [polyl, poly2 ] — возвращает наибольший общий делитель двух полиномов;
  • PolynomialExtendedGCD[polyl,poly2,Modulus->p] —возвращает наи- больший общий делитель двух полиномов по модулю р.

Примеры применения этой функции приведены ниже:
<<Algebra"PolynomialExtendedGCD
PolynomialExtendedGCDlxл2 + 3 х + 2, Expand[(x + 1)(х + 2)], Modulus->7]
{2+ Зх+х2, (0, 1}}
PolynomialExtendedGCD[
Expand[ ((12+1) z^2 + 5 z + I) (I z + 3)], Expand[ ((9+1) z + (3+1)) ((31) z +9)]]
{-31+z,
{- 2261/3341+ 710I/3341( 35/3341- 3951/10023)+ (5959/20046- 20531/20046)z}}
Далее следует функция PolynomialPowerMod [polyl, n, (poly2, р} ], которая является существенно ускоренной версией функции PolynomialMod.

  • степени ускорения свидетельствует следующий пример:

<<Algebra`PolynomialPowerMod`
Timing[PolynomialPowerMod[1 + х, 200, х^З + x^2 + 1, Prime[4750]]][[1]], Timing [ PolynomialMod [ (1 + x)^200, x^ + х^2 + 1, Prime [4750] ]][[1]]
{0. Second, 2.37 Second)
В данном случае вычисления по функции PolynomialPowerMod оказались вы- полненными менее чем за 0.01 с, что дает нулевой результат.
Еще одна функция в трех ее модификациях работает с симметричными полиномами:

  • SymmetricReduction [ {xl,…,xn}, k] — возвращает симметричный полином степени k по переменным {х1,…, хn);
  • SymmetricReduction [f, {xl,…,xn}] — возвращает часть полинома {p,q} по переменным {х1,…,хп}, где f=p+q, причем р есть симметричная часть, q — остаток;
  • SymmetricReduction [f, {xl,…,xn}, {s1,…, sn} ] — возвращает часть полинома (p,q) попеременным {xl, …,xn}, где элементарный симметричный полином представляет список {s1,…, sn}.

Следующий пример поясняет создание симметричного полинома 4-й степени по переменным {х,у, z,w,t}:
<<Algebra` SymmetricPolynomials`
SyiranetricPolynomial[{x, y, z, w, t}, 4]
twxy+ twxz+ twyz+txyz+wxyz
Действие других функций поясняют следующие примеры:
SynraetricReduction[(х + у)^2 + (х + z)^2 + (z + у)^2, {х, у, z}]
{2 (х+у+ z)2- 2 (xy+xz+yz), 0}
SymmetricReduction[х^5 + у^5 + z^4, {х, у, z}, {s1, s2, s3}]
{s15- 5s13s2 + 5s1s22+ 5sl2s3- 5s2s3, z4-z5}
Преобразование полиномов в схему Горнера — Horner
Подпакет Horner в системе Mathematica 8 реализует хорошо известную схему вычисления полиномов — схему Горнера. При ней операции возведения в степень заменяются операциями умножения. Для этого служит функция Horner:

  • Horner [poly] — устанавливает полином poly в форму Горнера;
  • Horner [poly, vars] — устанавливает полином ряда переменных vars в форму Горнера.

Примеры преобразования полиномов в схему Горнера:
<<NumericalMath`Horner`
Horner[ 11 х^3 -4 х^2 + 7 х + 2 ]
2+ х (7 + х (-4 + 11х))
Horner[ а х^3 + bх^2 + с х + d, х ]
d+ х (с + х (b + ах))
Horner[ х^(1/3) + х + х^(3/2) ]
Схема Горнера может использоваться и для отношения полиномов:
Horner [polyl/poly2] и Horner [polyl/poly2, varsl,vars2] .
Эти функции можно использовать для улучшенного представления аппроксимации Паде, что демонстрирует следующий пример:
<<Calculus ` Fade`
approx = Padef Exp[Log[x] -х] , {х, 0, 3, 2}]]
Horner[ approx ]

Переход к схеме Горнера дает ряд преимуществ перед обычным вычислением полиномов: уменьшается время вычислений, повышается их точность, уменьшается вероятность расхождения численных методов, в которых используются полиномы. В системе Mathematica 3 подпакет Corner находился в пакете расширения NumberMath, что было не вполне логично.

Операции в конечных полях — FiniteFields

Операции в конечных полях — FiniteFields
Поле является алгебраическим понятием, которое может быть определено как множество, имеющее не менее двух элементов, над которыми заданы две бинарные ассоциативные и коммутативные операции — сложения и умножения. Кроме того, для существования поля нужны два особых элемента — нуль 0, задающий правило сложения а + 0 = а, и единица 1 для задания правила умножения а*1 = 1. Определено также понятие противоположного элемента -а, такого что а + (-а) = 0, и обратного элемента а— 1 , такого что a- 1 а = 1. Поле характеризуется размером р и целым положительным целым d, называемым степенью расширения.
Пакет задает набор функций GF[p] [{k}], GF[p,l] [{k}], GF[p, {0,1}] [{k}], GF[p,d] HGF[p,ilist] [elist], действие которых иллюстрируют следующие примеры:
<<Algebra` FiniteFields`
GF[7][4] + GF[7][6]
{3}7
GF[3,4][1,2,1] GF[3,4][2,2,2,0]
{1, 1, 2, 0}3 GF[5,1][1] + GF[3,4][1,1,1]
{1, 1, 1, 0}3+ (1)5
Вряд ли подробное их описание заинтересует большинство читателей. Специалистов по полям не затруднит более детальное знакомство с этими функциями в разделе Add-ons справочной базы данных. Там же можно найти описание ряда других функций, относящихся к теории конечных полей.
Оценка интервалов изоляции корней полиномов — Rootlsolation
Следующие функции подпакета Rootlsotation позволяют оценивать интервалы изоляции для действительных и комплексных корней полиномов:

  • CountRoots [poly, {x,ml,m2} ] — возвращает число корней полинома poly от переменной х в комплексном интервале {ml, m2 };
  • RealRootsIntervals [poly] — возвращает разделенный интервал изоляции для вещественных корней полинома poly;
  • RealRootsIntervals [polyl,poly2,…] — возвращает разделенные интервалы изоляции для вещественных корней нескольких полиномов;
  • ComplexRootsIntervals [poly] — возвращает разделенный интервал изоляции для комплексных корней полинома;
  • ComplexlRootsIntervals [polyl, poly2,…] — возвращает разделенные интервалы изоляции для комплексных корней нескольких полиномов;
  • Contractlnterval [a,n] — возвращает интервал изоляции для числа а с точностью, задаваемой числом знаков результата п.

Применение этих функций поясняют следующие примеры:
<<Algebra`Rootlsolation`
f = (x^2- 1) (х^2- 3) (х^2- 5); CountRoots [f, {x, 1, 2}]
1
CountRoots[(х^2+2) х^4, {х, -I, 2 I}]
5
CountRoots[х^21- 1, {х, 0, 5 + 10*1}]
5
RealRootlntervals[f]
{{-4, -2}, {-2,.-1}, {-1, -1}, {1, 1}, {1, 2}, {2, 4}}
ComplexRootlntervals[f+5]
{{-1, 0}, {0, 1}, {-7-71, -7/4}, {-7, -7/4 + 7I},
{-7/4, -7I + 7/2}, {-7/4, -7/2 + 7I}}
ComplexRootlntervals[x^3, x^5+l]
{{{-2, 0}, {0, 0),
{-3-31, 0}, {-3, 31}, {-31, 3), {0, 3+31}}, {2, 1, 2, 2, 2, 2}}
Contractlnterval[Root[x^7- 1, 5], 5]
{ 58333/262144 + 511143I/ 524288+ 116665/524288+ 63893I/65536}
N[%]

{-0.222523+ 0.9749281, -0.222521 + 0.974931}

Пакет символьных преобразований тригонометрических функций

Пакет символьных преобразований тригонометрических функций
Следующий пакет служит для демонстрации символьных преобразований тригонометрических функций синуса и косинуса.
(* :Title: TrigDefine *)
(* :Context: ProgramminglnMathematica’TrigDefine" *)
BeginPackage["ProgramminglnMathematica’ TrigDefine’"]
TrigDefine::usage = "TrigDefine.m defines global rules for putting products of trigonometric functions into normal form."
Begin["’Private’"] (* set the private context *)
(* unprotect any system functions for which rules will be defined *)
protected = Unprotect[ Sin, Cos ] (* linearization *) Sin/: Sin[x_] Cos[y_] := Sin[x+y]/2 + Sin[x-y]/2
Sin/: Sin[x_] Sin[y_] := Cos[x-y]/2 — Cos[x+y]/2 Cos/: Cos[x_] Cos[y_] := Cos[x+y]/2 + Cos[x-y]/2
Sin/: Sin[x_]An_Integer?Positive :=
Expandt (1/2- Cos[2x]/2) Sin [x]^(n-2) ]
Cos/: Cos[x_]An_Integer?Positive :=
Expand[(l/2 + Cos[2x]/2) Cos[x]^(n-2)]
Protect[ Evaluate[protected]](* restore protection of system symbols *)
End[] (* end the private context *) EndPackage[] (* end the package context *)
Данный пакет задает преобразования для произведений sin(x) cos(x), sin(x) sin(y) и cos(x) cos(y), а также для sin(x) n и cos(x) n . Следующие примеры наглядно показывают работу с этим пакетом:
<< mypack\trigdefine.m
?Sin
Sin[z] gives the sine of z. Sin[a]*Cos[b]
1/2Sin[a-b] + 1/2 Sin[a+b]
Sin[a]*Sin[b]
1/2Cos[a-b] — 1/2Cos[a+b]
Cos[a]*Cos[b]
1/2 Costa-b] + 1/2Cos[a+b]
Sin[x]^2
1/2-1/2 Cos[2x]
Cos[x]^3
Sec[x]/4 +1/2Cos[2x] Sec[x] + 1/4(1/2 + 1/2 Cos[4x]) Sec[x]
Sin[x]^n
Sin[x]n
Данный пример — наглядная иллюстрация программирования символьных вычислений.
Пакет вычисления функций комплексного переменного
Еще один пакет расширений для вычисления функций комплексного переменного (блок пакетов ALGEBRA) представлен распечаткой, приведенной ниже.
(* :Title: Relm *)
(* :Authors: Roman Maeder and Martin Buchholz *) BeginPackage [ "Algebra ‘RelrrT "]
RealValued::usage = "RealValued[f] declares f to be a real-valued function
(for real-valued arguments)."
SBegin["’Private’"]
protected = Unprotect[Re, Im, Abs, Conjugate, Arg] (* test for "reality", excluding numbers *)
realQ[x_] /; !NumberQ[x] := Im[x] == 0 imagQ[x_] /; !NumberQ[x] := Re[x] == 0
(* fundamental rules *)
Re[x_] := x /; realQ[x] Arg[x_] := 0 /; Positive[x] Arg[x_J :=Pi /; Negative[x] Conjugate[x_] := x /; realQ[x] Conjugate[x_] := -x /; imagQ[x]
(* there must not be a rule for Im[x] in terms of Re[x] !! *) (* things known to be real *)
Im[Re[_]] := 0 Im[Im[_]] := 0 Im[Abs[_]] := 0 Im[Arg[_]] := 0 Im[x_?Positive] = 0 Im[x_?Negative] = 0
Im[x_ ^ y_] := 0,/; Positive[x] && Im[y] == 0 Im[Log[r ?Positive]] := 0
(*’ arithmetic *)
Re[x_Plus] := Re /@ x Im[x_Plus] := Im /@ x
Re[x_ y_Plus] := Re[Expand[x y]] Im[x_ y_Plus] := Im[Expand[x y]]
Re[x_ y_] := Re[x] Re[y]— Im[x] Im[y] Im[x_ y_] := Re[x] Im[y] + Im[x] Re[y]
(* products *)
Re[(x_?Positive y_) ^k_] := Re[x^k y^k] Im[(x_?Positive y_)^k_] := Im[x^k yAk]
(* nested powers *)
Re[(x_?Positive ^ y_ /; Im[x]==0)^k_] := Re[x^(y k)] Im[(x_?Positive ^ y_ /; Im[x]==0)"kj := Im[хл(у k)]
Re[ l/x_ ] := Re[x] / (Re[x]^2 + Im[х]^2) Im[ l/x_ ] := -Im[x] / (Re[x]"2 + Im[x]A2)
Im[x_^2] := 2 Re[x] Im[x]
Re[ x_^n_Integer ] := Block[{a, b},
a = Round[n/2]; b = n-a;
Re[x^a] Re[x^b] — Im[х^а] 1т[х^b] ]
Im[ x_^n_Integer ] :=Block[{a, b}, a = Round[n/2]; b = n-a; Re[x^a] Im[х^b] + Im[х^a] Re[x^b] ]
Re[x_IntegerAn_Rational] := 0 /; IntegerQ[2n] && Negative[x]
Im[x_IntegerAn_Rational] :=
(-х)лп (-1)л((Numerator[n]-l)/2 /; IntegerQ[2n] && Negative[x]
(* functions *)
Re[Log[r_?Negative]] := Log[-r] Im[Log[r_?Negative]] := Pi Re[Log[z_]] := Log[Abs[z]] /; realQ[z] Re[Log[z_]] := (1/2) Log[Re[z]^2 + Im[z]^2] Im[Log[z_]] := Arg[z]
Re[Log[a_ b_]] := Re[Log[a] + Log[b]]
Im[Log[a_ b_]] := Im[Log[a] + Log[b]]
Re[Log[a_^c_]] := Re[c Log[a]]
Im[Log[a_^c_]] := Im[c Log[a]]
Ке[Е^х_] :=Cos[Im[x]] Exp[Re[x]] Im[Е^х_] := Sin[Im[x]] Exp[Re[x]]
Re[Sin[x_]] := Sin[Re[x]] Cosh[Im[x]] Im[Sin[x_]] :=Cos[Re[x]] Sinh[Im[x]]
Re[Cos[x_]] := Cos[Re[x]] Cosh[Im[x]] Im[Cos[x_]] := -Sin[Re[x]] Sinh[Im[x]]
Re[Sinh[x_]] := Sinh[Re[x]] Cos[Im[x]] Im[Sinh[x_J] := Cosh[Re[x]] Sin[Im[x]]
Re[Cosh[x_]] := Cosh[Re[x]] Cos[Im[x]] Im[Cosh[x_]] := Sinh[Re[x]] Sin[Im[x]]
(* conjugates *)
Re[Conjugate[z_]] := Re[z] Im[Conjugate[z_]] :=
Conjugate[x_Plus]:= Conjugate /@ x Conjugate[x_Times]:= Conjugate /@ x Conjugate[x_^n_Integer]:= Conjugate[x]An Conjugate[Conjugate[x_]]:= x
(* real-valued rules *)
Attributes[RealValued] = {Listable, HoldAll} Attributes[RealValuedQ] = {HoldFirst}
RealValued[f_Symbol] := (f/: RealValuedQ[f] = True; f) RealValued[f ] := RealValued /@ {f}
Im[ (_?RealValuedQ) [_? (Im[#J ==0&)…] ] := 0
(* define built-in function to be real-valued *)
DoRules[flist_] := Block[{protected},
protected = Unprotect[flist];
RealValued[flist];
Protect[Evaluate[protected]]
]
DoRules[{Sin, Cos, Tan, ArcSin, ArcCos, ArcTan, ArcCot, Sinh, Cosh, Tanh, ArcSinh, ArcCosh, ArcTanh, Floor, Ceiling, Round, Sign, Factorial}]
Protect[Evaluate[protected]]
End[]
Protect[RealValued]
EndPackage[]
Как нетрудно заметить, в этом пакете задано вычисление действительной и мнимой частей для ряда тригонометрических, гиперболических и числовых функций. далее…

Циклы for и while

Циклы for и while
Зачастую необходимо циклическое повторение выполнения выражения заданное число раз или до тех пор, пока выполняется определенное условие. Maple 15 имеет обобщенную конструкцию цикла, которая задается следующим образом:
| for <name>| |from <exprl>| |to <expr3>| |by <expr2>| (while <expr4>| do Statement sequence> od;
Здесь name — имя управляющей переменной цикла, exprl, ехрr2 и ехрrЗ — выражения, задающие начальное значение, конечное значение и шаг изменения переменной name, ехрr4 — выражение, задающее условие, пока цикл (набор объектов между словами do и od) будет выполняться.
В ходе выполнения цикла управляющая переменная меняется от значения exprl до значения ехрr2 с шагом, заданным ехрrЗ. Если блок by <ехрr2> отсутствует, то управляющая переменная будет меняться с шагом +1 при ехргКехрг2. Это наглядно поясняет следующий пример:
> for i front 1 to 5 do printd) od;
1
2

4
5
В нем выводятся значения переменной i в ходе выполнения цикла. Нетрудно заметить, что она и впрямь меняется от значения 1 до значения 5 с шагом +1. Следующий пример показывает, что границы изменения управляющей переменной можно задать арифметическими выражениями:
> for i from 7/(2+5) to 2+3 do printd) od:
1
2
3
4
5
А еще один пример показывает задание цикла, у которого переменная цикла меняется от значения 1 до 10 с шагом 2:
> for i from 1 to 10 by 2 do printd) od: 1 3 5 7 9
8 этом случае выводятся нечетные числа от 1 до 9. Шаг может быть и отрицательным:
> for i from 9 to 1 by -2 do print(i) od:
9
7
5
3
1
Следует отметить, что если exprl>expr2 задать заведомо невыполнимое условие, например, ехрr1>ехрг2 и положительное значение шага, то цикл выполняться не будет. Цикл можно прервать с помощью дополнительного блока while <ехрr4>. Цикл с таким блоком выполняется до конца или до тех пор, пока условие ехрг4 истинно.
> for i from 1 to 10 by 2 while i<6 do print(i) od:
1
3
5
Таким образом, конструкция цикла в Maple-языке программирования вобрала в себя основные конструкции циклов for и while. Есть еще одна, более специфическая конструкция цикла:
|for <name>| |in <exprl>| |whi1e <expr2>| do statement sequence> od:
Здесь exprl задает список значений, которые будет принимать управляющая переменная name. далее…