2014-04-08 4 views
16

Ich bin auf der Suche nach einer Java-Bibliothek, die generalisierte hypergeometrische Funktion (http://en.wikipedia.org/wiki/Generalized_hypergeometric_series) berechnen kann. Ich schaute auf Apach Common Math, fand aber die Funktion nicht. Eigentlich brauche ich die Funktion, um die kumulative Wahrscheinlichkeitsfunktion für die beta-Binomialverteilung zu berechnen (http://en.wikipedia.org/wiki/Beta-binomial_distribution). Wenn jemand ein Java-Paket einschließlich der Distribution kennt, wäre es gut für mich.java Generalisierte Hypergeometrische Funktion

Danke,

Antwort

1

Sie dieses org.apache.commons.math3.distribution.HypergeometricDistribution von here verwenden können.

Download link.

+0

Danke für die Antwort. Ich habe mich in dem Thema geirrt. Es sollte eine generalisierte hypergeometrische Funktion anstelle einer verallgemeinerten hypergeometrischen Verteilung sein. Das tut mir leid. – longread

0

auf dem Wiki-Artikel aus, dass Sie auf dem Laufenden, ich glaube, Sie die Werte der hypergeometric Funktion mit diesem Code annähern kann, die ich schrieb:

Als nächster Schritt kann es möglich sein, den Fehler des abzuschätzen Annäherung.

/** 
* The generalized hypergeometric function is a convergent power series \sum_{i=0}^{\infty} c_i x^i 
* where the coefficients satisfy c_{n+1}/c_n = A(n)/B(n) for some polynomials A and B in n. 
* It is customary to factor out the leading term, so c_0 is assumed to be 1 
*/ 

public class HypergeometricFunction { 
    private final int degreeOfApproximation; 
    private final double[] coefficientsOfA; 
    private final double[] coefficientsOfB; 
    private final double[] coefficientsOfHypergeometricFunction; 

    public HypergeometricFunction(int degreeOfApproximation, double[] coefficientsOfA, double[] coefficientsOfB) { 
     this.degreeOfApproximation = degreeOfApproximation; 
     this.coefficientsOfA = coefficientsOfA; 
     this.coefficientsOfB = coefficientsOfB; 
     this.coefficientsOfHypergeometricFunction = generateCoefficients(); 
    } 

    /** 
    * @param x input 
    * @return Approximation to the hypergeometric function by taking the first 
    * {@code degreeOfApproximation} terms from the series. 
    */ 
    public double approximate(double x){ 
     return evaluatePolynomial(x, coefficientsOfHypergeometricFunction); 
    } 


    private double[] generateCoefficients() { 
     double[] coefficients = new double[degreeOfApproximation]; 
     coefficients[0] = 1; 
     for (int i = 1; i < degreeOfApproximation; i++) 
      coefficients[i] = (evaluatePolynomial(i, coefficientsOfA)/evaluatePolynomial(i, coefficientsOfB)) * coefficients[i - 1]; 
     return coefficients; 
    } 

    private double evaluatePolynomial(double n, double[] coefficients) { 
     int length = coefficients.length; 
     double out = 0.0D; 
     for (int i = 0; i < length; i++) { 
      out += coefficients[i] * pow(n, i); 
     } 
     return out; 
    } 

    private double pow(double a, int b) { 
     double out = 1; 
     for (int i = 0; i < b; i++) out *= a; 
     return out; 
    } 

} 

Wenn die Serie konvergiert (und damit eine ordnungsgemäße hypergeometric Funktion bereitstellt), seine lim[c_i*x^i] dann muss Null, so dass dies eine vernünftige Annäherung liefern sollte, wenn Sie degreeOfApproximation nehmen groß genug zu sein.

Die Polynome A und B sind diejenigen, auf die im Wiki-Artikel Bezug genommen wird, und um diesen Code zu verwenden, müssen Sie Koeffizienten für diese Polynome dem Konstruktor zusammen mit dem gewünschten Grad der Approximation bereitstellen.

Hoffe, das hilft Ihnen aus.

+0

Das Problem mit solchen "naiven" Annäherungen ist, dass sie nicht getestet wurden und somit die Fehlergrenzen unbekannt sind. Diese hängen oft von den spezifischen Werten ab, mit denen die Funktion evaluiert wird, und benötigen daher einige interne "Smart", um genügend Begriffe zur Konvergenz zu nehmen. Auch diese Art der Auswertung großer Polynome neigt dazu, numerisch instabil zu sein .... Deshalb suchte auch ich nach einem Paket, das das tut ... Danke! –

+0

Haben Sie komplexe Koeffizienten? Wenn dem so ist, dann sollte es in einer anderen Frage sein, weil es sich hier um das Beta-Binom handelt.Im realen Fall ist die Funktion auf einem Konvergenzradius kontinuierlich differenzierbar (siehe Wiki). Es gibt also eine Taylor-Reihe für die Funktion, die mit derjenigen übereinstimmt, die Sie approximieren würden, und Taylors Restsatz gibt tatsächlich eine Grenze für den Fehler. Wo hast du gelesen, dass das Abschneiden einer konvergenten Potenzreihe eine naive Approximation genannt wird? Das ist kein echter Begriff. – Blake

0

Es gibt eine GNU Scientific Library Implementierung hypergeometric functions und many random number distributions - leider ist es eine C-Bibliothek.

Zum Glück gibt es eine JavaCPP Preset available, die bedeutet, dass Sie es von Java verwenden können leicht (es bündelt nativen gcl Bibliothek für Windows/Linux/Android innen).

Die example hat bei mir nicht funktioniert (es Version 2.4-1.3.4-SNAPSHOT der Bibliothek verwendet), aber wenn Version 2.2.1-1.3 verwenden geändert (die auf Maven von zentraler Bedeutung ist) es einwandfrei funktioniert.

Mein pom.xml ist:

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> 
    <modelVersion>4.0.0</modelVersion> 
    <groupId>test</groupId> 
    <artifactId>test-gsl-java</artifactId> 
    <version>0.0.1-SNAPSHOT</version> 
    <properties> 
     <exec.mainClass>Example</exec.mainClass> 
    </properties> 
    <dependencies> 
     <dependency> 
      <groupId>org.bytedeco.javacpp-presets</groupId> 
      <artifactId>gsl-platform</artifactId> 
      <version>2.2.1-1.3</version> 
     </dependency> 
    </dependencies> 
</project> 

Disclaimer: Ich bin kein Mathematiker also bitte meine Gedanken validiere.

Viel Glück!