Update 2013-06-07: These are some notes I wrote over a month ago but never published. Since this work got me thinking about a how to align my instruction with SBG objectives and a later post I’m about to publish, it seemed like now or never.

In trying to get better at teaching graphical representations of uniformly accelerated motion, I tried something similar to Kelly O’Shea’s paradigm laboratory for the Constant Acceleration Particle Model (CAPM). Being not so brilliant at teaching myself, I think I injected a little too much of myself into it, but it was clear from a “pre-test” (review of Constant Velocity Particle Model graphs going into this unit) that students were confusing velocity and position, didn’t remember much about how to analyze velocity-vs-timer-reading graphs, so we needed to do some review. Part of this is the insanely long time between CVPM and CAPM, since we went ETM⟶CVPM⟶MTM⟶BFPM⟶CAPM⟶UBFPM. If I do this again, I will need to include more model-based reasoning problems that incorporate CVPM throughout the previous units. Thus, I found myself trying to come up with a list for us to make to summarize our large number of different scenarios in the CAPM paradigm (class) lab. For instance, in one of my periods, we had (among other things):

Velocity-vs-timer-reading graph for a cart on a ramp

I had the students annotate each segment of each graph with how the speed was changing (“v↑” or “speeding up”, “v↓” or “slowing down”), which direction it was going (“↑r” or “up the ramp”, “↓r” or “down the ramp”), and what was going on (“” for nothing, “pushed”, “stopped”, etc.). We made important notes besides the graphs that students drew in their lab notebooks, such as “☆The mass doesn’t seem to affect the graph very much.” Then we tried to summarize what we could tell with a table like:

Student-driven exploration of the velocity-vs-timer-reading representation
Feature of the $\vec{\boldsymbol v}\text{-}t$ graph Feature of the motion
point on the graph given by a pair $(t,\vec{\boldsymbol v})$ a data point, i.e. snapshot, of an object moving with a velocity $\vec{\boldsymbol v}$ at a timer reading $t$
horizontal position of a point on the graph timer reading $t$
vertical position of a point on the graph velocity $\vec{\boldsymbol v}$
vertical distance of a point from the timer reading ($t$) axis (the $\vec{\boldsymbol v}=\vec0$ line) how fast it is moving (speed $v$)
position of a point above(+)/on(0)/below(-) the timer reading ($t$) axis (the $\vec{\boldsymbol v}=\vec0$ line) which direction it is going
steepness of the $\vec{\boldsymbol v}\text{-}t$ graph’s slope in the neighborhood of a point how fast the velocity changes
sign of the $\vec{\boldsymbol v}\text{-}t$ graph’s slope in the neighborhood of a point which direction the velocity is changing (somewhat artificial)
the $\vec{\boldsymbol v}\text{-}t$ graph’s slope in the neighborhood of a point is moving [away from (+), parallel to (0), or toward (-)] the timer reading ($t$) axis (the $\vec{\boldsymbol v}=\vec0$ line) speeding up (+), maintaining a constant velocity (0), or slowing down (-)
point on the timer reading ($t$) axis (the $\vec{\boldsymbol v}=\vec0$ line) where the slope crosses the axis from negative to positive or vice versa. changing direction
? ?

Some classes were able to come up with their own entries. In others, I had to debase myself by suggestion them. In one class, it worked rather well to express my frustration that no one was saying anything, put a student in charge, and tell them that I would be silent while they figured it out. They put much wrong on the board, but they were jumping back to correct things they realized were wrong when trying to identify how to tell some of the other kinematic features; then the bell rang! I tried a similar approach in another class but didn’t give them enough awkward silence before going into silent mode myself. That class didn’t bother checking whether they hypothesized connections actually worked and weren’t given enough time to find out. I jumped into it with a few minutes to go and proceeded to ask them questions to test their statements, destroying all of them. I felt like rain on their parade. I had a hard time even convincing them that their statements were wrong because they could not tell me, given two points on the graph, which was moving faster. I intend to ask more questions like this next year during CVPM. I wanted to cry for them, and I was angry at all (including partly myself) who failed teaching them how to read a graph. Every year we say, “These are smart kids. They should be doing better on the science part of the ACT.” Now we know why. (Thus, I added the first three lines of the table above.)

