Лекция 1. Введение.

В пакет Mathematica встроено подробное описание (help). Чтобы в него попасть, нажмите F1 или войдите через меню Help/Documentation Center.

Элементарные операции для работы с Mathematica

После запуска программы, на экране появляется несколько независимых окон. Вдоль верхней части экрана расположено меню. Слева - рабочее окно. Можно открыть много рабочих окон, выполнив в меню команду File/New/Notebook(.nb). Как видно из названия команды, рабочее окно называется Notebook.
	Если в рабочее окно ввести произвольный символ, то этот символ отобразится в окне, а справа появитя вертикальная скобка, ограничивающая текущее рабочее поле. При дальнейшем вводе новые символы буду также отображаться в рабочем поле. Если произойдет переход на следующую строку, правая скобка расширится. Эта скобка указывает на независимую область, в которой можно расположить команды языка Mathematica и одновременно их выполнить. Область, ограниченная скобкой, называется клеткой (Cell). Если стать на последней строке клетки и нажать на стрелочку вниз, или же стать первой  строке клетки и нажать на стрелочку вверх, то курсор превратится в вертикальную линию, расположенную рядом с клеткой. Если опять ввести символ, то появится новая клетка, в которую также можно вводить текст. Кроме того, переходить от клетки к клетки, а также позиционировать курсор между клетками можно с помощью мышки.
	В клетки можно вводить произвольные выражения (Expression) и вычислять (Evaluate) их. Для вычисления нужно, находясь внутри клетки, выполнить команду shift+Enter. Поместите курсор внутрь следующей клетки, в которой написано 2+2, и выполните shft+Enter.

2+2

После выполнения команды shft+Enter слева от выражения появится In[1], нумерующее последовательно выполняющиеся команды. Кроме того, возникнет еще одна клетка с результатом, который будет помечен Out[1]. Заметим, что клетка ввода и вывода объединены в одну большую клетку. Вы можете манипулировать результатом многими способами. Один из них - использование символа %, которому присвоен результат последней выполненной команды; последовательности %% - результат выполнения предпоследней команды; %%%  - предпредпоследней и т.д. , а также %n - результат выполнения команды с номером n.

Основные принципы пакета Mathematica

Объекты, которыми оперирует Mathematica :
          	1) числа (Numbers), например, 5, 2/3, 2.35
      	2) символы (Symbols), например, x, abc5
    	3) строки (Strings), например, "это - строка"
  	4) выражения (Expressions), например, (x + 2)/(y - 2.3)

Замечания.
1) имеется несколько способов визуализации одного и того же выражения, например,

(1 + 2. - 5.77*3.8)/((3.2 - 0.1)^(1/2) + 6^2) 

((1+2.-5.77 3.8)/((Sqrt[3.2-0.1])+(6^2)))

Times[
   Plus[1, 2.`, Times[-1, Times[5.77`, 3.8`]]], 
   Power[Plus[Power[Plus[3.2`, -0.1`], Times[1, Power[2, -1]]], Power[6, 2]], -1]
   ]

В последнем случае Times[x,y] обозначает произведение x и y, 
                                 Plus[x,y] - их сумму
                                 Power[x,y] - x в степени y

Три типа визуализации выражений:

(станьте в клетку, вид которой хотите изменить, и выполните соответствующую команду)

InputForm (CtrlShft+i):

(1 + 2. - 5.77*3.8)/(Sqrt[3.2 - 0.1] + 6^2)

StandardForm (CtrlShft+n):

((1+2.-5.77 3.8)/((Sqrt[3.2-0.1])+(6^2)))

TraditionalForm (CtrlShft + t) :

((1+2.-5.77 3.8)/((Sqrt[3.2-0.1])+(6^2)))

Ввод с клавиатуры в StandardForm: использование Ctrl, Esc, Palettes
Ctrl+/ - дробь (a/b);  Ctrl+2 - радикал (Sqrt[x]); Ctrl+^ - верхний индекс (x^2), Ctrl+_ - нижний индекс (Subscript[x, 2])
Esc pi Esc - число π; Esc ee Esc - число e; Esc ii Esc - мнимая единица i;  Esc int Esc - интеграл ∫  ; Esc sum Esc - сумма ∑ ; Esc a Esc - альфа α ; Esc g Esc - гамма γ ...

Все выражения являются композицией атомарных объектов-выражений (чисел, символов и строк) и  выражений вида f[x,y,...]

Выражение

(1 + 2. - 5.77*3.8)/((3.2 - 0.1)^(1/2) + 6^2)

в действительности имеет вид

Times[Plus[1, 2.`, Times[-1, Times[5.77`, 3.8`]]], Power[Plus[Power[Plus[3.2`, -0.1`], Times[1, Power[2, -1]]], Power[6, 2]], -1]]

