Optimal ForceVelocity Profile for Sprinting: Is It All Bollocks? – Part 1
In this article series I will provide my opinion regarding the use of ForceVelocity Profile (FVP) optimization for short sprints (i.e., the sprints where there is no deceleration). Recent paper by Pierre Samozino et al. (2022) continues this FVP optimization theme from jumping [Pierre Samozino et al. (2012); Pierre Samozino (2018); P. Samozino et al. (2013); Pierre Samozino et al. (2008)]^{1}, but now applied to short sprinting. Before I offer my opinion, I will need to walk you through the whole process.
In this article series I will use the {shorts} package (Jovanović and Vescovi 2022; Jovanović 2022) for R programming language (R Core Team 2022). Code will be provided, but for more thorough introductions, please check the provided references.
Sprint models
There are multiple ways of how sprint models are created (e.g., using timing gates, video analysis, radar/laser guns, tether devices), but in first part of this article series, I will use the radar/laser gun. With radar/laser gun method, athlete accelerates maximally until reaching top speed (it depends on the level/sport, but 40m for your average team sport athlete is usually enough). Radar or laser gun is pointed to the athlete upper or lower back, and the captured velocity is assumed to be centerofmass (COM) velocity. Frequency of capturing this velocity is often pretty high (e.g., 100Hz or more; in other words 100 samples in a second).
There are some issues with collecting this velocity when athletes start from the crouch position instead of the standing start, but I will disregard them for the purpose of this article. Figure 1 depicts one such sprint. Please notice that the grey line, which represents the raw or instantaneous velocity, fluctuates. This is due to deccelerations and reaccelerations from step to step. There is certainly some noise involved (which can make havoc when estimating acceleration or the 1st derivative), but we will disregard it here. To provide average step velocity, the radar or laser software also provides some smoothed velocity (see black line on Figure 1). This is achieved by using certain filters (i.e., Kalman for example). And this is where we make our first model approximation (actually second, if we disregarding the assumption that low/upper back velocity is COM velocity). This assumption is that the COM velocity is smooth (by averaging step velocities, so to speak).
Show/Hide Code
require(tidyverse)
require(shorts)
require(cowplot)
require(directlabels)
# Prepare data
laser_df < read_csv("data/samplelaser.csv") %>%
mutate(Time = Time / 1000)
# Get the deceleration location with simple heuristic
dec_time < laser_df$Time[which.max(laser_df$Smooth)]
# Plot
ggplot(laser_df, aes(x = Time, y = `RawVelocity`)) +
theme_linedraw(8) +
annotate(
"rect",
xmin = dec_time, xmax = 5.5, ymin = 6.5, ymax = 7.5,
fill = "grey", alpha = 0.5
) +
annotate(
"text",
x = dec_time, y = 7.6, hjust = "left", vjust = "bottom",
label = "Decceleration", size = 2.5
) +
geom_line(alpha = 0.8, color = "grey") +
geom_line(aes(y = Smooth), alpha = 0.8, color = "black") +
scale_color_brewer(palette = "Set1") +
xlab("Time (sec)") +
ylab("Velocity (m/s)")
Figure 1: Short sprint velocity using radar/laser gun. Notice the fluctuations in raw/ instantaneous velocity (grey line), which is due steptostep decceleration/acceleration. Black line represents smoothed velocity using certain types of filter, to yield aproximate average step velocity. Grey area is where athlete starts to deccelerate, and this phase should be filtered out from our sample
It is important to keep in mind that the models are simplifications of the reality, built to describe, predict, and sometimes explain and intervene on phenomena we regularly observe. In other words, we try to create a simplified map of the Large World using Small World models (McElreath 2020; Savage 1972; Binmore 2011; Volz and Gigerenzer 2012; Gigerenzer, Hertwig, and Pachur 2015; Jovanović 2020). These are always wrong, but can be useful, sometime they can even be harmful (i.e., when making erroneous intervention claims, by assuming causal explanation of the model). I will come back to this dichotomy thorough this article series.
Instead of using simple filtering to smooth out the sprint velocity, we can fit (1) 3rd degree polynomial model (Equation 1), and (2) monoexponential model (Equation 2) (implemented in the {shorts} package). I will explore these two, but we will use monoexponential model as a gold standard to model velocity performance during short sprints. In the second part of this article series I will focus solely on the monoexponential model and its characteristics.
\begin{split}v(t) = b_0 + b_1 \times t + b_2 \times t^2 + b_3 \times t^3 \\\end{split}
Equation 1
\begin{split}v(t) = MSS \times (1 – e^{\frac{t}{TAU}}) \\\end{split}
Equation 2
Before we continue with our modeling aims, we need to filterout that grey deceleration phase from Figure 1. The question is how do we decide at which point in time one start to deccelerate? This is additional subjective input in our modeling (the scienceisobjective crowd will roll their eyes here). For the sake of this example, I will use peak smoothed velocity and remove everything after that.
Figure 2 depicts model predictions. In other words, these models (with the exception of the smooth model), mapout the relationship between time (i.e., predictor variable) and raw velocity (i.e., target or outcome variable).
Show/Hide Code
# Remove deceleration section
laser_df < laser_df %>%
filter(Time <= dec_time)
# Make models
# Monoexponential
m1 < shorts::model_radar_gun(
time = laser_df$Time,
velocity = laser_df$`RawVelocity`
)
# Polynomial model
m2 < lm(`RawVelocity` ~ poly(Time, 3), laser_df)
# Add prediction
laser_models_df < laser_df %>%
mutate(
`Monoexponential` = predict(m1),
`Polynomial` = predict(m2)
) %>%
# convert to long
pivot_longer(cols = Time, names_to = "model", values_to = "velocity") %>%
mutate(model = factor(model, levels = c("RawVelocity", "Smooth", "Polynomial", "Monoexponential"))) %>%
# Get Acceleration and power
group_by(model) %>%
arrange(Time) %>%
mutate(
dv = c(NA, diff(velocity)),
dt = c(NA, diff(Time)),
acceleration = dv/dt,
net_relative_power = velocity * acceleration
) %>%
ungroup()
# Plot velocity
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = Time, y = velocity, color = model)) +
theme_linedraw(8) +
geom_line(
data = laser_models_df %>%
filter(model == "RawVelocity"),
aes(x = Time, y = velocity),
color = "grey",
alpha = 0.8
) +
geom_line(alpha = 0.8) +
scale_color_brewer(palette = "Set1") +
xlab("Time (sec)") +
ylab("Velocity (m/s)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 5.5) +
ylim(0, 9)
Figure 2: Short sprint velocity using radar/laser gun. To “smooth” out the fluctuations, multiple models could be used. Here we have depicted software smoother (most likely using some type of Kalman filter), as well as polynomial (3rd degree) and monoexponential model predictions
As can be seen from Figure 2, polynomial and monoexponential models provide almost identical model predictions or model fit (standard error of the estimate equal to 0.332 and 0.334 $ ms^1$ respectively). Before I embark on the benefits of using monoexponential model (which should be more evident as you read anyway), let’s explore other kinematic variables: acceleration and power.
To estimate acceleration, we need to do 1st derivative (i.e., how fast is the velocity changing). In other words, we need to divide the change in velocity (i.e., $ \Delta v $) with change in time ($ \Delta t $). We can do this (1) computationally, and (2) algebraically using the actual models themselves. Algebraic method involves solving some ordinary differential equations (ODE) for the polynomial model and monoexponential model (which is easier to be done and can be found in Equation 3).
\begin{split}a(t) = \frac{MSS}{TAU} \times e^{\frac{t}{TAU}}\\\end{split}
Equation 3
But to provide the fair treatment to raw and smoothed velocity, I will estimate and plot acceleration using computational method by dividing change in velocity (i.e., difference between two adjunct samples in the data) by the change in time (or more simply by the 1/sampling rate). Result of this method is plotted in Figure 3. Note that Figure 3 have two figures  Figure 3 (a) includes acceleration estimated using raw velocity (grey line), while Figure 3 (b) excludes it for a better view of the model estimated acceleration.
Show/Hide Code
# Plot acceleration
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = Time, y = acceleration, color = model)) +
theme_linedraw(8) +
geom_hline(yintercept = 0, linetype = "dotted") +
geom_line(
data = laser_models_df %>%
filter(model == "RawVelocity"),
aes(x = Time, y = acceleration),
color = "grey",
alpha = 0.8
) +
geom_line(alpha = 0.8) +
scale_color_brewer(palette = "Set1") +
xlab("Time (sec)") +
ylab("Acceleration (m/s/s)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 5.5)
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = Time, y = acceleration, color = model)) +
theme_linedraw(8) +
geom_hline(yintercept = 0, linetype = "dotted") +
geom_line(alpha = 0.8) +
scale_color_brewer(palette = "Set1") +
xlab("Time (sec)") +
ylab("Acceleration (m/s/s)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 5.5)
(a) Estimated acceleration using raw velocity
(b) Estimated acceleration using model predictions
Figure 3: Estimated acceleration using dt/dv
There are few things to notice from Figure 3. First, see how the estimated acceleration from the raw velocity is wild. This can be due to measurement noise that is included in the raw signal, which is magnified when doing the first derivative. But this can also be the real acceleration phenomena, where on each step there are acceleration and decceration cycles (which can also help us identify steps and maybe quantify leftright side differences or asymmetries, but this is a topic for another article). These magnitudes might also be telling a story that we can use  for example we might notice that someone might be breaking too much due to overstriding or what have you. Anyway, these should not be thrown out easily for the more gross (or smoothed out, or averaged out) accelerations we get from the models or model predictions.
Second thing to notice is the acceleration estimated from the smoothed velocity. This is also wild, but less than the acceleration estimated from the raw velocity values.
Third thing to notice is the difference between estimated acceleration using polynomial and monoexponential velocity predictions. Monoexponential model demonstrated higher initial acceleration (this is equal to $ MAC $; maximal acceleration or $ \frac{MSS}{TAU} $ which I will explain in more details in the next installment) that tapers down to zero. Contrary to this, polynomial model estimated acceleration is lower at the start, but it has this weird increase at the end of the sprint. This model is thus theoretically unsound (keep counting these drawbacks please).
Let’s estimate net relative power (in W/kg). To do this we just multiply velocity with estimated acceleration. Why is this called net power? Because, this is not the total power generated by the athlete, but only power involved in increasing the momentum or the kinetic energy. To estimate total power, we need to have other resisting forces (e.g., air resistance) and work done (e.g., accelerating and decelerating limbs, which can demand more that 80% energy generated  I do not have a reference for this, sorry evidencebased zealots. Must have been in the Bosch book somewhere). And why is it called relative? Because it is relative to bodyweight or mass of the athlete.
Estimated net relative power (in W/kg) is depicted in Figure 4.
Show/Hide Code
# Plot net relative power
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = Time, y = net_relative_power, color = model)) +
theme_linedraw(8) +
geom_line(
data = laser_models_df %>%
filter(model == "RawVelocity"),
aes(x = Time, y = net_relative_power),
color = "grey",
alpha = 0.8
) +
geom_line(alpha = 0.8) +
scale_color_brewer(palette = "Set1") +
xlab("Time (sec)") +
ylab("Net Relative Power (W/kg)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 5.5)
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = Time, y = net_relative_power, color = model)) +
theme_linedraw(8) +
geom_line(alpha = 0.8) +
scale_color_brewer(palette = "Set1") +
xlab("Time (sec)") +
ylab("Net Relative Power (W/kg)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 5.5)
(a) Estimated power using raw velocity and raw acceleration
(b) Estimated power using model predicted velocity and acceleration
Figure 4: Estimated net relative power using acceleration x velocity
Similarly to acceleration, there are few thing to notice from Figure 4. Power estimated from raw velocity and acceleration is all over the place. Again, this could be due to measurement noise, or it could be the real phenomena due to step to step accelerations and deccelerations.
Power estimated using model predictions demonstrates asymmetrical bellshape with a prominent peak value (this value is called $ P_{peak} $ and represent maximal net power manifested). For the monoexponential model, this is equal to $ \frac{MSS \times MAC}{4} $, which is another simplicity (or mathematical elegance) benefit of the monoexponential model. Notice that power estimated using monoexponential model tapers of to zero (not shown in Figure 4), which is in alignment with our theoretical understanding (i.e., when reaching steady velocity, net power is equal to zero). This is not the case for the polynomial model.
Another interesting analysis is the relationship between acceleration and velocity, or AccelerationVelocity Profile (AVP). This simply done by plotting each sampled velocity with estimated acceleration (Figure 5) and represents the basis for the ForceVelocity Profile.
Show/Hide Code
# Plot accelerationvelocity profile
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = velocity, y = acceleration, color = model)) +
theme_linedraw(8) +
geom_point(
data = laser_models_df %>%
filter(model == "RawVelocity"),
aes(x = velocity, y = acceleration),
color = "grey",
size = 0.05,
alpha = 0.8
) +
geom_point(alpha = 0.5, size = 0.25) +
scale_color_brewer(palette = "Set1") +
xlab("Velocity (m/s)") +
ylab("Accelertion (m/s/s)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 9)
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = velocity, y = acceleration, color = model)) +
theme_linedraw(8) +
geom_point(alpha = 0.5, size = 0.25) +
scale_color_brewer(palette = "Set1") +
xlab("Velocity (m/s)") +
ylab("Accelertion (m/s/s)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 9)
(a) Estimated AVP using raw velocity and raw acceleration
(b) Estimated AVP using model predicted velocity and acceleration
Figure 5: AccelerationVelocity Profile (AVP)
Please note that there is no “profile” when using raw velocity and acceleration estimated from raw velocity (grey dots in Figure 5 (a)). The key thing to notice from Figure 5 (b), is that AVP for the monoexponential model is linear. This is indeed interesting characteristic of this model, since with only two parameters (i.e., MSS and MAC or TAU) we can explain the whole profile. It is indeed mathematically elegant model.
Kinetics and ForceVelocity Profile
To create ForceVelocity Profile (FVP), we simply need to estimate the total step average force being generated horizontally by the athlete. Since we know the instant acceleration and athlete body mass, we can calculate the net force, by simply multiplying the weight with acceleration. But athlete also needs to overcome one more force (i.e., one more force according to this simple model; there are multiple other forces and work that needs to be done to move the limbs, as alluded previously): air resistance force. Air resistance force (measured in Newtons, N) depends on the velocity, body mass (kg), body height (m), barometric pressure (Torr), air temperature ($ C^\circ $), and wind velocity ($ ms^1 $) (please refer to Arsac and Locatelli (2002), P. Samozino et al. (2016), and Ingen Schenau, Jacobs, and Koning (1991) for more information).
We can simply estimate total horizontal force by using $ F_{total} = a \times m + F_{air} $ by assuming athlete weights 85kg and is tall 1.8m (see the code for Figure 6).
Show/Hide Code
# Add air resistance
laser_models_df < laser_models_df %>%
mutate(
f_air = get_air_resistance(velocity = velocity, bodymass = 85, bodyheight = 1.8),
f_total = 85 * acceleration + f_air,
f_total_relative = f_total / 85,
power = f_total * velocity,
relative_power = power / 85
)
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = velocity, y = f_total, color = model)) +
theme_linedraw(8) +
geom_point(
data = laser_models_df %>%
filter(model == "RawVelocity"),
aes(x = velocity, y = f_total),
color = "grey",
size = 0.05,
alpha = 0.8
) +
geom_point(alpha = 0.5, size = 0.25) +
scale_color_brewer(palette = "Set1") +
xlab("Velocity (m/s)") +
ylab("Horizontal Force (N)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 9)
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = velocity, y = f_total, color = model)) +
theme_linedraw(8) +
geom_point(alpha = 0.5, size = 0.25) +
scale_color_brewer(palette = "Set1") +
xlab("Velocity (m/s)") +
ylab("Horizontal Force (N)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 9)
(a) Estimated FVP using raw velocity, raw acceleration, and air resistance
(b) Estimated FVP using model predicted velocity, acceleration, and air resistance
Figure 6: ForceVelocity Profile (FVP)
As can be seen, the shape of Figure 6 (b) is very similar to Figure 5. One thing to notice, although a bit harder, is that FVP for the monoexponential model is not a straight line anymore, but very, very close to being straight. We can thus actasif it is straight line. But this will introduce some error, as I will explore in the next installment.
Now when we have total horizontal force, we can also calculate total power (Figure 7). This is power used to gain horizontal momentum and to overcome air resistance, but not exactly the total power needed to move the limbs, overcome vertical up and down movements and so forth.
Show/Hide Code
# Plot net relative power
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = Time, y = power, color = model)) +
theme_linedraw(8) +
geom_line(
data = laser_models_df %>%
filter(model == "RawVelocity"),
aes(x = Time, y = power),
color = "grey",
alpha = 0.8
) +
geom_line(alpha = 0.8) +
scale_color_brewer(palette = "Set1") +
xlab("Time (sec)") +
ylab("Power (W)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 5.5)
ggplot(
laser_models_df %>%
filter(model != "RawVelocity"),
aes(x = Time, y = power, color = model)) +
theme_linedraw(8) +
geom_line(alpha = 0.8) +
scale_color_brewer(palette = "Set1") +
xlab("Time (sec)") +
ylab("Power (W)") +
theme(legend.position = "none") +
geom_dl(
aes(label = paste(" ", model)),
method = list("last.bumpup", cex = 0.5)
) +
xlim(0, 5.5)
(a) Estimated FVP using raw velocity, raw acceleration, and air resistance
(a) Estimated FVP using raw velocity, raw acceleration, and air resistance
Figure 7: Estimated total power using horizontal force x velocity
Key takeways
In my opinion, the models introduced here serve to simplify or summarize the observed sprint performance, rather than to uncover some hidden causal qualities (i.e., traits). There are a lot of assumptions and probably a lot of useful information being disregarded (e.g., total power generated, within step acceleration and deceleration fluctuations) to create simplistic summaries these models provide. But they can be useful for that purpose, as long as we do not give them more (causal) power and interpretation. I will expand on these topics thorough this article series.
As seen in this first installment, monoexponential model seems like a more favorable model to describe short sprints: it is more theoretical aligned with out expectations, it is mathematically more elegant, and it also provides parameters (i.e., MSS, TAU, MAC) that are more interpretable and more related to the real traits/qualities, or at least to the phenomena we observe (e.g., someone being better accelerator will have higher MAC parameter values).
In the next installment I will continue with exploring the characteristics of the monoexponential model. Although velocity trace acquired from the radar/laser gun can be more telling, we often do not have access to those, and must use timing gates. But we can still use variant of the monoexponential model to estimate MSS and TAU parameters, and using those to create AVP and FVP, as well as play with model optimization.
In the next installment I will explore the assumptions and behavior of the monoexponential model itself, which is needed to understand the concept of optimal FVP for sprinting. It is important to keep in mind that these are characteristics of the “Small World” model, rather than characteristics of the “Large World”  please do not confuse model for the reality. Map is not the territory.
References
 Arsac, Laurent M., and Elio Locatelli. 2002. “Modeling the Energetics of 100m Running by Using Speed Curves of World Champions.” Journal of Applied Physiology 92 (5): 1781–88. https://doi.org/10.1152/japplphysiol.00754.2001.
 Binmore, Ken. 2011. Rational Decisions. Fourth Impression edition. Princeton, NJ: Princeton University Press.
 Gigerenzer, Gerd, Ralph Hertwig, and Thorsten Pachur. 2015. Heuristics: The Foundations of Adaptive Behavior. Reprint edition. Oxford University Press.
 Ingen Schenau, Gerrit Jan van, Ron Jacobs, and Jos J. de Koning. 1991. “Can Cycle Power Predict Sprint Running Performance?” European Journal of Applied Physiology and Occupational Physiology 63 (34): 255–60. https://doi.org/10.1007/BF00233857.
 Jovanović, Mladen. 2020. Strength Training Manual: The Agile Periodization Approach. Independently published.
 ———. 2022. Shorts: Short Sprints. https://cran.rproject.org/package=shorts.
 Jovanović, Mladen, and Jason Vescovi. 2022. “Shorts: An r Package for Modeling Short Sprints.” International Journal of Strength and Conditioning 2 (1). https://doi.org/10.47206/ijsc.v2i1.74.
 McElreath, Richard. 2020. Statistical Rethinking: A Bayesian Course with Examples in r and Stan. 2nd ed. CRC Texts in Statistical Science. Boca Raton: Taylor; Francis, CRC Press.
 R Core Team. 2022. R: A Language and Environment for Statistical Computing. Vienna, Austria: R Foundation for Statistical Computing. https://www.Rproject.org/.
 Samozino, P., P. Edouard, S. Sangnier, M. Brughelli, P. Gimenez, and J.B. Morin. 2013. “ForceVelocity Profile: Imbalance Determination and Effect on Lower Limb Ballistic Performance.” International Journal of Sports Medicine 35 (06): 505–10. https://doi.org/10.1055/s00331354382.
 Samozino, Pierre. 2018. “Optimal ForceVelocity Profile in Ballistic PushOff: Measurement and Relationship with Performance.” In, edited by JeanBenoit Morin and Pierre Samozino, 97–119. Cham: Springer International Publishing. https://doi.org/10.1007/9783319056333_5.
 Samozino, Pierre, JeanBenoît Morin, Frédérique Hintzy, and Alain Belli. 2008. “A Simple Method for Measuring Force, Velocity and Power Output During Squat Jump.” Journal of Biomechanics 41 (14): 2940–45. https://doi.org/10.1016/j.jbiomech.2008.07.028.
 Samozino, Pierre, Nicolas Peyrot, Pascal Edouard, Ryu Nagahara, Pedro JimenezReyes, Benedicte Vanwanseele, and JeanBenoit Morin. 2022. “Optimal Mechanical ForceVelocity Profile for Sprint Acceleration Performance.” Scandinavian Journal of Medicine & Science in Sports 32 (3): 559–75. https://doi.org/10.1111/sms.14097.
 Samozino, Pierre, Enrico Rejc, Pietro Enrico Di Prampero, Alain Belli, and JeanBenoît Morin. 2012. “Optimal ForceVelocity Profile in Ballistic MovementsAltius:” Medicine & Science in Sports & Exercise 44 (2): 313–22. https://doi.org/10.1249/MSS.0b013e31822d757a.
 Samozino, P., G. Rabita, S. Dorel, J. Slawinski, N. Peyrot, E. Saez de Villarreal, and J.B. Morin. 2016. “A Simple Method for Measuring Power, Force, Velocity Properties, and Mechanical Effectiveness in Sprint Running: Simple Method to Compute Sprint Mechanics.” Scandinavian Journal of Medicine & Science in Sports 26 (6): 648–58. https://doi.org/10.1111/sms.12490.
 Savage, Leonard J. 1972. The Foundations of Statistics. 2nd Revised ed. edition. New York: Dover Publications.
 Volz, Kirsten G, and Gerd Gigerenzer. 2012. “Cognitive Processes in Decisions Under Risk Are Not the Same as in Decisions Under Uncertainty.” Frontiers in Neuroscience 6 (105). https://doi.org/10.3389/fnins.2012.00105.
Footnotes

You can find more about this model and my beef with it in the ForceVelocity Profiling and Training Optimization Course ↩︎
Responses