From e15cc4256054bfaa60cd7ed167c0448957c85ed2 Mon Sep 17 00:00:00 2001
From: Michael Orlitzky <michael@orlitzky.com>
Date: Sun, 3 Feb 2013 15:09:30 -0500
Subject: [PATCH] Add cleaner Show instance for Vn. Fix compiler warnings in
 FixedVector.hs. Add more doctests to FixedVector.hs.

---
 src/FixedVector.hs | 107 +++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 98 insertions(+), 9 deletions(-)

diff --git a/src/FixedVector.hs b/src/FixedVector.hs
index c01ae60..6dabfb6 100644
--- a/src/FixedVector.hs
+++ b/src/FixedVector.hs
@@ -7,16 +7,35 @@
 module FixedVector
 where
 
+import Data.List (intercalate)
 import Data.Vector.Fixed as V
 import Data.Vector.Fixed.Boxed
-import Data.Vector.Fixed.Internal
 
 import Normed
 
 -- | The Vn newtype simply wraps (Vector v a) so that we avoid
 --   undecidable instances.
 newtype Vn a = Vn a
-  deriving (Show)
+
+
+instance (Show a, Vector v a) => Show (Vn (v a)) where
+  -- | Display vectors as ordinary tuples. This is poor practice, but
+  --   these results are primarily displayed interactively and
+  --   convenience trumps correctness (said the guy who insists his
+  --   vector lengths be statically checked at compile-time).
+  --
+  --   Examples:
+  --
+  --   >>> let v1 = make2d (1,2)
+  --   >>> show v1
+  --   (1,2)
+  --
+  show (Vn v1) =
+    "(" ++ (intercalate "," element_strings) ++ ")"
+    where
+      v1l = toList v1
+      element_strings = Prelude.map show v1l
+
 
 -- | We would really like to say, "anything that is a vector of
 --   equatable things is itself equatable." The 'Vn' class
@@ -35,6 +54,7 @@ newtype Vn a = Vn a
 instance (Eq a, Vector v a, Vector v Bool) => Eq (Vn (v a)) where
   (Vn v1) == (Vn v2) = V.foldl (&&) True (V.zipWith (==) v1 v2)
 
+
 -- | The use of 'Num' here is of course incorrect (otherwise, we
 --   wouldn't have to throw errors). But it's really nice to be able
 --   to use normal addition/subtraction.
@@ -46,11 +66,30 @@ instance (Num a, Vector v a) => Num (Vn (v a)) where
   --   >>> let v1 = make2d (1,2)
   --   >>> let v2 = make2d (3,4)
   --   >>> v1 + v2
-  --   Vn fromList [4,6]
+  --   (4,6)
   --
   (Vn v1) + (Vn v2) = Vn $ V.zipWith (+) v1 v2
 
+  -- | Componentwise subtraction.
+  --
+  --   Examples:
+  --
+  --   >>> let v1 = make2d (1,2)
+  --   >>> let v2 = make2d (3,4)
+  --   >>> v1 - v2
+  --   (-2,-2)
+  --
   (Vn v1) - (Vn v2) = Vn $ V.zipWith (-) v1 v2
+
+  -- | Create an n-vector whose components are all equal to the given
+  --   integer. The result type must be specified since otherwise the
+  --   length n would be unknown.
+  --
+  --   Examples:
+  --
+  --   >>> let v1 = fromInteger 17 :: Vn (Vec3 Int)
+  --   (17,17,17)
+  --
   fromInteger x = Vn $ V.replicate (fromInteger x)
   (*) = error "multiplication of vectors is undefined"
   abs = error "absolute value of vectors is undefined"
@@ -60,11 +99,28 @@ instance Functor Vn where
   fmap f (Vn v1) = Vn (f v1)
 
 instance (RealFloat a, Ord a, Vector v a) => Normed (Vn (v a)) where
-  -- We don't use V.maximum here because it relies on a type
-  -- constraint that the vector be non-empty and I don't know how to
-  -- pattern match it away.
+  -- | The infinity norm. We don't use V.maximum here because it
+  --   relies on a type constraint that the vector be non-empty and I
+  --   don't know how to pattern match it away.
+  --
+  --   Examples:
+  --
+  --   >>> let v1 = make3d (1,5,2)
+  --   >>> norm_infty v1
+  --   5
+  --
   norm_infty (Vn v1) = fromRational $ toRational $ V.foldl max 0 v1
 
+  -- | Generic p-norms. The usual norm in R^n is (norm_p 2).
+  --
+  --   Examples:
+  --
+  --   >>> let v1 = make2d (3,4)
+  --   >>> norm_p 1 v1
+  --   7.0
+  --   >>> norm_p 2 v1
+  --   5.0
+  --
   norm_p p (Vn v1) =
     fromRational $ toRational $ root $ V.sum $ V.map (exponentiate . abs) v1
     where
@@ -72,25 +128,58 @@ instance (RealFloat a, Ord a, Vector v a) => Normed (Vn (v a)) where
       root = (** (recip (fromIntegral p)))
 
 -- | Dot (standard inner) product.
+--
+--   Examples:
+--
+--   >>> let v1 = make3d (1,2,3)
+--   >>> let v2 = make3d (4,5,6)
+--   >>> dot v1 v2
+--   32
+--
 dot :: (Num a, Vector v a) => Vn (v a) -> Vn (v a) -> a
 dot (Vn v1) (Vn v2) = V.sum $ V.zipWith (*) v1 v2
 
+
 -- | The angle between @v1@ and @v2@ in Euclidean space.
+--
+--   Examples:
+--
+--   >>> let v1 = make2d (1.0, 0.0)
+--   >>> let v2 = make2d (0.0, 1.0)
+--   >>> angle v1 v2 == pi/2.0
+--   True
+--
 angle :: (RealFloat a, Vector v a) => Vn (v a) -> Vn (v a) -> a
 angle v1 v2 =
   acos theta
   where
     theta = (v1 `dot` v2) / norms
-    norms = (norm_p 2 v1) * (norm_p 2 v2)
+    norms = (norm_p (2 :: Integer) v1) * (norm_p (2 :: Integer) v2)
+
 
--- | Convenience function for 2d vectors.
+-- | Convenience function for creating 2d vectors.
+--
+--   Examples:
+--
+--   >>> let v1 = make2d (1,2)
+--   >>> v1
+--   (1,2)
+--
 make2d :: forall a. (a,a) -> Vn (Vec2 a)
 make2d (x,y) =
   Vn v1
   where
     v1 = vec $ con |> x |> y :: Vec2 a
 
--- | Convenience function for 3d vectors.
+
+-- | Convenience function for creating 3d vectors.
+--
+--   Examples:
+--
+--   >>> let v1 = make3d (1,2,3)
+--   >>> v1
+--   (1,2,3)
+--
 make3d :: forall a. (a,a,a) -> Vn (Vec3 a)
 make3d (x,y,z) =
   Vn v1
-- 
2.44.2