- fixed: Bessel functions

strike65 · Oct 4, 2018 · 148ed86 · 148ed86
1 parent 9f974d3
commit 148ed86
Show file tree

Hide file tree

Showing 10 changed files with 1,373 additions and 654 deletions.
diff --git a/CHANGELOG b/CHANGELOG
@@ -1,3 +1,7 @@
+Version 1.0.1
+- fixed: BesselI1
+
+
 Version 1.0.0
 - needed: Swift 4.2
 - added: SSFloatingPoint protocol (constants)

diff --git a/Mathematica/ExpAbscissas.nb b/Mathematica/ExpAbscissas.nb
diff --git a/Package.swift b/Package.swift
@@ -54,4 +54,4 @@ let package = Package(
     swiftLanguageVersions: [4]
 )
 
-let version = Version("1.0.0")
+let version = Version("1.0.1")
diff --git a/SwiftyStats.podspec b/SwiftyStats.podspec
@@ -1,6 +1,6 @@
 Pod::Spec.new do |s|
 	s.name 		= 'SwiftyStats'
-	s.version 	= '1.0.0'
+	s.version 	= '1.0.1'
 	s.summary 	= 'Descriptive Statistics, Probability Functions (PDF, CDF, iCDF), parametric and nonparametric tests'
 	s.description 	= <<-DESC
 Includes (list is not exhaustive):

diff --git a/SwiftyStats/CommonSource/Shared/Math/SSMath-GenericFP.swift b/SwiftyStats/CommonSource/Shared/Math/SSMath-GenericFP.swift
@@ -100,6 +100,21 @@ internal func log21<T: SSFloatingPoint>(_ x: T) -> T {
     }
 }
 