Основная работа Mathematica - вычисление (Evaluation) выражений

(чтобы вычислить выражение, поместите курсор внутрь содержащей его клетки и выполните команду shft + Enter)

(1 + 2. - 5.77*3.8)/((3.2 - 0.1)^(1/2) + 6^2)

Арифметические операции (+, -, *, /, ^ ); "*" можно не писать (вместо нее - пробел, который Mathematica в некоторых случаях автоматически заменяет соответствующим значком)

a b 2 3 c d+ x y-2 z

Matematica различает строчные (маленькие) и прописные (заглавные, большие) буквы

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

Встроенные символы, примеры

Pi
E
I

Чтобы вывести соответствующее десятичное представление для выражения expr, нужно выполнить команду N[expr] или  N[expr,n] , где n - число цифр в десячичном представлении, например

N[Pi]
N[Pi,10]
N[100Pi,10]
N[E]
N[I]

Присвоение значений  командой Set или "=" (создание правила замены символа на присвоенное значение) и снятие присвоений командой Unset или "=."

x=2

x

x=.

x

Встроенным символам переприсвоить нельзя

Pi=10

Pi
N[Pi]

Pi=.

Pi
N[Pi]

Выражения f[a,b,...]

Встроенные :

Sin[π/2]

Создание выражений :

f[x_]:= (x^2)

f[2]
f[a]
f[Sin[x]]+f[Cos[x]]

Значок ":=" называется SetDelayed и он отличается от значка "=" Set тем, как осуществляется вычисление присвоенного выражения. Set  вычисляет правую часть rhs формулы lhs = rhs  еще до присвоения и результат присваивает  левой части lhs; SetDelayed присваивает левой части lhs невычисленную правую часть rhs, и при каждом вычислении левой части присвоенная правая часть вычисляется заново с использованием текущих значений связанных с rhs объектов

Для примера используем функцию Random[], которая выдает случайное вещественное число в пределах между 0 и 1. В первом примере перед присвоением вычисляется некоторое случайное число и результат присваивается переменной z, поэтому при каждом появлении z заменяется на одно и то же присвоенное число. Во втором примере z присваивается неотработанная функция Random[], и при каждом появлении z эта функция вычисляется каждый раз заново, чем и объясняется разные результаты вычисления z.

z=Random[]
z
z

z:=Random[]
z
z

z =.

Еще один пример

y=2

f[y_]=(y^3)

g[y_]:=(y^3)

f[w]
g[w]

y=.

Чтобы очистить сделанное присвоение вида f[x_]=rhs или f[x_]:=rhs, выполните команду Clear[ f]

Clear[f]
Clear[g]

f[x]
g[x]

Для одновременной очистки нескольких присвоений, сделанных для f, g, ... можно использовать Clear[f, g, ...]

f[x_]:=(x^2)
g[x_]:=(x^3)
f[x]
g[x]

Clear[f,g]
f[x]
g[x]

Некоторые другие способы записи выражений f[x]

f[x_]:=(x^2)
g[x_,y_]:=x (y^2)

В приведенных ниже первых трех примерах вычисляется значение функции f на переменной x = 2; в четвертом примере вычисляется значение функции g на переменных x = 2 и y = 3

f[2]  (* Standard форма *)
f@2 (* Prefix форма *)
2//f (* Postfix форма *)
2~g~3 (* Infix форма *)

Clear[f]
Clear[g]

Задание функции непосредственно, без присвоения и без имени (безымянные функции, Pure functions)