I know this can’t be the best way to teach this. Engagement was low, and the whole paradigm lab had a demonstrative feel.

Position-vs-timer-reading graph for a cart on a ramp

# Stacked kinematic graphs with Asymptote

Update 2: Current versions of the code are now available at my GitHub repository.

Update: The code below is not as encapsulated as I would like, but it’s still pretty usable. The different versions reflect different amounts of refactoring, but I hope that they give you enough to work with. If you have a question about how to modify one of my examples to product your own favorite version of a stacked graph, please leave a comment, and I’ll try to create one within a reasonable time.

I’ve been using Asymptote to create graphs like the stacked kinematic graphs below.  I’ll post more complicated graphs in the future, but here’s a simple one with axes only.  I like Asymptote’s ability to use consistent units in the graphs so that the t-axis is synchronized.  Although it takes more work to create a version in Asymptote than in a graphics package, I can immediately differentiate it to different problems just by changing a line here and there.

Old version with x/v/at graphs: kinematic_stack.pdf kinematic_stack.png

New version (from refactored code) with s/v/at graphs: kinematic_stack_pos_vel_acc.pdf kinematic_stack_pos_vel_acc.png (N.B. IB Physics uses the convention that position is given by the variable s, so I try to use it with students, although we also use x).

// Asymptote code for kinematic_stack_pos_vel_acc.asy
import graph;

pen axis_p = linewidth(1.4)+black;
pen grid_p = linewidth(1.0)+gray(0.2);

real hticks = 5;
real vMin_ticks = -5;
real vMax_ticks = 5;

void kingraph(picture pic, Label vL=&quot;&quot;, real vMin=vMin_ticks, real vMax=vMax_ticks, Label hL=&quot;$t$&quot;, real hMin=0, real hMax=hticks) {
scale(pic, Linear, Linear);
xlimits(pic, hMin, hMax);
ylimits(pic, vMin, vMax);
xaxis(pic, hL, YZero, axis_p, Arrow(6));
yaxis(pic, vL, XZero, axis_p, Arrow(6));
}

picture pos_pic;
kingraph(pos_pic, &quot;$s$&quot;);

picture vel_pic;
kingraph(vel_pic, &quot;$v$&quot;);

picture acc_pic;
kingraph(acc_pic, &quot;$a$&quot;);

//xequals(pos_pic,3,Dotted);
//xequals(vel_pic,3,Dotted);
//xequals(acc_pic,3,Dotted);

// boring code for stacking the graphs.  The only interesting part is the htick/vtick settings, which can be used to change the size of the horizontal and vertical units of the graphs.
void stack(picture pics[]) {
real margin=2mm;
real htick = .8cm;
real vtick = .4cm;
frame[] frames = new frame[pics.length];
for(int i=0; i&lt;pics.length; ++i) {     unitsize(pics[i], htick, vtick);     frames[i] = pics[i].fit();     if (i&gt;0) {
frames[i] = shift(0,min(frames[i-1]).y-max(frames[i]).y-margin)*frames[i];
}
}
}

stack(new picture[] {pos_pic, vel_pic, acc_pic});


With numbered ticks: kinematic_stack_pos_vel_acc_nticks.pdf kinematic_stack_pos_vel_acc_nticks.png

// Asymptote code for kinematic_stack_pos_vel_acc_nticks.asy
import graph;

pen axis_p = linewidth(1.4)+black;
pen tick_p = linewidth(1.0)+gray(0.2)+fontsize(8);
pen ticklabel_p = tick_p;
int hticks = 5;
int vMin_ticks = -5;
int vMax_ticks = 5;
real[] hTicks_a = sequence(1, hticks);
real[] vTicks_a = sequence(vMin_ticks, vMax_ticks);
ticks hTicks = Ticks(format=Label(&quot;$%.4g$&quot;, align=E, p=ticklabel_p), Ticks=hTicks_a, Size=1mm, pTick=tick_p);
ticks vTicks = Ticks(format=Label(&quot;$%.4g$&quot;, align=W, p=ticklabel_p), Ticks=vTicks_a, Size=1mm, pTick=tick_p);
real axis_extra = 0.7; // extend the axis just a bit past the last tick mark