+internal func log101<T: SSFloatingPoint>(_ x: T) -> T {
+    switch x {
+    case let d as Double:
+        return log10(d) as Double as! T
+    case let f as Float:
+        return log10f(f) as Float as! T
+        #if arch(x86_64)
+    case let f80 as Float80:
+        return log10l(f80) as Float80 as! T
+        #endif
+    default:
+        return T.nan
+    }
+}
+
 
 
 internal func log1p1<T: SSFloatingPoint>(_ x: T) -> T {
@@ -508,3 +523,76 @@ internal func matMul<FPT: SSFloatingPoint>(a: Array<FPT>, aCols: Int, aRows: Int
 }
 
 
+/// Binomial
+internal func binomial2<FPT: SSFloatingPoint>(_ n: FPT, _ k: FPT) -> FPT {
+    var ans: UInt64 = 1
+    var kk: UInt64 = integerValue(k)
+    var nn: UInt64 = integerValue(n)
+    var overflow: Bool = false
+    var ex1: (UInt64, Bool) = (0, false)
+    var ex2: (UInt64, Bool) = (0, false)
+    kk = k > n - k ? nn - kk : kk
+    for j: UInt64 in stride(from: 1, through: kk, by: 1) {
+        if nn % j == 0 {
+            ex1 = nn.dividedReportingOverflow(by: j)
+            if ex1.1 {
+                overflow = true
+                break
+            }
+            ex2 = ans.multipliedReportingOverflow(by: ex1.0)
+            if ex2.1 {
+                overflow = true
+                break
+            }
+            ans = ex2.0
+        }
+        else {
+            if ans % j == 0 {
+                ex1 = ans.dividedReportingOverflow(by: j)
+                if ex1.1 {
+                    overflow = true
+                    break
+                }
+                ans = ex1.0
+                ex2 = ans.multipliedReportingOverflow(by: nn)
+                if ex2.1 {
+                    overflow = true
+                    break
+                }
+                ans = ex2.0
+            }
+            else {
+                ex1 = ans.multipliedReportingOverflow(by: nn)
+                if ex1.1 {
+                    overflow = true
+                    break
+                }
+                ans = ex1.0
+                ex2 = ans.dividedReportingOverflow(by: j)
+                if ex2.1 {
+                    overflow = true
+                    break
+                }
+                ans = ex2.0
+            }
+        }
+        nn = nn - 1
+    }
+    if !overflow {
+        return makeFP(ans)
+    }
+    else {
+        let num: FPT = lgamma1(makeFP(n) + 1)
+        let den: FPT = lgamma1(makeFP(n - k + 1)) + lgamma1(makeFP(k + 1))
+        let q: FPT = num - den
+        return exp1(q).rounded(FloatingPointRoundingRule.toNearestOrAwayFromZero)
+
+    }
+}
+
+    /// Returns the logarithm of n!
+internal func logFactorial<FPT: SSFloatingPoint & Codable>(_ n: Int) -> FPT {
+        return lgamma1(makeFP(n + 1))
+}
+
+
diff --git a/SwiftyStats/CommonSource/Shared/Math/SSUtils.swift b/SwiftyStats/CommonSource/Shared/Math/SSUtils.swift
@@ -27,79 +27,6 @@ import Foundation
 
 
 
-/// Binomial
-internal func binomial2<FPT: SSFloatingPoint>(_ n: FPT, _ k: FPT) -> FPT {
-    var ans: UInt64 = 1
-    var kk: UInt64 = integerValue(k)
-    var nn: UInt64 = integerValue(n)
-    var overflow: Bool = false
-    var ex1: (UInt64, Bool) = (0, false)
-    var ex2: (UInt64, Bool) = (0, false)
-    kk = k > n - k ? nn - kk : kk
-    for j: UInt64 in stride(from: 1, through: kk, by: 1) {
-        if nn % j == 0 {
-            ex1 = nn.dividedReportingOverflow(by: j)
-            if ex1.1 {
-                overflow = true
-                break
-            }
-            ex2 = ans.multipliedReportingOverflow(by: ex1.0)
-            if ex2.1 {
-                overflow = true
-                break
-            }
-            ans = ex2.0
-        }
-        else {
-            if ans % j == 0 {
-                ex1 = ans.dividedReportingOverflow(by: j)
-                if ex1.1 {
-                    overflow = true
-                    break
-                }
-                ans = ex1.0
-                ex2 = ans.multipliedReportingOverflow(by: nn)
-                if ex2.1 {
-                    overflow = true
-                    break
-                }
-                ans = ex2.0
-            }
-            else {
-                ex1 = ans.multipliedReportingOverflow(by: nn)
-                if ex1.1 {
-                    overflow = true
-                    break
-                }
-                ans = ex1.0
-                ex2 = ans.dividedReportingOverflow(by: j)
-                if ex2.1 {
-                    overflow = true
-                    break
-                }
-                ans = ex2.0
-            }
-        }
-        nn = nn - 1
-    }
-    if !overflow {
-        return makeFP(ans)
-    }
-    else {
-        let num: FPT = lgamma1(makeFP(n) + 1)
-        let den: FPT = lgamma1(makeFP(n - k + 1)) + lgamma1(makeFP(k + 1))
-        let q: FPT = num - den
-        return exp1(q).rounded(FloatingPointRoundingRule.toNearestOrAwayFromZero)
-    }
-
-//    if k == 0 {
-//        return 1
-//    }
-//    let num: FPT = lgamma1(n + 1)
-//    let den: FPT = lgamma1(n - k + 1) + lgamma1(k + 1)
-//    let q: FPT = num - den
-//    return exp1(q)
-}
 
 
 /// Tests, if a value is integer.
@@ -512,12 +439,6 @@ internal func minimum<T>(_ t1: T, _ t2: T) -> T where T:Comparable {
     }
 }
 
-/// Returns the logarithm of n!
-internal func logFactorial<FPT: SSFloatingPoint & Codable>(_ n: Int) -> FPT {
-        return lgamma1(makeFP(n + 1))
-}
-
-
 /// Returns a SSExamine object of length one and count "count"
 /// - Parameter value: Value
 /// - Parameter count: Number of values