# SBG and Multiple Representations in Kinematics

Multiple representations in kinematics

This year when how I graded standards starting morphing from what they actually said, I realized that it was time to pick new standards. As I started to imagine how I would change them, I realized that I have no systematic way to do so. In teaching the subject of kinematics (in particular, uniform acceleration, i.e. CAPM), solving a problem involves motion concepts, multiple representations of motion (words, tables, Motion Maps, position-versus-timer-reading graphs, velocity-versus-timer-reading graphs, acceleration-versus-timer-reading graphs, equations, and even some weird ones like position-versus-velocity graphs, etc.), translations between representations, and features of representations that correspond to motion concepts. I can think of at least four broad ways to do this:

1. Standards correspond to relevant concepts. (N)
2. Standards correspond to the multiple representations. (n)
3. Standards correspond to translations between representations. (n(n-1))
4. Standards correspond to conceptual features of representations. (Nn)

The formulas in parentheses give a rough estimate of the number of possible standards for N motion concepts and n different representations. However, these are not the only considerations. I have more-or-less made the decision that the level of difficulty should increase with standards added and not by increasing the burden of proof or morphing the standards, but this year I occasionally evolved from a mainly qualitative understanding sufficing to requiring a quantitative understanding at the end of a unit. I’d much rather have this built into standards, which should be clear on whether they require a qualitative or quantitative understanding. Which types of standards should bifurcate into qualitative and quantitative flavors? Which overall method of choosing standards is most conducive to student morale and success? Is there any research about which kind of SBG standards are most conducive to learning?

So far I’ve found some prior work on SBG and PER/multiple representations:

1. The Physics Problem and Standards-Based Grading—Although it’s not what I’m looking for, it does consider the question, “How does one assess solving problems?”
2. Multiple Representations for NYS Grade 3-8 Common Core Mathematics Tests—Here’s how NY uses MR (multiple representations). The MRs appear as subtypes of standards, if I’m interpreting this correctly.
3. Kentucky fifth-grade math standards—A few of these involve something close to my “Method 1”.
4. NCTM’s Principles and Standards for School Mathematics: Representations—Though not about SBG, it illustrates NCTM’s thinking about what it means to represent something.
5. Multiple Representations of Limits—Now the NSA is spying on teachers?! 😉 Not about SBG, but some included Maryland standards are loosely based on MR.
6. Information About Standards-Based Grading—Mixes methods in an interesting way.

It looks like this area is a bit weakly developed, and it’s definitely not very researched.

## Summary of content

The basic motion data:

• TIME: The coordinate location is “timer reading” (my compromise between “time”, which I consider too confusing, and “clock reading”, which Arons prefers), and a difference between two points is called a “time interval” (which is typically not located anywhere…oh well).
• SPACE: The coordinate location is “position”, and a difference between two points is a “displacement”. The length of a path between two points is called “distance”.

The derived data are:

• RATES: The convention in rates is rates per unit of time. We term the rate at which position changes “velocity” and the rate at which distance changes “speed”. These can each be “average” or “instantaneous” depending on whether they apply to a finite of the path as a whole or the infinitessimal germ around the choosen timer reading, respectively.
• RATES OF RATES: To keep things simple, we’ll just consider one kind of rate, the rate at which velocity changes, namely, “acceleration”.

Here’s my short summary of the basic features of constantly accelerated motion.
Taking data at uniform time intervals:

• Position data are quadratic (change in change is constant).
• Velocity data (from changes in position change) are linear (change is constant).
• Acceleration data (from changes in changes in position) are constant.

I’ll try to point out common misconceptions as we go, but some relevant from the get-go are:

• Zero velocity implies zero acceleration, even for an instant.
• Velocity decreasing means something slows down. (Failure to account for vector character of velocity.)
• Constant speed implies zero acceleration. (#VectorFail)
• Distance and displacement are often confused.
• Position and displacement are often confused when making graphs.
• Position, velocity, and acceleration are “undifferentiated”.

In crafting standards, I’ll try to limit them to between 5 and 10 standards total per unit, and one of those will be something like:

• CAPM. I can solve problems involving constant acceleration. (Evidence: Correct quantities found through correct work.)
• CVPM. I can solve problems involving constant velocity. (Evidence: Correct quantities found through correct work.)

## Method 1: Standards correspond to relevant concepts.

1. CAPM. I can represent the direction of acceleration. (Evidence: Representation of acceleration (+/0/-) is correct across all representations.)
2. CVPM. I demonstrate how position differs from velocity. (Evidence: Representation of the two are different across all representations.)
3. CAPM. I can infer velocity data from acceleration data and vice versa. (Evidence: Velocity and acceleration coordinate across all representations.)
4. CVPM. I can infer position data from velocity data and vice versa. (Evidence: Position and velocity data coordinate across all representations.)
5. CAPM. I can state whether given motion data exhibits constant acceleration. (Evidence: Explicitly identifies relevant model in CA case.)
6. CVPM. I can state whether given motion data exhibits constant velocity. (Evidence: Explicitly identifies relevant model in CV case.)
7. CVPM. I can state whether given motion data exhibits constant position. (Evidence: Explicitly identifies relevant model in CP case.)
8. CAPM. I can represent constant acceleration motion qualitatively using multiple representations, such as words, diagrams, graphs, tables, and equations. (Evidence: Consistency and correctness of representations.)
9. CAPM. I can represent constant acceleration motion quantitatively using multiple representations, such as words, diagrams, graphs, tables, and equations. (Evidence: Consistency and correctness of representations.)
10. CVPM. I can represent constant velocity motion qualitatively using multiple representations, such as words, diagrams, graphs, tables, and equations. (Evidence: Consistency and correctness of representations.)
11. CVPM. I can represent constant velocity motion quantitatively using multiple representations, such as words, diagrams, graphs, tables, and equations. (Evidence: Consistency and correctness of representations.)

OK, I think I lied. I tried to make it about the concepts and relationships among the concepts, but I did it using representations. Without some sort of representation, it’s way too abstract to judge the student work. Do we just want them to write on a test, “The area under a velocity graph gives displacement”, or do we want them to use this idea to do something?

Pros: This is closer to the spirit of what I really want them to know. It’s not about learning the representations. In this method, those are just tools to communicate and refine one’s ideas while allowing one to make calculations. This method more directly targets misconceptions.

Cons: Grading means that the teacher’s eyes must jump around the page looking at all the representations. What if four are right but one is wrong? Mark it a “not yet”? What if I miss this tiny detail on another student’s paper? I grit my teeth and go back through all the grading to make sure I was consistent. Some of the standards are a little vague. The difficulty of the standards change depending on the type of data students are provided. These are the kind of standards that might make one’s head ache after grading 100 quizzes.

## Method 2: Standards correspond to the multiple representations.

Interpretation of a representation is hard to assess without correct explanation or another representation. Therefore, I focus only on creating each representation. I also eschew the good grammar of “constantly accelerated motion” for “constant acceleration motion”. The former seems to me to connote non-zero acceleration (and I have ELL learners), but maybe that’s just me.

1. CAPM. I can explain constant acceleration motion in words. (Evidence: Correct use of direction words and speeding-up/slowing-down words and other kinematic terminology. Problem: Students trying to say more are more likely to botch things up.)
2. CVPM. I can explain constant velocity motion in words. (Evidence: Correct use of direction words and speeding-up/slowing-down words and other kinematic terminology. Problem: Students trying to say more are more likely to botch things up.)
3. CAPM. I can create a table representing constant acceleration motion. (Evidence: Correct quantities (labels, numbers, and units))
4. CVPM. I can create a table representing constant acceleration motion. (Evidence: Correct quantities (labels, numbers, and units))
5. CAPM. I can create a Motion Map representing constant acceleration motion.
6. CVPM. I can create a Motion Map representing constant acceleration motion.
7. CAPM. I can create a position-versus-timer-reading graph representing constant acceleration motion.
8. CVPM. I can create a position-versus-timer-reading graph representing constant acceleration motion.
9. CAPM. I can create a velocity-versus-timer-reading graph representing constant acceleration motion.
10. CVPM. I can create a velocity-versus-timer-reading graph representing constant acceleration motion.
11. CAPM. I can create an acceleration-versus-timer-reading graph representing constant acceleration motion.

Here I still have the problem of requiring these representations to be qualitative or quantitative. I want students to be able to do both, but on assessments, I typically want quantitative accuracy.

Pros: This is easy to grade by correctness.

Cons: It does penalize students when they mess up one representation, for they are likely to mess up the others. They would have to reassess to correct the problem, but this is probably OK.

## Method 3: Standards correspond to translations between representations.

words, Motion Map, s-t graph, v-t graph, a-t graph, tables, and equations
I left out translation between tables and equations and everything else because we don’t often use them. That still leaves 5 representations for 20 permutations way too many! I left the ones I expect them to do. Since it gets tedious to read a bunch of the same language, I represented it as a digraph:

Assessed translations among kinematics multiple representations

The evidence is the faithfulness of the translation.

Pros: It’s very easy to grade this way for simple tasks. You gave students a description of motion and asked them to make a position-vs-timer-reading graph? Dead easy.

Cons: It’s harder to grade for more complex tasks. IF you gave students a description of motion and asked them to make a variety of graphs and a motion map, can you tell the order they used? Did they go from a motion map to a position-vs-timer-reading graph or vice versa? Can you tell? This is enough to disuade me from using this method. Also, propagation of error: If students mess up one translation but correctly translate that wrong representation, is it OK? Or, do you want them to recognize when what they’re doing is not CV or CA motion?

## Method 4: Standards correspond to conceptual features of representations.

Some of the features in the digraph below are from a previous blog post on analyzing velocity-vs-timer-reading graphs. Each of the features may be specified as occurring given some other kinematic event, like position when the object has reached a given speed, for instance. Again I have had to restrict myself to what I will assess. I based the arrows between objects on my current practice. I expect students to be able to do more, but I only included the most cognitively demanding tasks for assessment.

Features from Kinematics Multiple Representations

Note that if you were expecting, as I was, the concepts to match up to the features, you were sorely disappointed.

Pros: These are easy to grade when students show work near the representation or by annotating it, which I show my students how to do. It’s also very clear for students what they should be able to do.

Cons: If students don’t organize work well, it can be as hard as the previous method when students translate between representations in an unexpected manner. It also prescribes the method that the student must use. For instance, why do they need to find displacement from a velocity graph directly when they have already used that skill implicitly in creating a position graph? (Answer: For those students, I simply suggest being more explicit in annotating their velocity graphs.)

## Questions for the reader

1. How do you deal with the issue of qualitative versus quantitative correctness? Which do you require of 9th graders? 11th graders?
2. Is mastering representations of motion tantamount to learning about motions? If not, is it an acceptable proxy, or where does it fall short?
3. I worry that what I choose for students is consistent with awesomeness. Am I wasting time in thinking about this?

# Analyzing velocity-vs-timer-reading graphs

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

# Calculating velocity and acceleration from (timer reading, position) data using CAPM

I’m collecting some calculations I find useful for evaluating student data and for more advanced students to process their own data. CAPM says that we think acceleration is basically constant, gives us a mathematical model for how position and velocity depend on time, and allows us to make predictions. If we believe that CAPM holds, then we only need three points to calculate velocity and acceleration, one data point at the spacetime event in question and one on either side of the event in time.

## Assumptions

1. Acceleration is constant. Thus $x(t)=\frac12 At^2+Bt+C$ and $v(t)=At+B$.
2. The data point in question is $(t_0,x_0)$, and the points on either side are $(t_0-dt_-, x_0-dx_-)$ and $(t_0+dt_+, x_0+dx_+)$.

## General case

• $v(t_0)=\frac{\frac{dx_+}{dt_+}\cdot dt_- + \frac{dx_-}{dt_-}\cdot dt_+}{dt_-+dt_+}$
• $a(t_0)=\frac{\frac{dx_+}{dt_+}-\frac{dx_-}{dt_-}}{\frac12(dt_-+dt_+)}$

## Breadcrumb method case ($dt_-=dt_+=dt$)

• $v(t_0)=\frac{dx_-+dx_+}{2dt}$
• $a(t_0)=\frac{dx_+-dx_-}{dt^2}$

## Split time method case ($dx_-=dx_+=dx$)

• $v(t_0)=\frac{dx(dt_-^2+dt_+^2)}{dt_-dt_+(dt_-+dt_+)}$
• $a(t_0)=\frac{2dx(dt_--dt_+)}{dt_- dt_+(dt_-+dt_+)}$ (Note: This needs some reinterpretation.)

## Summary for use

With N data points, one can easily calculate N-2 velocities and accelerations at the same timer readings. Of course, one can calculate N-1 velocities at intermediate timer readings, but this can make it difficult for students to make spreadsheets for velocity. Using the method above, one can calculate both instantaneous velocity and instantaneous acceleration at the mesh of timer readings by focusing on three data points at a time. This makes it easier to test the validity of the Constant Acceleration Particle Model (CAPM).

I like to throw the formula into a spreadsheet that I use when looking at student data.  When they whiteboard in class, I type in their data to see how consistent it is, helping me to assess where students are going wrong and whether their graphs make any sense.

# 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];
}