axis VZero(bool extend=true) {
return new void(picture pic, axisT axis) {
axis.type = 0; // Value
axis.value = pic.scale.x.T(pic.scale.x.scale.logarithmic ? 1 : 0); // I'm good with Linear 0
axis.position = 1; // relative position of axis label
axis.side = left;
axis.align = 5*E;
axis.extend = extend;
};
}
axis VZero = VZero();

axis HZero(bool extend=true) {
return new void(picture pic, axisT axis) {
axis.type = 0; // Value
axis.value = pic.scale.y.T(pic.scale.y.scale.logarithmic ? 1 : 0); // I'm good with Linear 0
axis.position = 0.5; // relative position of axis label
axis.side = right;
axis.align = W;
axis.extend = extend;
};
}
axis HZero = HZero();

void kingraph(picture pic, Label vL=&quot;&quot;, real vMin=vMin_ticks-axis_extra, real vMax=vMax_ticks+axis_extra, Label hL=&quot;$t$ [sec]&quot;, real hMin=0, real hMax=hticks+axis_extra) {
scale(pic, Linear, Linear);
xlimits(pic, hMin, hMax);
ylimits(pic, vMin, vMax);
xaxis(pic=pic, L=hL, axis=VZero(false), p=axis_p, ticks=hTicks, arrow=Arrow(6), above=false);
yaxis(pic=pic, L=vL, axis=HZero(false), p=axis_p, ticks=vTicks, arrow=Arrow(6), above=false);
}

picture pos_pic;
kingraph(pos_pic, &quot;$s$ [m]&quot;);

picture vel_pic;
kingraph(vel_pic, &quot;$v$ [m/sec]&quot;);

picture acc_pic;
kingraph(acc_pic, &quot;$a$ [m/sec/sec]&quot;);

//xequals(pos_pic,3,Dotted);
//xequals(vel_pic,3,Dotted);
//xequals(acc_pic,3,Dotted);

// boring code for stacking the graphs.  The only interesting part is the htick/vtick settings, which can be used to change the size of the horizontal and vertical units of the graphs.
void stack(picture pics[]) {
real margin=2mm;
real htick = .8cm;
real vtick = .4cm;
frame[] frames = new frame[pics.length];
for(int i=0; i&lt;pics.length; ++i) {
unitsize(pics[i], htick, vtick);
frames[i] = pics[i].fit();
if (i&gt;0) {
frames[i] = shift(0,min(frames[i-1]).y-max(frames[i]).y-margin)*frames[i];
}
}
}

stack(new picture[] {pos_pic, vel_pic, acc_pic});


With unnumbered ticks: kinematic_stack_pos_vel_acc_ticks.pdfkinematic_stack_pos_vel_acc_ticks.png

// Asymptote code for kinematic_stack_pos_vel_acc_ticks.asy
import graph;

pen axis_p = linewidth(1.4)+black;
pen tick_p = linewidth(1.0)+gray(0.2)+fontsize(.01);
pen ticklabel_p = tick_p;
int hticks = 10;
int vMin_ticks = -5;
int vMax_ticks = 5;
real[] hTicks_a = sequence(1, hticks);
real[] vTicks_a = sequence(vMin_ticks, vMax_ticks);
ticks hTicks = Ticks(format=Label(&quot; &quot;, align=E, p=ticklabel_p), Ticks=hTicks_a, Size=1mm, pTick=tick_p);
ticks vTicks = Ticks(format=Label(&quot; &quot;, align=W, p=ticklabel_p), Ticks=vTicks_a, Size=1mm, pTick=tick_p);
real axis_extra = 0.7; // extend the axis just a bit past the last tick mark

axis VZero(bool extend=true) {
return new void(picture pic, axisT axis) {
axis.type = 0; // Value
axis.value = pic.scale.x.T(pic.scale.x.scale.logarithmic ? 1 : 0); // I'm good with Linear 0
axis.position = 1; // relative position of axis label
axis.side = left;
axis.align = .01*S;
axis.extend = extend;
};
}
axis VZero = VZero();