в приводимых ниже примерах значок "#" используется для обозначения единственной переменной задаваемой функции, значки "#1", "#2", ... - соответственно первая. вторая и т.д. переменные для функции многих переменных; значок "&" ставится после описания функции и обозначает, что стоящее слева от него выражение надо рассматривать как определение функции, а все вместе с ним - как саму функцию

(((#)^2)+2)& [x]

(#1^2+#2^4)&[x,y]

f=(((#)^2)+2)&

f[x]

Clear[f]

Подавление вывода результата и расположение команд внутри одной клетки

Если после команды ставится точка с запятой ";", то вывод результата не происходит

2+2

2+2;

На одной строке можно писать сразу несколько команд, разделяя их ";" (выводы результатов этих команд производиться не будут); можно писать одну команду срезу на нескольких строках

f[x_]:= (x^2); g[x_,y_]:=(x^2)+(y^3); h[x_,y_]:=
3x y;

f[a]
g[b,c]
h[d,e]

Clear[f,g,h]

Списки List[x,y,...] или {x,y,...}

{x,{a,b},z}

Доступ к элементам списка (команда Part или  [[ ...]])

{x,{a,b},z}[[3]]
Part[{x,{a,b},z},3]

{x,{a,b},z}[[2,1]]
Part[{x,{a,b},z},2,1]

{x,{a,b},z}[[{1,3,1,2,3,3}]]

{1,2,3,4,5,6,7}[[2;;5]]

Вместо скобок "[ [ " и "] ]"  удобно изображать "[[" и "]]", которые получаются  набором последовательностей   "Esc [ [ Esc"  и "Esc ] ] Esc" соответственно

{x,{a,b},z}[[3]]

Арифметические операции над списками - покомпонентные

{1,2,3}+{x,y,z}

{1,2,3}x

{1,2,3}{x,y,z}

{1,2,3}/{x,y,z}

Специальные операции над списками

{1,2,3}.{x,y,z}

{{a, b}, {c, d}} . {x, y}

Список {{a, b}, {c, d}} представляет собой матрицу и может быть визуализирован в привычной форме (({{a, b}, {c, d}})) с использованием палетки

(({{a, b}, {c, d}})).{x, y}

(({{a, b}, {c, d}})).(({{x, y}, {z, t}}))

Чтобы вывести список в матричной форме, можно использовать команду MatrixForm

(({{a, b}, {c, d}})).(({{x, y}, {z, t}}))//MatrixForm

Применение функций к спискам

функция Sin, примененная к списку, вычисляется на каждом элементе списка (функции, обладающие таким свойством, называются Listable)

Sin[{1,2,3,4,5}]

не всякая функция является Listable

f[{1,2,3,4,5}]

чтобы применить функцию f, не являющуюся Listable, к списку list, можно воспользоваться командой Map[f, list]

Map[f,{1,2,3,4,5}]

функцию f удобно задавать непосредственно внутри команды Map, не присваивая ей имени

Map[((#)^2)&,{1,2,3,4,5}]

также бывает необходимо применять функции f нескольких переменных к набору списков; для этого служит команда MapThread[f, {list1, list2, ...}]

MapThread[((#1)^2)-((#2)^3)&,{{1,2,3},{x,y,z}}]

Создание списков

следующая команда задает список от 1 до 17 с шагом 2

Table[k,{k,1,17,2}]

следующая команда задает матрицу из трех строк (нумеруются i) длины 5 (элементы строки нумеруются j), в которой (i,j)-ый элемент иммет вид  i+j

Table[i+j,{i,1,3},{j,1,5}]

следующая команда создает список натуральных чисел от 1 до 5

Range[5]

следующая команда объединяет списки

Join[{1,2,3},{3,4,5}]
{1,2,3}~Join~{3,4,5}

следующая команда объединяет подсписки в единый список (убирает внутренние фигурные скобки)

(({{1, 2}, {3, 4}}))
Flatten[(({{1, 2}, {3, 4}}))]

следующая функция создает список из последовательных непересекающихся подсписков длины 3

Partition[{a,b,c,d,e,f,g},3]

m={{1,2,3},{4,5,6},{7,8,9}};
m//MatrixForm
Transpose[m] //MatrixForm

Некоторые графические возможности

Plot[Sin[x],{x,-4π,4π}]

Plot3D[x^2-y^2,{x,-1,1},{y,-1,1}]

ParametricPlot[{Cos[t],Sin[t]Cos[t]},{t,0,2π}]

ParametricPlot3D[{8Cos[t],8Sin[t],t},{t,0,6π}]

ParametricPlot3D[{Cos[u],Sin[u]Cos[v],Cos[v]},{u,0,2π},{v,0,2π}]

Визуализация зависимости от параметра

Катеноид (минимальная поверхность вращения)

ParametricPlot3D[{Cosh[u]Cos[v],Cosh[u]Sin[v],u},{u,-1,1},{v,0,2π}]

Геликоид (минимальная линейчатая поверхность)

ParametricPlot3D[{Sinh[u]Sin[v],-Sinh[u]Cos[v],v},{u,-1,1},{v,0,2π}]

Изгибание катеноида в геликоид

(здесь PlotRange описывает отрезки изменения координат {x,y,z} точек поверхности; Mesh - координатная сетка на поверхности, в данном случае Mesh -> None означает, что сетка отсутствует; PlotPoints - количество точек на каждой координатной кривой: чем больше точек, тем более гладко выглядит поверхность, хотя прорисовка замедляеся; α - параметр изгибания)

Manipulate[ParametricPlot3D[Cos[α]{Cosh[u]Cos[v],Cosh[u]Sin[v],u}+Sin[α]{Sinh[u]Sin[v],-Sinh[u]Cos[v],v},{u,-1,1},{v,0,2π},
PlotRange->{{-1.6,1.6},{-1.6,1.6},{-1,6.5}},Mesh->None,
PlotPoints->30],
{α,0,(π/2)}]

Дифференцирование и интегрирование

f[x_]:= (x^2)Sin[x]
D[f[x],x]
f'[x]
Integrate[f[x],x]
∫f[x]\[DifferentialD]x
Integrate[(x^2),{x,a,b}]
(∫_a^b)(x^2)\[DifferentialD]x

Численное интегрирование

NIntegrate[Sin[Cos[x]],{x,1,2}]
(∫_1^2)Sin[Cos[x]]\[DifferentialD]x
N[(∫_1^2)Sin[Cos[x]]\[DifferentialD]x]

Замена фрагментов выражения expr по правилам rules (ReplaceAll): 
expr /. rules

(значок "->" получается последовтельным набором - и > или с использованием палетки (palettes) BasicMathInput)

{Cos[x],x^2+z^3,y,z}/.x->b

{Cos[x],x^2+z^3,y,z}/.Cos->Sin

{Cos[x],x^2+z^3,y,z}/.z->{a,b}

{Cos[x],x^2+z^3,y,z}/.{x->a,y->b}

{Cos[x],x^2+z^3,y,z}/.{{x->a},{y->b}}

{Cos[x],x^2+z^3,y,z}/.{x->a,a->b}

{Cos[x],x^2+z^3,y,z}/.x->a/.a->b

(значок ":>" получается последовтельным набором : и > или с использованием палетки (palettes) BasicMathInput)
в отличие от "lhs->rhs", которое сначала вычисляет rhs, а потом заменяет на результат вычислений все вхождения lhs, правило "lhs:>rhs" вычисляет rhs отдельно для каждого вхождения lhs

{x,x,x}/.x->Random[]
{x,x,x}/.x:>Random[]

Равенства и неравенства

(значки "==",  "≥" и  "≤" получаются последовательным набором = =, > = и < = соответственно или с использованием палетки (palettes) BasicMathInput)

x==2
x>3
x≥3
(x≥3&&x≤6)||(x==8)

Решение  уравнений и неравенств

res=Solve[a (x^2)+b x+c==0,x]

x/.res[[1]]

Solve[{(x^2)- y-4==0,y+3x==2},{x,y}]

Reduce[a (x^2)+b x+c==0,x]

Reduce[-1≤ x+y≤1&&(x^2)+(y^2)==2,{x,y}]

Clear[res]

Решение  диффренциальных уравнений

res=DSolve[x''[t]-x'[t]==2,x[t],t]

f[t_]=x[t]/.res[[1]]/.{C[1]->1,C[2]->0}

Plot[f[t],{t,-1,1}]

Clear[f,res]

Численное решение  диффренциальных уравнений

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

res=NDSolve[{x''[t]-Sin[x'[t]]==2,x[0]==1,x'[0]==2},x,{t,0,1}]

f=x/.res[[1]]

f[0]
f'[0]

Plot[f[s],{s,0,1}]

Clear[res,f]

Преобразование выражений, упрощение

(((x+y))^5)

(((x+y))^5)//Expand

(1/x)+((x-2)/((x^2)+3))

8 (x^2)-6 (x^3)+(x^4)-2 (x^2) y+(x^3) y-8 (y^3)+6 x (y^3)-(x^2) (y^3)+2 (y^4)-x (y^4)//Factor

(1/x)+((x-2)/((x^2)+3))//Together

((Sin[x])^2)+((Cos[x])^2)

((Sin[x])^2)+((Cos[x])^2)//Simplify

Программирование

Булевы операции

And[] или && или ∧  (Esc && Esc) 
Or[] или || или ∨ (Esc || Esc)
Not[] или ! или ¬ (Esc ! Esc)
Equal[] или == 
Unequal[] или !=
.............................
True, False
>,  >=, <, <=

2>1&&π>3

1>2||π>3

!x>1

2+2==4

1≠2

Условные операторы

Оператор If[condition, t, f] или If[condition, t, f, u]
если  условие дает True, то выполняется часть t, если условие дает False, то выполняется часть f, если условие не дает ни True ни False, то выполняется часть u

abs[x_]:=If[x<0,-x,x]
Map[abs,{1,0,-1,y}]

abs1[x_]:=If[x<0,-x,x,"значение не сравнимо с нулем"]
Map[abs1,{1,0,-1,y}]

Оператор Which[test1, value1, test2, value2, ...]
последовательно выполняет тесты, возвращая значение value для первого теста, дающего True

a=2;Which[a==1,x,a==2,b,a==2,c]

lhs := rhs /; test - присвоение происходит только в случае, когда тест дает True (Condition[])

f[x_]:=(Sqrt[x])/;x≥ 0

Map[f,{4,-4}]

Операторы цикла и контроля

Оператор Do[expr, {i, imax}] выполняет expr для всех i между 1 и imax
Оператор Do[expr, {i, imin, imax, di}] выполняет expr для всех i между imin и imax с шагом di
Оператор Do[expr, {i, list}] выполняет expr для всех i из списка list
Оператор Do[expr, {i, {n}}] выполняет expr n раз

(в приводимом ниже примере команда Print выводит результат на экран)

Do[res=(i^2);Print[res],{i,3}]

t=x;Do[t=1/(1+k t),{k,2,6,2}];t

Do[Print[(i^2)],{i,{3,6,8}}]

t=x;Do[t=1/(1+t),{3}];t

Вложенные циклы Do[expr, {i1, ...}, {i2, ...}, ...]

Do[Print[{i,j}],{i,4},{j,i-1}]

Оператор While[test, body] выполняет body до тех пор, пока test дает True

(n++ означает увеличение n на единичку; равносильно n = n + 1)

n=1;m=1;While[n≤5,m=m n;n++;Print[m]]

Оператор For[start, test, incr, body] выполняет start, затем последовательно выполняет body и incr до тех пор, пока test дает True

For[i=1;t=x,i^2<10,i++,t=t^3+i;Print[t]]

Break[] выходит из ближайшего цикла
Continue[] переходит к следующему шагу в текущем цикле
Return[expr] возвращает значение expr, выходя при этом из всех процедур и циклов в функции
Goto[name] переходит к элементу Label[name] в текущей процедуре

(оператор t *= k равносилен t = t*k)

t=1;Do[t*=k;Print[t];If[t>19,Break[]],{k,10}]

В следующем примере PrimeQ[n] дает True, если n - простое число

Do[If[!PrimeQ[k],Continue[],Print[k]],{k,15}]

f[x_]:=(If[x<0,Return[-(x^2)]];(x^2))
Plot[f[x],{x,-1,1}]

x=2;Label[start];Print[x];x+=2;If[x<8,Goto[start]]

Clear[abs,abs1,a,res,i,m,n,t,f,x]

Последовательности команд; локализация переменных

Как при определении выражений, так и в полях, отведенных для аргументов, можно писать не одно выражение, а последовательности выражений. Ниже приведены правила написания таких последовательностей.

1) Выражения последовательности разделяются точкой с запятой ";".
  2) Если после последнего выражения нет ";" , то результат вычисления этого последнего выражения выводится (например, в случае, когда последовательность введена в том месте, где должен стоять аргумент, значение присваивается аргументу). Если после последнего выражения стоит ";" , то результат не выводится.
  3) При задании последовательности выражений, которую нужно присвоить некоторому выражению, или при задании безымянных функций, эта последовательность берется в круглые скобки

For[
i=1;j=1,
i+j≤10,
i++,
If[PrimeQ[i]&&PrimeQ[j]&&i≤j,Print[{i,j}]];  If[j<9&&i+j==10,j++;i=1]
]

f[y_]:=(If[y>0,x="+"]; If[y<0,x="-"];If[y==0,x="!"];x)
f[2]

g[y_]:=(If[y>0,x="+"]; If[y<0,x="-"];If[y==0,x="!"];x;)
g[2]

Map[(If[#>0,x="+"]; If[#<0,x="-"];If[#==0,x="!"];x)&,{1,-1,0}]

Map[(If[#>0,x="+"]; If[#<0,x="-"];If[#==0,x="!"];x;)&,{1,-1,0}]

Clear[i,j,x,f,g]

В выражении Module[{x,y,...}, expr] переменные x,y,... локальны, т.е. определены лишь внутри этой конструкции. При этом значения одноименных переменных, определенных снаружи, не используются при вычислении модуля, в то время как  значения неодноименных наружных переменных используются.

Из приведенного примера видно, что внутренняя переменная x на самом деле имеет другое имя

x=1;
y=2;
z=3;
Module[{x},x]
Module[{x},x=5;z=6;x y]
x
z

Локальным переменным можно присваивать начальные значения прямо в месте их декларации, т.е. Module[{x=x0,y=y0,z,...}, expr] 
(AxesOrigin в команде Plot задает координаты точки, через которую проводятся координатные оси)

f[x0_]:=
Module[{x=x0,y=5,z},z=y-x; If[z≥0,5,x]
];
Plot[f[x],{x,0,10},AxesOrigin ->{0,0} ]

Выражение Block[{x,y,...}, expr] вычисляется со значенияим переменных x,y,..., заданных внутри блока. При этом значения одноименных переменных, определенных снаружи, используются при вычислении модуля, если они не были переопределены в блоке. Переопределенные в блоке переменные x,y,... при выходе из блока восстанавливают свое предыдущее значение.

x=2;
Block[{x},x]
Block[{x=5},x]
x

Clear[x,y,z,f]

Упражнения

(А.С.Мищенко, Ю.П.Соловьев, А.Т.Фоменко. сборник задач по дифференциальной геометрии и топологии)

(2.1) Точка M равномерно движется по прямой ON, равномерно вращающйся вокруг точки O. Составить уравнение траектории точки M (спираль Архимеда).

Решение. Пусть O - начало координат.

Если (Subscript[φ, 0]) - начальный угол между прямой ON и положительным направлением оси абсцисс,а ω - угловая скорость вращения прямой ON вокруг O, то в момент времени t угол φ[t] между ON и осью абсцисс равен

φ[t_]:=φ0+ω t

Если r - начальное расстояние от M до O равно (Subscript[r, 0]), а скорость движения по прямой ON  точки O равно v, то в момент времени t расстояние r[t] между M и O равно

r[t_]:=r0+v t;

Таким образом, координаты точки M в момент времени t равны

γ[t_]:=r[t]{Cos[φ[t]],Sin[φ[t]]}

γ[t]

Изобразим траекторию при следующих значениях параметров: (Subscript[φ, 0])=0, (Subscript[r, 0])=1,ω=5,v=1,t∈[0,10]

ParametricPlot[γ[t]/.{φ0->0,r0->1,ω->5,v->1},{t,0,10}]

Clear[φ,γ,r]

(2.19) Под каким углом пересекаются кривые (x^2) = 4 y и y = (8/((x^2)+4))?

Решение. Найдем точки пересечния кривых.

res=Solve[{(x^2)==4y,y==(8/((x^2)+4))},{x,y}]

Так как кривые вещественные, подходят лишь 3 и 4 решения. Так как кривые инвариантны при замене x на - x, углы пересечения в обеих точках одинаковы, поэтому достаточно вычислить угол лишь, скажем, для 4-го решения. Заметим, что обе кривые являются графиками функций параметра x, поэтому они могут быть параметризованы x. Имеем (функция Norm[v], которую мы используем ниже, равна евклидовой длине вектора v)

γ1[x_]:= {x,((x^2)/4)}; γ2[x_]:={x,(8/((x^2)+4))};
v1:=γ1'[x]/.res[[4]];v2:=γ2'[x]/.res[[4]];
φ=ArcCos[((v1.v2)/(Norm[v1]Norm[v2]))]

Изобразим эти кривые

Plot[{((x^2)/4),(8/((x^2)+4))},{x,0,3}]

Clear[γ1,γ2,v1,v2,res,φ]

(2.22) Вокруг оси Oz вращается окружность x = a + b Cos[v], z = b Sin[v] (0 < b < a). Составить уравнение поверхности вращения.

Решение. Если точку с координатой {a + b Cos[v],0,b Sin[v]} повернуть на угол φ вокруг оси Oz, то у полученной токчи будут координаты

r[φ_,v_]:={(a+b Cos[v])Cos[φ],(a+b Cos[v])Sin[φ],b Sin[v]}

Нарисуем эту поверхность (являющуюся, очевидно, тором) при следующих значениях параметров : a = 4, b = 2 при изменении φ и ⋁ в пределах от 0 до 2π

ParametricPlot3D[r[φ,v]/.{a->4,b->2},{φ,0,2π},{v,0,2π}]

Изобразим зависимость тора от параметров (здесь {{aa, 4}, 1, 6} означает, что параметр aa может меняться в пределах между 1 и 6, причем начальное его значение равно 4; аналогично для параметра bb)

Manipulate[ParametricPlot3D[r[φ,v]/.{a->aa,b->bb},{φ,0,2π},{v,0,2π},Mesh->None,PlotPoints->30,PlotRange->{{-12,12},{-12,12},{-6,6}}],{{aa,4},1,6},{{bb,2},1,6}]

Clear[r]

(4.1) Вычислить кривизну следующих кривых : б) y = a ch (x/a).

Решение 1. В качестве параметра выберем x, тогда

γ[x_]:={x,a Cosh[(x/a)]};

Найдем натуральный параметр.

f[x_]=∫(Sqrt[γ'[x].γ'[x]])\[DifferentialD]x

f[x_]=Simplify[∫(Sqrt[γ'[x].γ'[x]])\[DifferentialD]x]

В качестве второго параметра кооманды Simplify можно указать предположения, которые помогут упростить выражение

f[x_]=Simplify[∫(Sqrt[γ'[x].γ'[x]])\[DifferentialD]x,Cosh[(x/a)]≥0]

Выразим x через натуральный параметр s

g[s_]=InverseFunction[f][s]

Заменим параметр на натуральный

γ1[s_]=γ[x]/.x->g[s]

k[s_]=(Sqrt[γ1''[s].γ1''[s]])//Simplify

Выразим x через натуральный параметр s (другой способ)

res=Solve[s==f[x],x]

γ1[s_]=γ[x]/.res[[1]]

k[s_]=(Sqrt[γ1''[s].γ1''[s]])

k[s_]=Simplify[(Sqrt[γ1''[s].γ1''[s]])]

k[s_]=Simplify[(Sqrt[γ1''[s].γ1''[s]]),{a>0,(a^2)+(s^2)>0}]

Решение 2. Вновь в качетве параметра выберем x и воспользуемся формулой кривизны произвольно параметризованной кривой. Имеем

γ[x_]:={x,a Cosh[(x/a)]};
k[x_]= ((Abs[Det[{γ'[x],γ''[x]}]])/((Norm[γ'[x]])^3))

k[x_]= Simplify[((Abs[Det[{γ'[x],γ''[x]}]])/((Norm[γ'[x]])^3)),{Sinh[(x/a)]≥ 0,Cosh[(x/a)]≥0,a≥0}]

проверим, что получился тот же результат

k[x]/.res[[1]]//Simplify

γ[x]

Manipulate[{
ParametricPlot[γ[x]/.a->aa,{x,-1,1},AspectRatio->Automatic,PlotRange->{{-1,1},{-0.1,3.5}}],
Plot[k[x]/.a->aa,{x,-1,1},AspectRatio->Automatic,PlotRange->{{-1,1},{-0.1,3.5}}]
},
{{aa,1},0.3,3}]

Clear[γ,a,γ1,f,g,res,k]

(4.22) Найти параметрические уравнения кривых, зная их натуральные уравнения (здесь R = 1/k) : a) R = a s

Решение 1.  Имеем

k[s_]:=(1/(a s));

α[s_]=∫k[s]\[DifferentialD]s

x[s_]=∫Cos[α[s]]\[DifferentialD]s
y[s_]=∫Sin[α[s]]\[DifferentialD]s

{x[s],y[s]}

Изобразим полученные кривые для параметра s в пределах от 0.1 до 20 и изучим их зависимость от параметра a, изменяющегося в пределах от 0.05 до 1 с начальным значением 0.5

Manipulate[ParametricPlot[{x[s],y[s]}/.a->aa,{s,0.1,20},PlotRange->{{-3,3},{-3,3}}],{{aa,0.5},0.05,1}]

Clear[k,α,x,y]

Решение 2.  Вместо явного интегрирования, решим систему дифференциальных уравнений

res=DSolve[{α'[s]==(1/(a s)),x'[s]==Cos[α[s]],y'[s]==Sin[α[s]]},{α[s],x[s],y[s]},s]

Задав начальные значения констант равными нулю, получим (сравните с предыдущим результатом)

{x[s],y[s]}/.res[[1]]/.{C[1]->0,C[2]->0,C[3]->0}//Simplify

Clear[k,α,x,y,res]

Важное замечание. Численная реализация Решения 2 работает даже тогда, когда Mathetatica не может посчитать интегралы. Проиллюстрируем это на примере.

k[s_]:=s (E^s);

Первый способ.

α[s_]=∫k[s]\[DifferentialD]s

x[s_]=∫Cos[α[s]]\[DifferentialD]s
y[s_]=∫Sin[α[s]]\[DifferentialD]s

ParametricPlot[{x[s],y[s]},{s,0.1,1}]

Clear[k,α,x,y]

Второй способ.

k[s_]:=s (E^s);
res=NDSolve[{α'[s]==k[s],x'[s]==Cos[α[s]],y'[s]==Sin[α[s]],α[0]==0,x[0]==0,y[0]==0},{α[s],x[s],y[s]},{s,0,1}]

γ[s_]={x[s],y[s]}/.res[[1]]//Simplify

ParametricPlot[γ[s],{s,0,1}]

Clear[k,γ,res]

Построить кривую в пространстве с кривизной k[t]=1+((Sin[t])^2) и кручением κ[t] = Cos[t]

k[t_]=1+((Sin[t])^2) ; κ[t_] = Cos[t];γ[t_]:={x[t],y[t],z[t]};
eq[ξ_,η_]:=Table[ξ[[i]]==η[[i]],{i,3}];
v[t_]={v1[t],v2[t],v3[t]};
n[t_]={n1[t],n2[t],n3[t]};b[t_]={b1[t],b2[t],b3[t]};

frenet=eq[γ'[t],v[t]]~Join~eq[v'[t],k[t]n[t]]~Join~eq[n'[t],-k[t]v[t]+κ[t]b[t]]~Join~eq[b'[t],-κ[t]n[t]]

res=NDSolve[frenet~Join~eq[γ[0],{0,0,0}]~Join~eq[v[0],{1,0,0}]~Join~eq[n[0],{0,1,0}]~Join~eq[b[0],{0,0,1}],γ[t]~Join~v[t]~Join~n[t]~Join~b[t],{t,0,100}]

Manipulate[ParametricPlot3D[γ[t]/.res[[1]],{t,0,aa},PlotRange->{{-1,1},{0,2},{-1,1}},PlotPoints->Round[(10/11)aa+(100/11)]],{aa,1,100}]

Clear[k,κ,γ,eq,v,n,b,frenet,res]