-----------------------------------------------------------------------------
-- |
-- Module      :  Numeric.Statistics.TTest
-- Copyright   :  (c) Matthew Donadio 2002
-- License     :  GPL
--
-- Maintainer  :  m.p.donadio@ieee.org
-- Stability   :  experimental
-- Portability :  portable
--
-- UNTESTED: DO NOT USE
--
-- Student's t-test functions
--
-- Reference: NRiC
--
-----------------------------------------------------------------------------

module Numeric.Statistics.TTest (ttest, tutest, tptest) where

import Numeric.Statistics.Covariance
import Numeric.Statistics.Moment

ttest :: [Double] -- ^ X1
      -> [Double] -- ^ X2
      -> Double   -- ^ t

ttest :: [Double] -> [Double] -> Double
ttest [Double]
x1 [Double]
x2 = Double
t
    where t :: Double
t = (Double
mu1 forall a. Num a => a -> a -> a
- Double
mu2) forall a. Fractional a => a -> a -> a
/ Double
s_d
	  mu1 :: Double
mu1 = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.sum [Double]
x1 forall a. Fractional a => a -> a -> a
/ Double
n1
	  mu2 :: Double
mu2 = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.sum [Double]
x2 forall a. Fractional a => a -> a -> a
/ Double
n2
	  v1 :: Double
v1  = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.sum (forall a b. (a -> b) -> [a] -> [b]
map (\Double
x -> (Double
x forall a. Num a => a -> a -> a
- Double
mu1)forall a b. (Num a, Integral b) => a -> b -> a
^(Int
2::Int)) [Double]
x1)
	  v2 :: Double
v2  = forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
Prelude.sum (forall a b. (a -> b) -> [a] -> [b]
map (\Double
x -> (Double
x forall a. Num a => a -> a -> a
- Double
mu2)forall a b. (Num a, Integral b) => a -> b -> a
^(Int
2::Int)) [Double]
x2)
	  n1 :: Double
n1  = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ [Double]
x1
	  n2 :: Double
n2  = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ [Double]
x2
	  s_d :: Double
s_d = forall a. Floating a => a -> a
sqrt (((Double
v1 forall a. Num a => a -> a -> a
+ Double
v2) forall a. Fractional a => a -> a -> a
/ (Double
n1forall a. Num a => a -> a -> a
+Double
n2forall a. Num a => a -> a -> a
-Double
2)) forall a. Num a => a -> a -> a
* (Double
1forall a. Fractional a => a -> a -> a
/Double
n1 forall a. Num a => a -> a -> a
+ Double
1forall a. Fractional a => a -> a -> a
/Double
n2))

tutest :: [Double] -- ^ X1
       -> [Double] -- ^ X2
       -> Double   -- ^ t

tutest :: [Double] -> [Double] -> Double
tutest [Double]
x1 [Double]
x2 = Double
t
    where t :: Double
t = (Double
mu1 forall a. Num a => a -> a -> a
- Double
mu2) forall a. Fractional a => a -> a -> a
/ forall a. Floating a => a -> a
sqrt (Double
var1 forall a. Fractional a => a -> a -> a
/ Double
n1 forall a. Num a => a -> a -> a
+ Double
var2 forall a. Fractional a => a -> a -> a
/ Double
n2)
	  mu1 :: Double
mu1 = forall a. Fractional a => [a] -> a
mean [Double]
x1
	  mu2 :: Double
mu2 = forall a. Fractional a => [a] -> a
mean [Double]
x2
	  var1 :: Double
var1 = forall a. Fractional a => [a] -> a
var [Double]
x1
	  var2 :: Double
var2 = forall a. Fractional a => [a] -> a
var [Double]
x2
	  n1 :: Double
n1  = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ [Double]
x1
	  n2 :: Double
n2  = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ [Double]
x2

tptest :: [Double] -- ^ X1
       -> [Double] -- ^ X2
       -> Double   -- ^ t

tptest :: [Double] -> [Double] -> Double
tptest [Double]
x1 [Double]
x2 = Double
t
    where t :: Double
t = (Double
mu1 forall a. Num a => a -> a -> a
- Double
mu2) forall a. Fractional a => a -> a -> a
/ Double
s_d
	  mu1 :: Double
mu1 = forall a. Fractional a => [a] -> a
mean [Double]
x1
	  mu2 :: Double
mu2 = forall a. Fractional a => [a] -> a
mean [Double]
x2
	  var1 :: Double
var1 = forall a. Fractional a => [a] -> a
var [Double]
x1
	  var2 :: Double
var2 = forall a. Fractional a => [a] -> a
var [Double]
x2
	  s_d :: Double
s_d = forall a. Floating a => a -> a
sqrt ((Double
var1 forall a. Num a => a -> a -> a
+ Double
var2 forall a. Num a => a -> a -> a
- Double
2 forall a. Num a => a -> a -> a
* forall a. Fractional a => [a] -> [a] -> a
cov [Double]
x1 [Double]
x2) forall a. Fractional a => a -> a -> a
/ Double
n)
	  n :: Double
n  = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ forall (t :: * -> *) a. Foldable t => t a -> Int
length forall a b. (a -> b) -> a -> b
$ [Double]
x1