axis HZero(bool extend=true) {
return new void(picture pic, axisT axis) {
axis.type = 0; // Value
axis.value = pic.scale.y.T(pic.scale.y.scale.logarithmic ? 1 : 0); // I'm good with Linear 0
axis.position = 1; // relative position of axis label
axis.side = right;
axis.align = .01*W;
axis.extend = extend;
};
}
axis HZero = HZero();

void kingraph(picture pic, Label vL=&quot;&quot;, real vMin=vMin_ticks-axis_extra, real vMax=vMax_ticks+axis_extra, Label hL=&quot;$t$&quot;, real hMin=0, real hMax=hticks+axis_extra) {
scale(pic, Linear, Linear);
xlimits(pic, hMin, hMax);
ylimits(pic, vMin, vMax);
xaxis(pic=pic, L=hL, axis=VZero(false), p=axis_p, ticks=hTicks, arrow=Arrow(6), above=false);
yaxis(pic=pic, L=vL, axis=HZero(false), p=axis_p, ticks=vTicks, arrow=Arrow(6), above=false);
}

picture pos_pic;
kingraph(pos_pic, &quot;$s$&quot;);

picture vel_pic;
kingraph(vel_pic, &quot;$v$&quot;);

picture acc_pic;
kingraph(acc_pic, &quot;$a$&quot;);

//xequals(pos_pic,3,Dotted);
//xequals(vel_pic,3,Dotted);
//xequals(acc_pic,3,Dotted);

// boring code for stacking the graphs.  The only interesting part is the htick/vtick settings, which can be used to change the size of the horizontal and vertical units of the graphs.
void stack(picture pics[]) {
real margin=2mm;
real htick = .4cm;
real vtick = .4cm;
frame[] frames = new frame[pics.length];
for(int i=0; i&lt;pics.length; ++i) {
unitsize(pics[i], htick, vtick);
frames[i] = pics[i].fit();
if (i&gt;0) {
frames[i] = shift(0,min(frames[i-1]).y-max(frames[i]).y-margin)*frames[i];
}
}
}

stack(new picture[] {pos_pic, vel_pic, acc_pic});


// Asymptote code for kinematic_stack_pos_vel_acc_grid.asy
import graph;

pen axis_p = linewidth(1.4)+black;
pen grid_p = linewidth(0.8)+gray(0.2);
pen ticklabel_p = fontsize(.01);
int hticks = 10;
int vMin_ticks = -5;
int vMax_ticks = 5;
real[] hTicks_a = sequence(1, hticks);
real[] vTicks_a = sequence(vMin_ticks, vMax_ticks);
real axis_extra = 0.7; // extend the axis just a bit past the last tick mark

axis VZero(bool extend=true) {
return new void(picture pic, axisT axis) {
axis.type = 0; // Value
axis.value = pic.scale.x.T(pic.scale.x.scale.logarithmic ? 1 : 0); // I'm good with Linear 0
axis.position = 1; // relative position of axis label
axis.side = left;
axis.align = 1.5*E;
axis.extend = extend;
};
}
axis VZero = VZero();

axis HZero(bool extend=true) {
return new void(picture pic, axisT axis) {
axis.type = 0; // Value
axis.value = pic.scale.y.T(pic.scale.y.scale.logarithmic ? 1 : 0); // I'm good with Linear 0
axis.position = 1; // relative position of axis label
axis.side = right;
axis.align = W;
axis.extend = extend;
};
}
axis HZero = HZero();

