Встроенные процедуры дифференцирования

 

Для дифференцирования выражения e по переменным x, y и т.д. используют следующие две команды в среде Maple

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

D - позволяет найти дифференциал функции и дифференцировать процедуры;

implicitdiff - позволяет дифференцировать функции, заданные уравнением.

Пример 5 (дифференцирование).

> Diff(sin(x),x);

> diff(sin(x),x);

> Diff(sin(x),x$3);

> value(");

В последнем примере мы задали порядок дифференцирования.

Если функция не задана явно, то

> diff(f(x),x);

> diff(f(x,y),x,y);

Аналогично вычисляются и дифференциалы

> D(sin);

> D(ln);

> D(f);

> D(f)(0); # Производная от f вычисляется в точке 0

> D(D(f));

> (D@@2)(f); # Дифференциал старшего порядка как композиция простых дифференциалов

 

> D(f@g); # Дифференциал от композиции двух функций

Эта комманда позволяет дифференцировать и составные выражения. Например, предположим, что a -это число

> assume(a,constant);

> D(2*sin(a)*f);

Дифференциал можно преобразовать в производную и обратно

> f:= D(y)(x) - a*D(z)(x);

> convert(f, diff, x);

> f:= diff(y(x), x$2);

> convert(f, D);

Рассмотрим уравнение, которое определяет x(y) или y(x)

> f:= x^2+y^3=1

Продифференцируем y по x или x по y

> implicitdiff(f,y,x);

> implicitdiff(f,x,y);

> implicitdiff(f,y,z);

> implicitdiff(f,y(x),x);

> implicitdiff(f,y,x,x);

 

Определение собственных функций

 

Необходимо отличать выражение вида f:=x^n+y с четко определенным значением от отображения (функционала) вида переменные -> результат, которое является символом. Внутреннее представление данного отображения эквивалентно написанию процедуры вида proc(переменные) option operator, arrow; результат end

Рассмотрим, на примерах, различия между этими понятиями

Пример 7 (выражения).

> restart:

> f:=x^3+у^4+z;

с подстановкой и дифференцированием вида

> subs(x=1,y=5,z=-1,f);

> diff(f,x);

> Diff(f,y); value(");

Пример 8 (отображения).

> restart:

> F:= (x -> sin(x));

> F(t);

> g:=(x)->x^2+y^4+z;

с подстановкой и дифференцированием вида

> g(1);

> D(g);

> D(g)(3);

Для случая многих переменных это так же несложно

> f:= (x,y) -> exp(x*y);

> f(1,1);

> D[1](f);

> D[2](f);

Данные определения выражения и отображения отличаются не только способом вычисления в заданной точке и дифференцированием, но и рядом других свойств. Например, с помощью команд map и map2 можно применять заданное отображение к матрицам, спискам или другим более сложным объектам

Пример 9 (команда map).

> restart:

> map(f, x + y*z);

> map(f, y*z);

> map(f, {a,b,c});

Зададим какое-нибудь отображение

> f:=x-> x^5+1;

> L:=[1,-2,x,y,9];

> map(f,L);

Более сложное использование данных команд

> restart:

> map2(map, f, g(a+b, h(c)+d));

Выражение можно всегда переопределить как функционал командой unapply. Фактически, в Maple даже дифференциал определён таким образом D(f) = unapply(diff(f(x), x), x). Напомним, что дифференциал преобразуется к производной и обратно командой convert.

Пример 10 (выражения и отображения).

> restart:

> q:= x^2 + y^3 + 1;

> f:= unapply(q,x);

> f(2);

> g:= unapply(q,x,y);

Определим процедуру по правилу

> f:= proc(x) local t1,t2;

> t1:= x^2;

> t2:= sin(x);

> 3*t1*t2+2*x*t1-x*t2

> end:

Вычислим производную от f по аргументу x

> D(f);

Проверим вычисление производной

> D(f)(x) - diff(f(x),x);

Следующим отличием отображений от выражений является то, что оператор композиции @, можно применять только для отображений. Данный оператор позволяет не только создавать сложные функции, но и является наиболее эффективным для создания обратных функций.

Пример 11 (композиция функций).

> sin@cos)(x);

> (sin@arcsin)(x);

> sin@arcsin;

> simplify(");

> sin@@0;

> sin@@1;

> (sin@@2)(x);

> (D@@2)(ln);

Обратные функции строяться аналогично

> sin@@(-1);

> ln@@(-3);

> LambertW@@(-1);

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

> readlib(invfunc);

> invfunc[sin](1);

> Invfunc[sin](1);

> Invfunc[exp](x);

 

Интегрирование

 

Встроенные команды интегрирования

 

В стандартной (загруженной по умолчанию) библиотеке находяться процедуры Int (expr, options) и int (expr,options), т.е. символ и значение. Синтаксис и опции можно найти в справочнике int.

Пример 1 (определенные и неопределенные интегралы).

> f:=sin(x):

> g:=Int(f,x);

> value(g);

> int(f,x);

Таким образом, мы видим,. что обозначения максимально приближены к обычной математической записи. Для вычисления определенного интеграла надо дополнительно указать пределы интегрирования

> f:=x*exp(x):

> g:=Int(f,x=0..1);

> value(g);

> int(f,x=0..1);

Рассмотрим более сложные интегралы

> f:=sin(x^3):

> g:=int(f,x=0..Pi);

> h:=evalf(g);

или

> g:=Int(x/(x^3-x^2+1),x);

> value(g);

здесь сумма берется по %1 - корням полинома в скобках.

Иногда, при интегрировании получаются многозначные функции, при этом, по умолчанию, Maple использует только одно значение. Список многозначных функций и их принципиальные ветви можно посмотреть следующей командой

> restart: readlib(branches):

> branches(ln);

Рассмотрим интегралы с параметрами

> f:=exp(-a*x)*ln(x)*sqrt(x);

> int(f,x=0..infinity);

Как видим, этот интеграл неопределен при всех значениях параметра. Сделаем дополнительные предположения

> assume(a<0): int(f,x=0..infinity);

Сравним с

> assume(a>0): int(f,x=0..infinity);

Полученные при интегрировании эллиптические функции, зависящие от радикалов можно упростить

> answer:= int(1/sqrt(sin(x)), x=0..Pi/2);

> radnormal(answer);

Интегралы, которые не выражаются через алгебраические функции, можно представить как ряд

> int(exp(x^3), x);

> series(", x=0);

В общем случае синтаксис для численного интегрирования имеет вид

evalf (Int (f, x = a..b, digits, flag)),

где digits- точность вычисления, и flag- код численного метода, см. int[numerical]

> int(exp(v-v^2/2)/(1+1/2*exp(v)), v = -infinity..infinity);

> evalf(", 20);

Здесь digits равно 20. Другой пример - интегрирование гамма функции с использованием алгоритма Ньютона-Котеса:

> evalf(Int(1/GAMMA(x), x = 0..2, 10, _NCrule));

Более сложные опции позволяют вычислять главное значение интеграла и реализуют некоторые дополнительные возможности

> int(1/x^3, x=-1..2, 'CauchyPrincipalValue');

> int(1/(x+a)^2, x=0..2, 'continuous');

В принципе, различные эвристические методы, такие как интегрирование по частям и замены переменных, не используются явно, например.

Рассмотрим несколько интегралов, которые берутся по частям или с использованием различных замен переменных

Пример 2 (интегрирование по частям и другие методы).

> int(x*ln(x),x);

> int(x*sin(x^2),x);

> Int(x^2/(sqrt(1-x^2))^(3/2),x):

> value(");

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

Пример 3 (интегрирование с пакетом student).

Для начала мы очистим рабочую память и загрузим данный пакет.

> restart:

> with(student);

При загрузке любого пакета Maple выдает список всех загружаемых команд.

Замены переменных:

> f:=Int(sqrt(1-x^2),x=a..b);

> g:=changevar(x=sin(u),f,u);

Здесь мы вводим новую независимую переменную интегрирования u, связанную со старой переменной уравнением x=sin(u) (пределы интегрирования изменились автоматически!) Посмотрим на результат

> value(g);

В двойных интегралах интегралах это позволяет, например, перейти к полярным координатам:

> changevar({x=r*cos(t),y=r*sin(t)}, Doubleint(1,x,y),[t,r]);

Интегрирование по частям:

напомним, что правило интегрирования по частям записывается следующим образом

> f:=Int (u,v)=u*v-Int(v,u);

Синтаксис данной команды intparts(f,u)

> a:=Int(x^2*exp(x),x);

Проинтегрируем по частям

> b:=intparts(a,x^2);

проинтегрируем по частям второй раз

> c:=intparts(b,2*x);

и получим результат

> d:=value(c);

Другие полезные команды для интегрирования из данного пакета

> integrand(Int(h(x),x));

и

> Doubleint(h(x,y),x,y);

> Tripleint(h,x=1..n,y=2..4,z=w..u);

Кроме этого, в пакете student реализовано несколько численных методов:

leftbox, leftsum, rightbox, rightsum, middlebox, middlesum, simpson, trapezoid,

Синтаксис для всех команд одинаков, рассмотрим только один пример

Пример 4 (численное интегрирование).

> restart: with(student):

> f:=x^5*ln(x);

Явное интегрирование данной функции можно посмотреть в справочнике, мы же сравним численные значения

> ex:=evalf(int(f,x=1..3));

> s:=evalf(simpson(f,x=1..3,16));

> t:=evalf(trapezoid(f,x=1..3,16));

> ls:=evalf(leftsum(f,x=1..3,16));

Покажем это на рисунке

> leftbox(f,x=1..3,16,color=red,shading=BLUE);

Аналогично и для других команд

> rs:=evalf(rightsum(f,x=1..3,16));

> rightbox(f,x=1..3,16,color=red,shading=BLUE);

и

> ms:=evalf(middletsum(f,x=1..3,16)));

> middlebox(f,x=1..3,16,color=red,shading=BLUE);