Ticket #7197: trac_7197_basic_stats.patch

File trac_7197_basic_stats.patch, 6.9 KB (added by amhou, 12 years ago)
  • new file sage/stats/basic_stats.py

    # HG changeset patch
    # User Andrew Hou <hou.andrew@gmail.com>
    # Date 1256536506 25200
    # Node ID 90a5eeacff8d573ab6cf5c90639ce95946f9a41f
    # Parent  dd0601e1d263ffc5040535f605a2b69fb8d26eab
    basic_stats.py now works!
    
    diff -r dd0601e1d263 -r 90a5eeacff8d sage/stats/basic_stats.py
    - +  
     1from sage.rings.integer_ring import ZZ
     2from sage.symbolic.constants import NaN
     3from operator import itemgetter
     4from sage.functions.other import sqrt
     5import numpy
     6
     7def mean(v):
     8    """
     9    Return the mean of the elements of `v`.
     10
     11    We define the mean of the empty list to be NaN, following the
     12    convention of MATLAB, Scipy, and R.
     13
     14    INPUT:
     15
     16        - `v` -- a list of numbers
     17
     18    OUTPUT:
     19
     20        - a number
     21
     22    EXAMPLES::
     23
     24        sage: mean([pi, e])
     25        1/2*pi + 1/2*e
     26        sage: mean([])
     27        NaN
     28        sage: mean([I, sqrt(2), 3/5])
     29        1/3*sqrt(2) + 1/3*I + 1/5
     30        sage: mean([RIF(1.0103,1.0103), RIF(2)])
     31        1.5051500000000000?
     32        sage: mean(range(4))
     33        3/2
     34    """
     35    if hasattr(v, 'mean'): return v.mean()
     36    if len(v) == 0:
     37        return NaN
     38    s = sum(v)
     39    if isinstance(s, (int,long)):
     40        # python integers are stupid.
     41        return s/ZZ(len(v))
     42    return s/len(v)
     43
     44
     45
     46def mode(v):
     47    """
     48    Return the mode (most common) of the elements of 'v'
     49   
     50    If 'v' is empty, we define the mode to be null.
     51    If all elements occur only once, we define the mode to be null.
     52    If multiple elements occur at the same frequency, all will be
     53    displayed.
     54
     55   
     56    INPUT:
     57
     58        - 'v' -- a list
     59
     60    OUTPUT:
     61
     62        - [(element, number_of_occurences)]
     63
     64    EXAMPLES::
     65
     66        sage: mode([1,2,4,1,6,2,6,7,1])
     67        [(1, 3)]
     68        sage: mode([])
     69        []
     70        sage: mode([1,2,3,4,5])
     71        []
     72        sage: mode(['sage', 4, I, 3/5, 'sage', pi])
     73        [('sage', 2)]
     74    """
     75    freq = {}
     76    if hasattr(v, 'mode'): return v.mode()
     77    for i in v:
     78        try:
     79            freq[i] += 1
     80        except KeyError:
     81            freq[i] = 1
     82
     83    s = sorted(freq.items(), key=itemgetter(1), reverse=True)
     84    if not s or s[0][1]==1:
     85        # no mode if all occur equally often
     86        return []
     87    else:
     88        return [i for i in s if i[1]==s[0][1]]
     89
     90
     91
     92def std(v, bias=False):
     93    """
     94    Returns the standard deviation of the elements of 'v'.
     95
     96    We define the standard deviation of the empty list to be NaN,
     97    following the convention of MATLAB, Scipy, and R.
     98
     99    INPUT:
     100
     101        - 'v' -- a list of numbers
     102       
     103        - bias -- bool (default: False); if False, divide by
     104                  len(v) - 1 instead of len(v)
     105                  to give a less biased estimator (sample) for the
     106                  standard deviation.
     107
     108    OUTPUT:
     109       
     110        - a number
     111
     112    EXAMPLES::
     113
     114        sage: std([1..6], bias=True)
     115        1/2*sqrt(35/3)
     116        sage: std([1..6], bias=False)
     117        sqrt(7/2)
     118        sage: std([e, pi])
     119        sqrt(1/2)*sqrt((pi - e)^2)
     120        sage: std([])
     121        NaN
     122        sage: std([I, sqrt(2), 3/5])
     123        sqrt(1/450*(5*sqrt(2) + 5*I - 6)^2 + 1/450*(5*sqrt(2) - 10*I + 3)^2 + 1/450*(10*sqrt(2) - 5*I - 3)^2)
     124        sage: std([RIF(1.0103, 1.0103), RIF(2)])
     125        0.6998235813403261?
     126
     127
     128    """
     129    x = 0
     130    if type(v) is numpy.ndarray:
     131        # accounts for numpy arrays
     132        if bias == True:
     133            return v.std()
     134        elif bias == False:
     135            return v.std(ddof=1)
     136    if hasattr(v, 'std'): return v.std(bias=bias)
     137    if hasattr(v, 'standard_deviation'): return v.standard_deviation(bias=bias)
     138    if len(v) == 0:
     139        # standard deviation of empty set defined as NaN
     140        return NaN
     141    for i in range(len(v)):
     142        x += (v[i] - mean(v))**2
     143    if bias == True:
     144        # population standard deviation
     145        if isinstance(x, (int,long)):
     146            return sqrt(x/ZZ(len(v)))
     147        return sqrt(x/len(v))
     148    elif bias == False:
     149        # sample standard deviation
     150        if isinstance(x, (int,long)):
     151            return sqrt(x/ZZ(len(v)))
     152        return sqrt(x/(len(v)-1))
     153
     154
     155
     156
     157def variance(v, bias=False):
     158    """
     159    Returns the variance of the elements of 'v'.
     160
     161    We define the variance of the empty list to be NaN,
     162    following the convention of MATLAB, Scipy, and R.
     163
     164    INPUT:
     165
     166        - 'v' -- a list of numbers
     167       
     168        - bias -- bool (default: False); if False, divide by
     169                  len(v) - 1 instead of len(v)
     170                  to give a less biased estimator (sample) for the
     171                  standard deviation.
     172
     173    OUTPUT:
     174       
     175        - a number
     176
     177
     178    EXAMPLES::
     179
     180        sage: variance([1..6])
     181        7/2
     182        sage: variance([1..6], bias=True)
     183        35/12
     184        sage: variance([e, pi])                 
     185        1/2*(pi - e)^2
     186        sage: variance([])                     
     187        NaN
     188        sage: variance([I, sqrt(2), 3/5])       
     189        1/450*(5*sqrt(2) + 5*I - 6)^2 + 1/450*(5*sqrt(2) - 10*I + 3)^2 + 1/450*(10*sqrt(2) - 5*I - 3)^2
     190        sage: variance([RIF(1.0103, 1.0103), RIF(2)])
     191        0.4897530450000000?
     192
     193
     194    """
     195    x = 0
     196    if type(v) == numpy.ndarray:
     197        # accounts for numpy arrays
     198        if bias == True:
     199            return v.var()
     200        elif bias == False:
     201            return v.var(ddof=1)
     202    if hasattr(v, 'variance'): return v.variance(bias = bias)
     203    if len(v) == 0:
     204        # variance of empty set defined as NaN
     205        return NaN
     206    for i in range(len(v)):
     207        x += (v[i] - mean(v))**2
     208    if bias == True:
     209        # population variance
     210        if isinstance(x, (int,long)):
     211            return x/ZZ(len(v))
     212        return x/len(v)
     213    elif bias == False:
     214        # sample variance
     215        if isinstance(x, (int,long)):
     216            return x/ZZ(len(v))
     217        return x/(len(v)-1)
     218
     219
     220
     221def median(v):
     222    """
     223    Return the median (middle value) of the elements of 'v'
     224
     225    If 'v' is empty, we define the median to be null.
     226    If 'v' is comprised of strings, TypeError occurs.
     227    For elements other than numbers, the median is a result of 'sorted()'
     228
     229    INPUT:
     230
     231        - 'v' -- a list
     232
     233    OUTPUT:
     234
     235        - median element of 'v'
     236
     237    EXAMPLES::
     238
     239        sage: median([1,2,3,4,5])
     240        3
     241        sage: median([e, pi])
     242        1/2*pi + 1/2*e
     243        sage: median(['sage', 'linux', 'python'])
     244        'python'
     245        sage: median([])
     246        []
     247    """
     248    if hasattr(v, 'median'): return v.median()
     249    if len(v) == 0:
     250        #median of empty set defined as null
     251        return []
     252    values = sorted(v)
     253    if len(values) % 2 == 1:
     254        return values[((len(values))+1)/2-1]
     255    else:
     256        lower = values[(len(values)+1)/2-1]
     257        upper = values[len(values)/2]
     258        return (lower + upper)/ZZ(2)
     259