void kingraph(picture pic, Label vL=&quot;&quot;, real vMin=vMin_ticks, real vMax=vMax_ticks, Label hL=&quot;$t$&quot;, real hMin=0, real hMax=hticks) {
scale(pic, Linear, Linear);
xlimits(pic, hMin, hMax);
ylimits(pic, vMin, vMax);
ticks hTicks = LeftTicks(format=Label(&quot; &quot;, align=E, p=ticklabel_p), Ticks=hTicks_a, extend=true, pTick=grid_p); // The space clears the labels on the ticks.
ticks vTicks = RightTicks(format=Label(&quot; &quot;, align=W, p=ticklabel_p), Ticks=vTicks_a, extend=true, pTick=grid_p);
xaxis(pic=pic, L=&quot;&quot;, axis=BottomTop, p=grid_p, ticks=hTicks);
yaxis(pic=pic, L=&quot;&quot;, axis=LeftRight, p=grid_p, ticks=vTicks);
xaxis(pic=pic, L=hL, axis=VZero(false), p=axis_p, ticks=NoTicks, arrow=Arrow(6), above=true);
yaxis(pic=pic, L=vL, axis=HZero(false), p=axis_p, ticks=NoTicks, arrow=Arrow(6), above=true);
}

picture pos_pic;
kingraph(pos_pic, &quot;$s$&quot;);

picture vel_pic;
kingraph(vel_pic, &quot;$v$&quot;);

picture acc_pic;
kingraph(acc_pic, &quot;$a$&quot;);

//xequals(pos_pic,3,Dotted);
//xequals(vel_pic,3,Dotted);
//xequals(acc_pic,3,Dotted);

// boring code for stacking the graphs.  The only interesting part is the htick/vtick settings, which can be used to change the size of the horizontal and vertical units of the graphs.
void stack(picture pics[]) {
real margin=0mm;
real htick = .4cm;
real vtick = .4cm;
frame[] frames = new frame[pics.length];
for(int i=0; i&lt;pics.length; ++i) {
unitsize(pics[i], htick, vtick);
frames[i] = pics[i].fit();
if (i&gt;0) {
frames[i] = shift(0,min(frames[i-1]).y-max(frames[i]).y-margin)*frames[i];
}
}
}

stack(new picture[] {pos_pic, vel_pic, acc_pic});


Blank position and velocity graphs only: kinematic_stack_pos_vel.pdf kinematic_stack_pos_vel.png

// Asymptote code for kinematic_stack_pos_vel.asy
import graph;

pen axis_p = linewidth(1.4)+black;
pen grid_p = linewidth(1.0)+gray(0.2);

real hticks = 5;
real vMin_ticks = -5;
real vMax_ticks = 5;

void kingraph(picture pic, Label vL=&quot;&quot;, real vMin=vMin_ticks, real vMax=vMax_ticks, Label hL=&quot;$t$&quot;, real hMin=0, real hMax=hticks) {
scale(pic, Linear, Linear);
xlimits(pic, hMin, hMax);
ylimits(pic, vMin, vMax);
xaxis(pic, hL, YZero, axis_p, Arrow(6));
yaxis(pic, vL, XZero, axis_p, Arrow(6));
}

picture pos_pic;
kingraph(pos_pic, &quot;$s$&quot;);

picture vel_pic;
kingraph(vel_pic, &quot;$v$&quot;);

// boring code for stacking the graphs.  You can change the stack statement at the bottom to choose which graphs to include in what order.  The only interesting part of the stack function is the htick/vtick settings, which can be used to change the size of the horizontal and vertical units of the graphs.
void stack(picture pics[]) {
real margin=2mm;
real htick = .8cm;
real vtick = .4cm;
frame[] frames = new frame[pics.length];
for(int i=0; i&lt;pics.length; ++i) {
unitsize(pics[i], htick, vtick);
frames[i] = pics[i].fit();
if (i&gt;0) {
frames[i] = shift(0,min(frames[i-1]).y-max(frames[i]).y-margin)*frames[i];
}
}
}

stack(new picture[] {pos_pic, vel_pic});


# Sciencey graphs with Matplotlib from SciPy

This is my first post in a series of examples of graphing using available technical tools, and today I feature the Matplotlib bindings from SciPy.  It does a decent job of plotting, supports LaTeX in labels, and runs on Python.  You will need NumPy and SciPy, both downloadable from the SciPy website.  You can find the Matplotlib documentation to see how to make a scatter plot and many other types of graphs.
One can plot interactively using ipython (as in “ipython –pylab”) or from IDLE or a Python script by importing pylab (as in “from pylab import *”).  Here’s a schematic example:


from pylab import * # not needed if run from ipython --pylab
Independent_Variable = arange(0, 5, 0.1) # You should enter some data here, like [0.0, 0.1, 0.2, 3.1]
Dependent_Variable = sin(Independent_Variable) # You should enter some data here like [-3.2, 44.8, 91.2, 5.0]
Dependent_Variable_Error = 0.1*abs(randn(len(Dependent_Variable)))
Fit_Coeffs = polyfit(Independent_Variable, Dependent_Variable, 2) # 2 is for 2nd order polynomial
Dependent_Variable_Best_Fit = polyval(Fit_Coeffs, Independent_Variable)
figure()
errorbar(Independent_Variable, Dependent_Variable, yerr=Dependent_Variable_Error, fmt='o', label='experimental run 1') # fmt='o' makes dots
plot(Independent_Variable, Dependent_Variable_Best_Fit, label='best fit quadratic polynomial') # You can enter mathematics in the labels between dollar signs, like 'best fit $y=ax^{2}+bx+c$'
xlabel('Independent Variable axis label (IV units)')
ylabel('Dependent Variable axis label (DV units)')
legend() # This adds a legend using the "label=" part of the commands above.
title('Scatter plot with error bars') # Be descriptive!  What is the context?
show() # Needed when not running from ipython



This code generates a graph that can be exported to a PNG image file, which looks like this:

# Basic Classes of Mathematical Models

Following David Hestenes on page 6 of Modeling Instruction for STEM Education Reform, I wanted to create a poster like in my previous post of graphical methods and linearizing graphs but this time about the basic classes of mathematical models that Hestenes lists.  I’m not sure that I like all the equation gobbledegook, but I think students need something to which to aspire, so I just made it less prominent.  I’d also like a better presentation of some of the equations.

Update: You can now find source code for this and other posters in my GitHub repository.

