Элементы управления и динамика

Разбить на страницы

Показывать лекцию целиком

Элементы управления (Controls)

В Mathematica имеются многочисленные элементы управления: ползунки ( Slider ), несколько видов кнопок (окошко Checkbox, где можно поставить галочку, кнопки RadioButton, позволяющие выбрать одно из нескольких значений) и т. д. Эта особенность делает возможным организовывать пользователю удобный интерфейс. Приведем некоторые примеры.

Ползунок

In[1]:= Slider []

Ползунок можно вставлять в формулы:

In[2]:=l + Slider []

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

То же самое можно сделать, пометив ползунок и нажав комбинацию клавиш Ctrl+Shift+Enter. В результате Mathematica вычислит и заменит на результат ровно то выражение на входе, которое было помечено. Проверьте это на примере приведенного ниже выражения.

In[4] := 1 + Slider []

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

Out[6] = 1.667

Ползунок может иметь разные параметры, например:

Slider[x] устанавливает ползунок в положение x (предполагается, что x лежит между 0 и 1);

Slider[x, {xmin, xmax}] устанавливает ползунок в положение x (мы предполагаем, что x лежит между xmin и xmax);

Slider[x, {xmin, xmax, dx}] устанавливает ползунок в положение x (предполагается, что x лежит между xmin и xmax ), причем ползунок двигается дискретно с шагом dx:

In[7]:= Slider [0.5, {0, 2, 0.5}]

Аналогично работает двумерный ползунок Slider2D[]:

In[8]:=DynamicSetting[Slider2D[] ]

Несколько других примеров:

In[9] : = Manipulator []
          Checkbox[]
          RadioButton[]
          ColorSlider[] 
          Graphics[Locator[{0,  0}],  PlotRange -> 1]

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

Оператор Dynamic[]

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

In[14]:=х = 3; 
        х²
Out[15] = 9
In[16]:=x = 5
        х²
Out[16] = 5
Out[17] = 25

Заметим, что первый вывод Out[15] по-прежнему дает значение 9, хотя x уже поменялся.

Если хочется, чтобы вывод результата вычисления выражения менялся при изменении входящих в него переменных, можно использовать Dynamic:

In[18] := Dynamic [x²]
Out[18]=x²

Выполним следующие команды и обратим внимание на то, как будет меняться вывод предыдущей, т.е. Out[18] команды:

In[19]: = x = 7;
Out[18] = 49
In[20]:=x = ∫y d y;
Out[18]=y⁴/4
In[21]:=x = Plot[x², {x,  -1, 1}];

Динамика и элементы управления. Сам по себе ползунок не влияет на значение аргумента x:

In[22]: = х = 0.5;
In[23] := Slider [x]

In[24]: = x
Out[24] = 0.5

Если ползунок использовать вместе с Dynamic, то переменная x будет динамически обновлять свое значение при перемещении ползунка:

In[25]:={Slider [Dynamic [x] ] , Dynamic [x]}

In[26]: = x 
Out[26] = 0.5

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

In[27] :={Slider2D [Dynamic [x] ] , Dynamic [x]}

In[28] := {Slider [Dynamic [k] ] ,
            Dynamic [Plot [Sin [k x] , {x, 0, 20π } ,
              PlotRange -> {{0, 20 π} ,{-1, 1}}]]}

Теперь сдвинем слайдер:

In[29] :={Slider2D [Dynamic [r] ] ,
           Dynamic[Plot3D[Cos[Norm[{x, y} - r] ] , {x, 0, 1}, 
            {y, 0, 1}, Mesh -> None] ]}

Приведем примеры использования динамики вместе с другими элементами управления:

