← Back to branch summary

~ubuntu-branches/ubuntu/karmic/model-builder/karmic

« back to all changes in this revision

Viewing changes to model_builder/Bayes/like.py

  • Committer: Bazaar Package Importer
  • Author(s): Varun Hiremath
  • Date: 2007-04-10 17:05:04 UTC
  • Revision ID: james.westby@ubuntu.com-20070410170504-y884ntvt656218me
Tags: upstream-0.4.0
Import upstream version 0.4.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
model_builder/Bayes/like.py
 
1
#-*-encoding:latin-1-*1
 
2
# Fun��es de log verossimilhan�a
 
3
# copyright 2007 by Fl�vio Code�o Coelho
 
4
# License: GPL
 
5
#
 
6
import scipy
 
7
from scipy.special import gammaln
 
8
from numpy import *
 
9
 
 
10
 
 
11
def Categor(x,hist):
 
12
    """
 
13
    Log-like categorica
 
14
    x: vetor de dados
 
15
    hist: tupla (prob,classes) classes contem L.S. da classe
 
16
    >>> Categor([1],([.3,.7],[0,1]))
 
17
    -0.356674943939
 
18
    """
 
19
    like =0.0
 
20
    x = array(x)
 
21
    prob = array(hist[0])
 
22
    sup = array(hist[1])
 
23
    ind = searchsorted(sup,x)
 
24
    like += sum(log(prob[ind]))
 
25
    return like
 
26
 
 
27
def Normal(x,mu,tau):
 
28
    """
 
29
    Log-like normal
 
30
    mu: m�dia
 
31
    tau: precisao (1/sd)
 
32
    >>> Normal([0],0,1)
 
33
    -0.918938533205
 
34
    """
 
35
    x = array(x)
 
36
    n = x.size
 
37
    like =  sum(-0.5 * tau * (x-mu)**2)
 
38
    like += n*0.5*log(0.5*tau/pi)
 
39
    return like
 
40
    
 
41
def Lognormal(x,mu,tau):
 
42
    """
 
43
    Log-like Lognormal
 
44
    mu: m�dia
 
45
    tau: precisao (1/sd)
 
46
    >>> Lognormal([0.5,1,1.2],0,0.5)
 
47
    -3.15728720569
 
48
    """
 
49
    x = array(x)
 
50
    n = x.size
 
51
    like = n * 0.5 * (log(tau) - log(2.0*pi)) + sum(0.5*tau*(log(x)-mu)**2 - log(x))
 
52
    return like
 
53
 
 
54
def Poisson(x,mu):
 
55
    """
 
56
    Log-Like Poisson
 
57
    >>> Poisson([2],2)
 
58
    -1.30685281944
 
59
    """
 
60
    x=array(x)
 
61
    sumx = sum(x*log(mu)-mu)
 
62
    sumfact = sum(log(scipy.factorial(x)))
 
63
    like = sumx-sumfact
 
64
    return like
 
65
 
 
66
def Negbin(x,r,p):
 
67
    """
 
68
    Log-Like negative Binomial
 
69
    >>> Negbin([2,3],6,0.3)
 
70
    -9.16117424315
 
71
    """
 
72
    x = array(x)
 
73
    like = sum(r*log(p)+x*log(1-p)+log(scipy.factorial(x+r-1))-log(scipy.factorial(x))-log(scipy.factorial(r-1)))
 
74
    return like
 
75
 
 
76
def Binomial(x,n,p):
 
77
    """
 
78
    Log-Like Binomial
 
79
    >>> Binomial([2,3],6,0.3)
 
80
    -2.81280615454
 
81
    """
 
82
    x = array(x)
 
83
    like = sum(x*log(p)+ (n-x)*log(1.-p)+log(scipy.factorial(n))-log(scipy.factorial(x))-log(scipy.factorial(n-x)))
 
84
    return like
 
85
 
 
86
def Weibull(x,alpha,beta):
 
87
    """
 
88
    Log-Like Weibull
 
89
    >>> Weibull([2,1,0.3,.5,1.7],1.5,3)
 
90
    -7.811955373
 
91
    """
 
92
    x=array(x)
 
93
    beta = float(beta)
 
94
    n = x.size
 
95
    #Normalizing constant
 
96
    like = n * (log(alpha) - alpha*log(beta))
 
97
    # Kernel of the distribution
 
98
    like += sum((alpha-1) * log(x) - (x/beta)**alpha)
 
99
    return like
 
100
 
 
101
def Bernoulli(x,p):
 
102
    """
 
103
    Log-Like Bernoulli
 
104
    >>> Bernoulli([0,1,1,1,0,0,1,1],0.5)
 
105
    -5.54517744448
 
106
    """
 
107
    x=array(x)
 
108
    like = sum(x*log(p) + (1-x)*log(1.-p))
 
109
    return like
 
110
 
 
111
def Gamma(x,alpha,beta):
 
112
    """
 
113
    Log-Like Gamma
 
114
    >>> Gamma([2,3,7,6,4],2,2)
 
115
    -11.015748357
 
116
    """
 
117
    x = array(x)
 
118
    beta = float(beta)
 
119
    n = x.size
 
120
    #Normalizing constant
 
121
    like = -n * (gammaln(alpha) + alpha*log(beta))
 
122
    # Kernel of the distribution
 
123
    like += sum((alpha - 1.0)*log(x) - x/beta)
 
124
    return like
 
125
    
 
126
def Beta(x,a,b):
 
127
    """
 
128
    Log-Like Beta
 
129
    >>> Beta([.2,.3,.7,.6,.4],2,5)
 
130
    -0.434845728904
 
131
    """
 
132
    x = array(x)
 
133
    n = x.size
 
134
    #Normalizing constant
 
135
    like = n * (gammaln(a+b) - gammaln(a) - gammaln(b))
 
136
    # Kernel of the distribution
 
137
    like += sum((a-1.0)*log(x) + (b-1.0)*log(1.0-x))
 
138
    return like
 
139
 
 
140
def Simple(x,w,a,start=0):
 
141
    """
 
142
    find out what it is.
 
143
    not implemented.
 
144
    """
 
145
    m=len(a)
 
146
    n=len(x)
 
147
    pass
 
148
    
 
149
if __name__=="__main__":
 
150
    import doctest
 
151
    doctest.testmod(verbose=True)