\documentclass[final]{beamer} % beamer 3.10: do NOT use option hyperref={pdfpagelabels=false} !
%\documentclass[final,hyperref={pdfpagelabels=false}]{beamer} % beamer 3.07: get rid of beamer warnings
\mode<presentation> {  %% check http://www-i6.informatik.rwth-aachen.de/~dreuw/latexbeamerposter.php for examples
\definecolor{royalblue}{rgb}{0,0.13725490196078433,0.4}
\definecolor{royalblueweb}{rgb}{0.25490196078431371,0.41176470588235292,0.88235294117647056}
\definecolor{burntorange}{rgb}{0.8,0.3333333333333333,0}
\setbeamercolor{frametitle}{fg=blue!80!black}
\setbeamertemplate{frametitle} {
\begin{center}
\vspace{-1.2cm}\textbf{\insertframetitle} \par
\normalsize\textbf{\insertframesubtitle}
\end{center}
}
}
\usepackage[english]{babel}
\usepackage[latin1]{inputenc}
\usepackage{amsmath,amsthm, amssymb, latexsym}
%\usepackage{times}\usefonttheme{professionalfonts}  % times is obsolete
\usefonttheme[onlymath]{serif}
\boldmath
%\usepackage[orientation=portrait,size=a0,scale=1.4,debug]{beamerposter}                       % e.g. for DIN-A0 poster
%\usepackage[orientation=portrait,size=a1,scale=1.4,grid,debug]{beamerposter}                  % e.g. for DIN-A1 poster, with optional grid and debug output
\usepackage[size=custom,width=45.72,height=60.96,scale=1.8,debug]{beamerposter}                     % e.g. for custom size poster (18in x 24in w/ printable 17in x 23in)
%\usepackage[orientation=portrait,size=a0,scale=1.0,printer=rwth-glossy-uv.df]{beamerposter}   % e.g. for DIN-A0 poster with rwth-glossy-uv printer check
% ...
%
\geometry{margin=.5in}
\usepackage{array}
\usepackage{booktabs}
\newcolumntype{P}[1]{>{\raggedright\large}p{#1}}
\def\imagetop#1{\vtop{\vspace{-1.5cm}\null\hbox{#1}\vspace{-1.5cm}}}
\usepackage{tikz}

\newcommand{\xx}{\textcolor{variable}{x}}
\newcommand{\yy}{\textcolor{variable}{y}}
\newcommand{\versus}{vs\ }
\newcommand{\plotscale}{2.0}
\newcommand{\plotline}{6pt}
\newcommand{\formatmm}[1]{\textcolor{royalblue}{\textbf{#1}}}
\colorlet{plot}{burntorange}
\colorlet{variable}{blue!80!black}

% From Hestenes' list of 4 basic mathematical models
\title[Mathematical Models]{Basic Classes of Mathematical Models}
\author[Vancil]{Brian Vancil}
\institute[Sumner]{Sumner Academy of Arts & Sciences}
\date{2012-04-07}

\begin{document}
\begin{frame}{Basic Classes of Mathematical Models}
\framesubtitle{with sample equations}
\vspace{-2cm}
\begin{center}
\normalsize Mathematical model & \normalsize Kind of change & \normalsize Graph shape  \\ \midrule[.1em] \addlinespace

\formatmm{Linear model}
\par \normalsize $\yy=A\xx+B$
\par $\dfrac{d\yy}{d\xx}=A$ &
Rate of change is constant. &
\imagetop{\begin{tikzpicture}[scale=\plotscale,domain=0:4,line width=\plotline,smooth]
\draw[color=plot] plot (\x,.6*\x+1);
\draw[<->] (0,4) -- (0,0) -- (4,0);
\end{tikzpicture}}

\par \normalsize $\yy=A\xx^{2}+B\xx+C$
\par $\dfrac{d^{2}\yy}{d\xx^{2}}=A$ &
Rate of change of rate of change is constant. &
\imagetop{\begin{tikzpicture}[scale=\plotscale,domain=0:4,line width=\plotline,smooth,samples=40]
\draw[color=plot] plot (\x,{4-0.7*(\x-2)*(\x-2)});
\draw[<->] (0,4) -- (0,0) -- (4,0);
\end{tikzpicture}}

\formatmm{Exponential model}
\par \normalsize $\yy=Ab^{\xx}$ or $\yy=Ae^{\frac{\xx}{\xi}}$
\par $\dfrac{d\yy}{d\xx}=\ln b\cdot\yy$ or $\dfrac{d\yy}{d\xx}=\frac{\yy}{\xi}$ &
Rate of change is proportional to amount. &
\imagetop{\begin{tikzpicture}[scale=\plotscale,domain=0:4,line width=\plotline,smooth,samples=40]
\draw[color=plot] plot (\x,{pow(pow(4,.25),\x)});
\draw[<->] (0,4) -- (0,0) -- (4,0);
\end{tikzpicture}}

\formatmm{Harmonic model}
\par \normalsize $\yy=A\cos\left(k\xx+\phi\right)$ or $\yy=A\sin\left(k\xx+\phi'\right)$ or $\yy=\mathfrak{Re}\left\{Ae^{i(k\xx+\phi)}\right\}$
\par $\dfrac{d^{2}\yy}{d\xx^{2}}=-k^{2}\yy$ &
Rate of change of rate of change is proportional to amount. &
\imagetop{\begin{tikzpicture}[scale=\plotscale,domain=0:4,line width=\plotline,smooth,samples=40]
\draw[color=plot] plot (\x,{2*cos((\x*6.28-1)r)});
\draw[->] (0,-2) -- (0,2);
\draw[->] (0,0) -- (4,0);
\end{tikzpicture}}

\formatmm{Sudden change model}
\par \normalsize $\yy=A\ \theta(\xx-x_{0})+B$
\par $\dfrac{d\yy}{d\xx}=A\ \delta(\xx-x_{0})$ &
Change is finite and instantaneous. &
\imagetop{\begin{tikzpicture}[scale=\plotscale,domain=0:4,line width=\plotline,smooth,samples=40]
\draw[color=plot, domain=0:2] plot (\x,1);
\draw[color=plot, domain=2:4] plot (\x,3);
\draw[<->] (0,4) -- (0,0) -- (4,0);
\end{tikzpicture}}