In[30] : = Clear [x]
             {Manipulator[Dynamic[xl]], Dynamic[xl]} 
             {Checkbox[Dynamic[x2]], Dynamic[x2]} 
            Map[RadioButton[Dynamic[x3], #]  , {1, 2, 3}] 
              {ColorSlider[Dynamic[col] ] , 
                Dynamic[Graphics[{col, Disk []}]]} 
               p = {0.5, 0.5} ;
               Graphics[Locator[Dynamic[p]], PlotRange -> 1] 
               Dynamic[p]

Out[37] = ImageScaled[ {0.4 8308 9, 0.58 4573} ] 
In[38] : = Clear [k, x, xl, x2 , p]

Локализация переменных. В приводимых ниже двух примерах ползунков оба они изменяются одинаково при изменении одного из них (так как x - глобальная переменная).

In[39]:={Slider [Dynamic [x] ] , Dynamic [x]} 
         {Slider[Dynamic[x]], Dynamic[x]}

Чтобы избавиться от такой зависимости, можно локализовать переменную x (по аналогии с тем, как это делалось в Module[] ).

In[41]:= 
      DynamicModule[{х}, {Slider[Dynamic[x]], Dynamic[x]}] 
      DynamicModule[{x}, {Slider[Dynamic[x]], Dynamic[x]}]

Локализация с помощью DynamicModule имеет свои преимущества, в частности, при сохранении проекта и выхода из него текущие значения локализованных переменных сохраняются (этого не происходит со значениями глобальных переменных и локальных переменных из Module ).

Второй аргумент в Dynamic[]. Когда Dynamic[] используется вместе с ползунком в виде Slider[Dynamic[expr]] , при движении ползунка все время выполняется присвоение expr = new, где new - значение, вычисленное по положению ползунка. Если присвоение успешно, ползунок смещается, иначе - остается на месте.

В приведенном ниже примере можно двигать лишь левый ползунок. Попытка движения правого приводит к ошибке, так как невозможно присвоить новое значение выражению 1-x.

In[43] : = DynamicModule [{х = 0} ,
             {Slider[Dynamic[x]] ,  Slider[Dynamic[1 - х] ]} ]

А именно, если попробовать пошевелить второй слайдер, то возникнет сообщение об ошибке, типа

During evaluation of In [133]:=
                    Set::write : Tag Plus in -0.202 +1 is Protected. >>

Однако если использовать второй аргумент команды Dynamic, то с помощью него можно задать динамику первого аргумента:

In[44]:=
      DynamicModule[{х = 0}, 
         {Slider [Dynamic [x] ] ,  Slider [Dynamic [1 - х,   (х = 1 -#)  ] ] } ]

Этим способом можно реализовать обратную функцию:

In[45]:=
     DynamicModule\{х = 0}, 
         {Slider[Dynamic[x]], 
              Slider [Dynamic [1 - 2 х, (х =  (1 -#) / 2)  ] , {-1,  1}] }]

Таким образом, формат команды следующий: Dynamic[expr, f] , где f[expr, val] вычисляется при каждом изменении значения val, которое, в свою очередь, задается положением ползунка.

В приводимом примере используем тот факт, что DateList[], выдающая временные данные в формате год, месяц, день, час, минута, секунда, так же как и функция RandomReal[], самостоятельно не обновляется. Однако при обновлении второго аргумента динамики первый также пересчитывается:

In[46] := Slider [Dynamic [x] ]
            Dynamic[DateList[], Dynamic[x]]

Out[47]= {2010, 2, 3, 18, 53, 43.5625000}

Можно заставить самостоятельно обновляться Dynamic[], задав опцию UpdateInterval:

$$UpdateInterval \to. t$$ (обновляться не реже чем каждые $$t$$ секунд),

$$UpdateInterval \to 0$$ (обновляться как можно чаще),

$$UpdateInterval \to Infinity$$ (не обновляться).

In[48]: = Dynamic[DateList [] , UpdateInterval -> 1]
Out[48]= {2010, 2, 3, 18, 53, 43.6093750}

Где нужно располагать Dynamic[]? Оператор Dynamic[] ведет себя достаточно хитро, и далеко не каждое его расположение приводит к ожидаемому результату. Опишем несколько установленных экспериментально важных принципов, которые позволяют избежать многочисленных ошибок.

Mathematica состоит из оболочки ( Front End ), в которой мы сейчас работаем, и ядра ( Kernel ), выполняющего вычисления выражений (перед тем как выполнится первая команда, скажем, 2+2, набранная в оболочке и активированная командой оболочки Shift+Enter, Mathematica загружает в память свое ядро и команда обрабатывается именно ядром; в дальнейшем ядро остается в памяти и производит вычисление выражений, активизированных той же командой Shift+Enter ). Используя команду меню Evaluation/Quit Kernel/Local, можно выгрузить ядро, завершив тем самым сеанс. Если затем выполнить команду Shift+Enter, позиционировав предварительно курсор в какой-нибудь клетке, ядро вновь загрузится и команды из клетки будут обработаны ядром.

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

In[49]:=х = 10;
        N[Sin[Dynamic[x]]]
Out[50] = Sin [0.5]

(хотя значение x подставляется в Sin[], тем не менее команда N[] не может вычислить значение Sin[10] ).

Функция Plot замечает ошибку сама:

In[51]:=х = .
       Plot[Dynamic[x²] , {х,  -1, 1}]

Функция Dynamic[expr] имеет атрибут HoldFirst (см. подробности в лекции 4), поэтому аргумент expr не меняется при вычислении:

In[53] : = Attributes [Dynamic]
             Dynamic[1 + 1]  // InputForm
Out[53]= {HoldFirst,  Protected,  ReadProtected}
Out[54] = Dynamic [1 + 1]

Это можно преодолеть с помощью команды Evaluate:.

In[55] : = Dynamic [Evaluate [1 + 1] ]  // InputForrn
Out[55] = Dynamic [2]

Важное следствие: ошибки при создании списка динамических данных (в примере временная переменная i внутри data[[i]] не меняет своего значения, потому что Dynamic имеет атрибут HoldFirst ).

In[56]:=data = {.1, .5, .3, .9, .2}; 
           Dynamic[data] \\
            Table[Slider[Dynamic [datap]] ]], {i, 5}]
Out[57] = { 0 . 1, 0.5, 0.3, 0.9, 0.2}

Чтобы конструкция заработала, можно использовать правило замены так, чтобы итератор оказался снаружи Dynamic:

In[59]:=data ={.1, .5, .3, .9, .2}; 
           Dynamic[data] 
            Table [Slider [Dynamic [data [[i]]] ] /. i -> ii, {ii, 5}]
Out[60] ={ 0 . 1, 0.5, 0.3, 0.9, 0.2}

Еще один вариант - использовать команду With[{x=x0,y=y0,...},expr] , состоящую в том, что при каждом появлении символов x, y, ... они заменяются на x0, y0, ...:

In[62]: = With[{y = р - 1}, 1+у-у^2]
Out[62] = -(-l+p)²+p
In[63]: = data = { .1, .5, .3, .9, .2}; 
            Dynamic[data]
            Table [With [{i = i}, Slider [Dynamic [data [[i]] ] ] ] , 
              {i, 5}]
Out[64] = {0 .1, 0.5, 0.3, 0.9, 0.2}

Dynamic не выводится при стандартном выводе, хотя на самом деле присутствует, что можно увидеть, заменив формат вывода на InputForm. Кроме того, при выводе в стандартном режиме аргумент expr выражения Dynamic[expr] визуализируется в вычисленном виде, несмотря на то, что реально Dynamic[expr] представлено невычисленным выражением expr:

In[66]:=Dynamic [1+1]
         Dynamic[1+1]//InputForm
Out[66]=2
Out[67]=Dynamic [1+1]
In[68]:=x =.
In[69]:=2+Slider[x]
Out[69]= 2 + Slider[x]
In[70]:=Slider[x]
Out[70]=Slider[x]

При использовании Dynamic[] с элементами управления нужно придерживаться следующего правила: первый аргумент элемента управления почти всегда обрамлен командой Dynamic, например, Slider[Dynamic[x]] , Checkbox[Dynamic[x]] , RadioButton[Dynamic[x]] . ..:

In[71]:={Dynamic [Slider [x] ],Dynamic[x]}

Расположение Dynamic в правильном месте - высокое искусство. Часто это - самый внешний оператор, хотя, как мы уже видели на примере элементов управления, это не всегда так. Кроме того, иногда имеется свобода в расположении Dynamic, а также операторы Dynamic могут быть вложенными в друг друга:

In[72]: = Dynamic [Table [x, {i, 10}]] 
          Table[Dynamic[x], {i, 10}]
Out[72]={0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5}
Out[73] = {0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5}

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

Dynamic может быть расположен в правой части опций, однако далеко не во всех случаях. Например, Dynamic не может регулировать количество PlotPoints, потому что функция Plot должна знать значение PlotPoints до того, как будет порождено то, что потом изобразится на экране (напомним, что Dynamic выполняется оболочкой, а не ядром). Приведем примеры возможного использования Dynamic в опциях:

In[74]:= {Slider [Dynamic [h] , {6,  100}],
              Dynamic[Style["Это   -   текст", FontSize -> h]]}
            {Slider[Dynamic[h], {6,  100}], 
              Style["Это   -   текст", FontSize -> Dynamic [h] ] }

(Команда Style работает с оболочкой, настраивая вид вывода, поэтому Style может работать с Dynamic.)

Dynamic может быть также использована с командой SetOptions:

In[76] := SetOptions [Graphics , Background -> Dynamic [Hue [x] ] ]
                {Slider[Dynamic[x]], Graphics[Circle[]]}
Out[76] =
       {AlignmentPoint -> Center, AspectRatio -> Automatic, 
        Axes ->  Feilse, AxesLabel -> None, AxesOrigin -> Automatic, 
        AxesStyle -> { } , Background -> Hue [0.5], 
        BaselinePosition -> Automatic, BaseStyle -> {}, 
        ColorOutput -> Automatic, ContentSelectable -> Automatic, 
        CoordinatesToolOptions -> Automatic, 
        DisplayFunction : -> $DisplayFunction, 
        Epilog -> {}, FormatType : -> TraditionalForm, 
        Frame -> False, FrameLabel -> None, FrameStyle -> {},
        FrameTicks -" Automatic, FrameTicksStyle -> {}, 
        GridLines -> None, GridLinesStyle -> {},
        ImageMargins -> 0 ., ImagePadding -> All,
        ImageSize -> Automatic, ImageSizeRaw -> Automatic, 
        LabelStyle -> {}, Method -> Automatic, PlotLabel -> None, 
        PlotRange -> All, PlotRangeClipping -> False, 
        PlotRangePadding -> Automatic, PlotRegion -> Automatic, 
        PreservelmageOptions ->  Automatic, Prologs -> {}, 
        RotateLabel -> True, Ticks -> Automatic, TicksStyle -> {}}

In[78] : = Clear [h, x]

Функция Manipulate[]

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

Manipulate[expr,{u,umin,umax}] - параметр u меняется на отрезке от umin до umax (управляется ползунком Slider );

Manipulate[expr,{u,{xmin,ymin},{xmax,ymax}}] - параметр u меняется в прямоугольнике, с нижним левым углом в {xmin,ymin} и верхним правым углом в {xmax,ymax} (двумерный ползунок Slider2D );

Manipulate[expr,{u,umin,umax,du}] - параметр u меняется ползунком с шагом du ;

Manipulate[expr,{{u,uinit},umin,umax}] - параметру u присваивается начальное значение uinit ;

Manipulate[expr,{{u,uinit},umin,umax,du}] - параметру u присваивается начальное значение uinit и он меняется с шагом du ;

Manipulate[expr,{u,{u1,u2,...}}] параметр u пробегает дискретный набор значений {u1, u2,...} ; при этом если список значений короткий, то u управляется строкой кнопок ( Setter Bar ), а если список длинный - то выпадающим меню ( Popup Menu );

Manipulate[expr,{u,color}] - параметр u задается с помощью цветового ползунка;

Manipulate[expr,{u,{True,False}}] - параметр u задается с помощью флаговой кнопки CheckBox ;

Manipulate[expr,{u,Locator}] - параметр u задается с помощью локатора Locator ;

Manipulate[expr,{{u,uinit},Locator}] - начальное положение локатора равно uinit.

Можно также задавать не один параметр, а несколько:

In[79]: =
        Manipulate[
           Plot [λ f [a (x - loc[[1]]) + b] ⁿ g [x - loc[[l]] ] + loc[[2]] ,
                   {x,  0, [[1]]},  PlotRange -> {{0, pt [[1]]},   {-pt[[1]], pt[[2]]}},
              PlotStyle -> {color} , Axes -> axes] ,
           {λ , 1, 2},
           {pt,  {2 π,  1},   {4 π 2}}, 
           {n, 1, 5,  1}, 
           {{a,  1}, 0, 2}, 
           {{b, 1}, 0, 2, 0.2}, 
           {f,   {Sin, Cos, Tan, Cot}}, 
           {g,   {Sin, Cos, Tan, Cot, Sqrt, Log}}, 
           {color, Red} , 
           {axes,  {True, False}}, 
           {{loc,   {0, 0}}, Locator} 
    ]

Управление скоростью движения ползунка. Если при смещении ползунка удерживать клавишу Alt, изменение параметра замедлится в 20 раз.

Если к Alt добавить Ctrl или Shift, движение замедлится еще в 20 раз (проделайте это на примере, приведенном выше).

Редактируемая визуализация текущего значения параметра, задаваемого ползунком, изменение этого значения, автоматизация процесса изменения, последовательное изменение всех параметров ( Autorun ). Если кликнуть на значок "+" справа от ползунка, то под ползунком возникнет окошко с текущим значением параметра, а также шесть кнопок справа от этого окошка. Окошко можно редактировать, изменяя тем самым значение параметра. Шесть кнопок позволяют задавать автоматическое изменение параметра (поэкспериментируйте с этими кнопками и разберитесь, за что они отвечают). Чтобы посмотреть зависимость от всех параметров, можно кликнуть на значок "+" в правом верхнем углу панели Manipulate и в появившемся меню выбрать Autorun. Появится управляющее окошко Autorun и параметры начнут последовательно менять свои значения. В управляющем окошке можно менять параметры демонстрации Autorun. Чтобы остановить процесс, нажмите в этом окошке на Close.

Нередактируемая визуализация значения параметра, задаваемого ползунком. Чтобы вывести справа от ползунка текущее нередактируемое значение параметра, добавьте в список описания параметра опцию $$Appearance \to "Labeled"$$:

In[80]: = Manipulate[Plot[Sin[a x + b] , {x,  0, 2 π } , 
                 PlotRange -> {{0, 2 π } , {-1, 1}}], 
              {{a, 1}, 0, 2},
              {b, 0, 2, Appearance -> "Labeled"\}
      ]

Замена имен параметров на метки. Для этого после обязательного задания начального значения нужно указать название параметра:

In[81]: = Manipulate[Plot[Sin[ax + b] , {x, 0, 2 π },
               PlotRange -> {{ 0 , 2 π } , {-1,1}}],
             {{a, 1, "Частота"}, 0, 2}, 
             {{b, 0,  "Фаза"}, 0, 2, Appearance -> "Labeled"}
           ]

Визуализация дискретных значений параметра метками. Для этого после задания дискретного значения нужно поставить стрелочку $$\to $$ и указать метку (типа String ):

In[82]: = Manipulate[Plot[f [ах + b] g[х] ,  {х, 0, 2 π },
                   PlotRange -> {{0,  2 π } ,   {-1,  1}}] , 
                {{а, 1}, 0, 2}, 
                {{b, 1}, 0, 2,  0.2}, 
                {{f, Sin},   {Sin -> "Синус", Cos,  Tan -> "Тангенс",
                    Cot -> "Котангенс"}} , 
                {{g,  Sin},   {Sin -> "Синус", Cos -> "Косинус",  Tan, 
                    Cot -> "Котангенс" , Sqrt -> "Квадратный корень", 
                    Log -> "Логарифм"}}
]

Задание вручную (переопределение заданных по умолчанию) элементов управления. Для этого в описании параметра нужно указать опцию ControlType ->¦ ТипУправления, где Тип Управления принимает одно из следующих значений: Animator, Checkbox, CheckboxBar, ColorSetter, ColorSlider, InputField, Manipulator, None, PopupMenu, RadioButton, RadioButtonBar, Setter, SetterBar, Slider, Slider2D, TogglerBar, Trigger, VerticalSlider:

In[83]: =
    Manipulate [Plot [f [a x + b] g[x] , {x, 0,2 π },
          PlotRange -> {{0, 2 π } , {-1, 1}}] ,
     {{a, 1}, 0, 2}, 
     {{b, 1}, 0, 2, 0.2},
     {{f, Sin}, {Sin, Cos, Tan, Cot}, ControlType -> Slider} , 
     {{g, Sin}, {Sin, Cos, Tan, Cot, Sqrt, Log},
        ControlType -> RadioButton}
    ]

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

In[84]:=
      Manipulate [Plot [f [ах + b] ,   {х,  0, 2 π }, 
            PlotRange -> {{0, 2 π } ,   {-1,  1}}] , 
         {{а,  1}, 0, 2}, 
         {{b, 1}, 0, 2, 0.2}, 
         {{f,  Sin},   {Sin, Cos,  Tan, Cot},  ControlType -> SIider2D}
]

Ничего хорошего не получилось, и возникло сообщение об ошибке:

Manipulate: :vstype : 
     ControlType ->Slider2D is not supported for the variable specification {f$$, {Sin, Cos, Tan, Cot}},
        ControlType ->PopupMenu will be used instead. >>

а панель Manipulate окрасилась в розовый цвет:

Использование функций в качестве элементов контроля.

In[85]:=Manipulate [Plot [f [ax + b] ,   {x, 0, 2 π } ,
             PlotRange -> {{0, 2 π } ,   {-1,  1}}] , 
          {{a, 1}, 0, 2}, 
          {{b,  1}, 0, 2,  0.2}, 
          {{f, Sin},   (Which[
                  pt[[1]] < 0.5  pt[[2]] < 0.5,  f = Sin, 
                  pt[[1]] < 0.5 pt[[2]] >=   0.5,  f = Cos, 
                  pt[[1]] >= 0.5 pt[[2]] <   0.5,  f = Tan, 
                  pt[[1]] >=  0.5 pt[[2]] >= 0.5,  f = Cot 
                 ] ; Slider2D[Dynamic[pt]])   }
       ]

Интерактивное создание локаторов. Для этого в описании локатора нужно задать опцию $$LocatorAutoCreate \to. True$$. Теперь при удерживании клавиши Alt и клике на свободную часть поля мы будем создавать новые локаторы. При удерживании Alt и клике на существующий локатор мы удалим этот локатор:

In[86]:=
        Manipulate[ 
             Graphics[{EdgeForm[{Blue, Thick}], FaceForm[Yellow],
                    Polygon [pt]} , PlotRange -> 2] , 
                {{pt, {{0, 0}, {1, 0}, {1, 1}, {0, 1}}}, Locator, 
                    LocatorAutoCreate -> True} ]

Пример программы рисования многоугольника на плоскости Лобачевского ( Alt+Click на свободное поле добавляет вершины). Смещая локаторы, можно наблюдать за соответствующим изменением многоугольника:

$$In[87]: = g[z_{-}, \varphi_{-} , z0_{-} ] :=e^{I \varphi} \frac{z-z0}{1-z Conjugate[z0]};\\ \begin{matrix} givn[z_{-}, \varphi_{-}, z0_{-}]:=e^{-I \varphi}\frac{z_e^{I \varphi}z0}{1_ze^{-i \varphi}Conjugate[z0]}; \end{matrix} $$

line[zl_, z2_, t_] : = ginv[tg [z2, 0, z1] , 0, zl] ;
              Manipulate[res = p; Show[{
                 Graphics[Circle[]], 
                 Table[ParametricPlot[ 
                   With[ 
                     {z = line [Complex [Sequence @@p[[i]] ] , 
                        Complex[Sequence @@
                           p[[If [i == Length [p] , 1, i + 1] ]] ] , t] }, 
                     {Re[z] , lm[z]}], {t, 0, 1}], 
                   {i, If [Length [p] ==2,  1, Length [p] ]} ] 
                }], {{p, {{-1/2, 0}, {1/2, ?}}}, Locator, 
                LocatorAutoCreate -> True} 
       ]

Упражнения

Для кривой $$\gamma$$ визуализировать ее каустику (множество центров кривизны) и динамику волновых фронтов (эквидистант). Убедиться, что особенности волновых фронтов заметают каустику.

>
In[91]: =
       SetAttributes[wave, HoldFirst];
       wave [ {x_ [ t_, px_] , y_ [t_, py_]}, {px0_, pxmin_,  рхmах_},
              {py0_, pymin_, pymax_}, {tmin_, tmax_}, {min_,  max_},
               OptionsPattern[ParametricPlot]] : =
            DynamicModule q{γ, s, v, a, n, q, k, caustic},
      Manipulate[
            γ[s_]:={x[s,px], y[s,py]};

$$\begim{matrix} n[s_{-}]=\frac{\{-\gamma '[s][[2]], \gamma '[s][[1]]\}}{Norm[\gamma '[s]]};\\ k[s_{-}]=\frac{Det[\{\gamma '[s], \gamma ' '[s]\}]}{Norm[\gamma '[s]]^3}; \end{matrix} $$

caustic[s_]:=γ [s]+1/(k[s]) n[s];
             Show [ {
                ParametricPlot[γ [s], {s, tmin,  tmax}], 
                ParametricPlot[caustic[s], {s, tmin, tmax},
                     Plotstyle -> Directive [Yellow] ] , 
               ParametricPlot[γ [s] +n[s] q,  {s, tmin, tznax} , 
                    Plotstyle -> OptionValue[PlotStyle]]
             } , PlotRange -> OptionValue[PlotRange], 
            AspectRatio -> OptionValue[AspectRatio] ] ,
         ] {{q, 0} , min, max} ,{{px, px0} , pxmin, pxmax} ,
         {{py, py0},  pymin, рутах} , Paneled -> False
      ]
   ]
In[93]: =
         wave [{#2 Cos [#1] [t, px] , #2 Sin[#2] [t, py] } ,
              {2, 1, 5}, {3, 1, 5}, {0, 2 π}, {-1, 5},
              {AspectRatio -> Automatic, PlotRange -> {{-3, 3}, {-4, 4}}, 
                   PlotStyle -> Directive[Red]} ]

In[95]: = wave[{#l + #2 Cos [#2 + π/2] [t, px] ,
                    l + #2Sin[#l + π/2] [t, py]}, {0.5, 0, 2}, {0.5, 0, 2},
                 {-4 π , 4 π }, {-3 π, З π }, 
                 {AspectRatio -> Automatic,
                    PlotRange -> {{-4 π , 4 π } , {-8, 8}}} , 
                   PlotStyle -> Directive[Red] ]

In[94]: = wave[{#l [t, px] , Sin[#2] [t, py] } , {2, 1, 5} , 
                {3, 1, 5}, {-4 π, 4 π }, {-20, 20}, 
                {AspectRatio -> Automatic,
                 PlotRange -> {{-4π,  4π} , {-15, 15}}} , 
                PlotStyle -> Directive [Red] ]

Смоделировать часы со стрелками.

In[96]: = Dynamic[DateList [] , UpdateInterval -> 1]
Out[96]= {2010, 2, 3, 18, 53, 57.5312500\}

In[97]: =
   DynamicModule [ {α, β, γ, δ = 0.05, δ1, ϕ} ,\\ Dynamic[ \\
    Graphics[
     {
       Circle[],
       Sequence @@ Table [if [Mod [i, 5] ==0, δ1 = δ,δ1 = δ/2];
           ϕ = (2π)/(60) i; Line [{Cos [ϕ] , Sin[ϕ]}#  /@ {1 -δ1, 1 + δ1}] ,
          {i, 0, 59}], 
       Sequence @@ Table [ϕ =(2π)/4 - (2π)/(12)i ;
          Text[ToString[i] , (1 + 2δ){Cos [ϕ] , Sin [ϕ]} ,
            Automatic], {i, 1, 12}],

$$\begin{matrix} Yellow, \alpha = \frac{2 \pi}{4}-2 \pi \frac{Round[DateList[][[6]]]}{60}; \end{matrix} $$

Arrow[{{0,0},{Cos[α], Sin[α]}}],

$$\begin{matrix} Red, \beta=\frac{2 \pi}{4}-2 \pi \frac{DateList[][[5]]+DateList[][[6]]/60}{60};\\ \end{matrix} $$

Thickness[0.008],
          Arrow[{{0, 0}, (1-2δ){Cos[β], Sin[β]}}],
          Black,
          γ=
            2π/4-
               2π(1)/(12) - (Mod[DateList[] [[4]] , 12] + DateList [] [[5]] / 60) ;
            Thickness[0.01] ,
            Arrow[{{0, 0}, (1-6δ) {Cos[γ], Sin[γ]}}]
        }
        PlotRange -> {{-1.2,  1.2}, {-1.2, 1.2}}, 
       AspectRatio -> Automatic] ,
     Update Interval -> 1
  ]
]

Часы, смоделированные таким образом, на компьютере идут:

Страницы: