From 4e987026148fe65c323afbc93cd560c07bf06b3f Mon Sep 17 00:00:00 2001
From: Yale AI Dept <ai@nebula.cs.yale.edu>
Date: Wed, 14 Jul 1993 13:08:00 -0500
Subject: Import to github.

---
 progs/demo/X11/animation/r_curve.hs | 60 +++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 progs/demo/X11/animation/r_curve.hs

(limited to 'progs/demo/X11/animation/r_curve.hs')

diff --git a/progs/demo/X11/animation/r_curve.hs b/progs/demo/X11/animation/r_curve.hs
new file mode 100644
index 0000000..14d288c
--- /dev/null
+++ b/progs/demo/X11/animation/r_curve.hs
@@ -0,0 +1,60 @@
+{-**************************************************************
+  MODULE R_CURVE
+
+    This module produces sequences of numbers to be used by
+  Behaviours. The sequences used for moving or scaling can
+  be produced here, in either linear sequences or accelerating
+  and decelerating sequences.
+    The acceleration functions produce floats, so the vftov function
+  would have to be used to convert floating point vectors to integer
+  vectors.
+
+***************************************************************-}
+
+module R_Curve(lnr,hold, acc, dec, accdec, decacc) where
+
+import R_Ptypes
+import R_Constants
+import R_Utility
+import R_Picture
+import R_Behaviour
+
+  -- lnr takes the start, finish and the number of intervals and
+  -- produces a linear list of ints going from the start to finish.
+lnr :: Int -> Int -> Int ->[Int]
+lnr start fin n = take n [start,(start+step)..]
+			where step = ((fin-start)`div`(n-1))
+
+  -- hold produces an infinite number of ints starting at v, modified
+  -- by step every time.
+hold :: Int -> Int -> [Int]  
+hold v step  = [v,v+step..]
+
+  -- acc accelerates from 0 to the max in n steps.
+acc :: Int -> Int -> Int -> [Int]
+acc min max n = min:acc' min (max-min) n 1 
+
+acc' ::  Int -> Int -> Int -> Int -> [Int]
+acc' min max n c | (c>n) = []
+acc' min max n c         = (min + (((max*c*c) `div` (n*n)))) 
+                           : (acc' min max n (c+1)) 
+
+
+  -- dec decelerates from the max to 0 in n steps.
+dec :: Int -> Int -> Int -> [Int]
+dec min max n = reverse (acc min max n)
+  
+  -- accdec accelerates from start up to max and back to fin, in an steps
+  -- accelerating and dn steps decelerating
+accdec :: Int -> Int -> Int -> Int -> Int -> [Int]
+accdec start max fin an dn = (acc start max an)++(tail (dec fin max dn))
+
+  -- decacc decelerates from start to min in dn steps and then accelerates
+  -- back up to fin in an more steps
+decacc :: Int -> Int -> Int -> Int -> Int -> [Int]
+decacc start min fin dn an = (dec min start dn)++(tail (acc min fin an))
+
+
+
+
+
-- 
cgit v1.2.3