hand merge

haskell/Tests/RoundTrip.hs

@@ -259,11 +259,6 @@ testRayleighRelations :: Test
 testRayleighRelations = test [
     "t_weibull_to_rayleigh" ~: testConcreteFiles "tests/RoundTrip2/t_weibull_to_rayleigh.0.hk" "tests/RoundTrip2/t_weibull_to_rayleigh.expected.hk"
     ]
-
-testCauchyRelations :: Test 
-testCauchyRelations = test [
-    "t_cauchy_linear_transformation" ~: testConcreteFiles "tests/RoundTrip2/t_cauchy_linear_transformation.0.hk" "tests/RoundTrip2/t_cauchy_linear_transformation.expected.hk"
-    ]
 
 testOther :: Test
 testOther = test [

stdlib/exponential.hk

@@ -5,57 +5,73 @@
 # Exponential Distribution and Transformations #
 ################################################
 
+# The documents on parametrization can be found at: http://www.math.wm.edu/~leemis/chart/UDR/UDR.html
+
+
 def exponential(alpha prob) measure(prob):
-	gamma(1/1,alpha)
+  gamma(1/1,alpha)
 
 def weibull(alpha prob, beta prob) measure(prob):
-	X <~ exponential(alpha)
-	return real2prob(X) ** (1/beta)
+  X <~ exponential(alpha)
+  return real2prob(X) ** (1/beta)
 
 def rayleigh(alpha prob) measure(prob):
-	X <~ exponential(alpha)
-	return sqrt(real2prob(X))
+  X <~ exponential(alpha)
+  return sqrt(real2prob(X))
 
 def laplace(alpha prob, beta prob) measure(real):
-	X <~ exponential(alpha)
-	Y <~ exponential(beta)
-	return X - Y
+  X <~ exponential(alpha)
+  Y <~ exponential(beta)
+  return X - Y
 
 def extremeValue(alpha prob, beta prob) measure(real):
-	X <~ weibull(alpha,beta)
-	return log(X)
+  X <~ weibull(alpha,beta)
+  return log(X)
 
 def K(alpha prob, beta prob) measure(prob):
-	X <~ exponential(1/1)
-	Y <~ gamma(alpha, alpha/beta)
-	return sqrt(X*Y)
+  X <~ exponential(1/1)
+  Y <~ gamma(alpha, alpha/beta)
+  return sqrt(X*Y)
 
 def gumbel(mu real, beta prob) measure(real):
-	X <~ exponential(1/1)
-	return mu - beta * log(X)
+  X <~ exponential(1/1)
+  return mu - beta * log(X)
 
 def exGaussian(mean real, stdev prob, scale prob) measure(real):
-	X <~ normal(mean,stdev)
-	Y <~ exponential(scale)
-	return X + Y
+  X <~ normal(mean,stdev)
+  Y <~ exponential(scale)
+  return X + Y
 
 def skewLogistic(alpha prob) measure(real):
-	X <~ exponential(alpha)
-	return log(real2prob(exp(X) - 1/1))
-	
+  X <~ exponential(alpha)
+  return log(real2prob(exp(X) - 1/1))
+  
 def hyperexponential (alpha array(prob), p array(prob)):
-	x <~ lebesgue (0,∞)
-	pdf = summate i from 1 to size(p): p[i]/alpha[i] * (exp((-x)/alpha[i]))
-	weight(real2prob(pdf), return x)
+  x <~ lebesgue (0,∞)
+  pdf = summate i from 1 to size(p): p[i]/alpha[i] * (exp((-x)/alpha[i]))
+  weight(real2prob(pdf), return x)
 
 def IDB (delta prob, kappa prob, gamma prob):
-	x <~ lebesgue(0,∞)
-	x = real2prob(x)
-	pdf = (((1 + kappa*x) * delta*x + gamma) * exp(-1 /(2 * delta * x**2))) / ((1 + kappa*x) ** (gamma / (kappa+1)))
-	weight(real2prob(pdf), return x)
-
-def hypoexponential(alpha array(prob)):
-	x<~lebesgue(0,∞)
-	x = real2prob(x)
-	pdf = summate i from 0 to (int2nat(size(alpha)-1) ): (1/alpha[i]) * exp((-x)/alpha[i]) * (product j from 0 to (int2nat(size(alpha)-1) ): if i/=j: alpha[j] / alpha[i] - alpha[j] else: 1)
-	weight(real2prob(pdf), return x)
+  x <~ lebesgue(0,∞)
+  x = real2prob(x)
+  pdf = (((1 + kappa*x) * delta*x + gamma) * exp(-1 /(2 * delta * x**2))) / ((1 + kappa*x) ** (gamma / (kappa+1)))
+  weight(real2prob(pdf), return x)
+
+def hyperexponential (alpha array(prob), p array(prob)) measure(prob):
+  if (summate i from 0 to size(p): p[i]) == 1:
+    x <~ lebesgue (0,∞)
+    x = real2prob(x)
+    pdf = summate i from 0 to size(p): p[i]/alpha[i] * (exp((-x)/alpha[i]))
+    weight(real2prob(pdf), return x)
+  else:
+    reject.measure(prob)
+
+def IDB (delta prob, kappa prob, gamma prob)measure(prob):
+  if delta>0 && kappa>0:
+    x <~ lebesgue(0,∞)
+    x = real2prob(x)
+    pdf = (((1 + kappa*x) * delta*x + gamma) * exp(-1 /(2 * delta * x**2))) / ((1 + kappa*x) ** (gamma / (kappa+1)))
+    weight(real2prob(pdf), return x)
+  else:
+    reject.measure(prob)
+

stdlib/logarithm.hk

@@ -1,7 +1,17 @@
-def logarithm(c prob):
+# Hakaru Standard Library
+# author: Aryan Sohrabi
+
+################################################
+# Logarithm Distribution and Transformations #
+################################################
+
+# The documents on parametrization can be found at: http://www.math.wm.edu/~leemis/chart/UDR/UDR.html
+
+def logarithm(c prob)measure(nat):
 	x<~counting
 	if (x>0):
-		pmf = - real2prob(1-c)**x / (x*log(c))
+		x=int2nat(x)
+		pmf = - (1-c)^x / (x*log(c))
 		weight(real2prob(pmf), return x)
 	else:
-		return nat2int(0)
+		reject.measure(nat)

stdlib/standardWald.hk

@@ -1,9 +1,20 @@
+# Hakaru Standard Library
+# author: Aryan Sohrabi
+
+################################################
+# Standard Wald Distribution and Transformations #
+################################################
+
+# The documents on parametrization can be found at: http://www.math.wm.edu/~leemis/chart/UDR/UDR.html
+
+#Inverse Gaussian Distribution
 def invGaussian(lambda prob, mu prob) measure(prob):
 	x<~lebesgue(0,∞)
 	x = real2prob(x)
 	pdf = (lambda/1*pi*x**3) ** (1/2) * exp(-((lambda*(x-mu)^2)/(2*x*mu^2)))
 	weight(real2prob(pdf), return x)
 
+#Standard Wald Distribution
 def stdWald(lambda prob) measure(prob):
 	x<~lebesgue(0,∞)
 	x = real2prob(x)

stdlib/uniformTransforms.hk

@@ -7,6 +7,9 @@
 # Uniform Transforms #
 ######################
 
+# The documents on parametrization can be found at: http://www.math.wm.edu/~leemis/chart/UDR/UDR.html
+
+
 # Pareto Distribution.
 def pareto(lambda prob, kappa prob) measure(prob):
 	X <~ uniform(0,1)
@@ -50,38 +53,37 @@ def benford() measure(prob):
 	return 10**x
 
 #generalized pareto Distribution
-def generalizedPareto (delta prob,kappa real,gamma prob):
+def generalizedPareto (delta prob,kappa real,gamma prob)measure(prob):
 	x <~ lebesgue(0,∞)
-	pdf = (gamma + kappa / real2prob(x+delta)) * (real2prob(1 + x/delta) ** (- kappa)) * real2prob(exp((- gamma) * x))
+	x = real2prob(x)
+	pdf = (gamma + kappa / (x+delta)) * ((1 + x/delta) ** (- kappa)) * exp((- gamma) * x)
 	weight(real2prob(pdf), return x)
 
 #Power Distribution
-def power(alpha prob, beta prob):
+def power(alpha prob, beta prob)measure(prob):
 	x<~lebesgue(0,alpha)
 	x = real2prob(x)
 	pdf = (beta * x**(beta-1)) / alpha**beta
 	weight(real2prob(pdf), return x)
 
 #lomax Distribution
-def lomax(lambda prob, kappa prob):
+def lomax(lambda prob, kappa prob)measure(prob):
 	x<~lebesgue(0,∞)
 	x = real2prob(x)
 	pdf = (lambda * kappa) / (1+lambda*x)**(kappa+1)
 	weight(real2prob(pdf), return x)
 
 #makeham Distribution
-def makeham(delta prob, kappa prob, gamma prob):
+def makeham(delta prob, kappa prob, gamma prob)measure(prob):
 	x<~lebesgue(0,∞)
 	x = real2prob(x)
 	pdf = (gamma+delta*kappa**x)*exp((-gamma)*x-delta*(kappa**x-1)/log(kappa))
 	weight(real2prob(pdf), return x)
 
 #minimax Distribution
-def minimax(beta prob, gamma prob):
+def minimax(beta prob, gamma prob)measure(prob):
 	x<~lebesgue(0,1)
 	x = real2prob(x)
 	pdf = beta*gamma*x**(beta-1)*real2prob(1-x**beta)**(gamma-1)
 	weight(real2prob(pdf), return x)
 
-
-benford()