Poisson-Verteilung und kumulative Poisson-Verteilung über SQLite in Python und Java

Letztes Mal Zeichnen Sie ein Diagramm der Poisson-Verteilung und der kumulativen Poisson-Verteilung in Python bzw. Java. Ich habe die in Java mit Matplotlib erstellten Daten geplottet, aber die, die die Daten mit CSV überbrückten Ich habe es mit SQlite umgeschrieben.

Die Sqlite-API verwendet den 3.6-Standard für Python und [diesen] für Java (https://bitbucket.org/xerial/sqlite-jdbc).

Der folgende Code erstellt die Tabellen Poisson und Poisson CDF in math_data.db und füllt die stochastische Masse und die kumulative Menge für jedes λ.

Java-Code

`poisson.java`




    public static void main(String[] args) {
        Connection connection = null;
        Statement statement = null;
        Calc c = new Calc();
        //Die Methode zum Speichern des λ-Werts in der Liste wurde geändert
        int[] lamList = {1, 4, 8, 10};
        try {
            double p = 0;
            Class.forName("org.sqlite.JDBC");
            connection = DriverManager.getConnection("jdbc:sqlite:math_data.db");
            statement = connection.createStatement();
            connection.setAutoCommit(false);

            //Tabelle erstellen
            statement.executeUpdate("DROP TABLE IF EXISTS Poisson");
            statement.executeUpdate("CREATE TABLE IF NOT EXISTS Poisson( lam integer, count integer , p real )");
            //Geben Sie den Wert ein
            PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO Poisson values (?, ?, ?);");
//λ Wahrscheinlichkeit, dass ein Ereignis, das in einem bestimmten Zeitraum auftritt, i-mal in einem bestimmten Zeitraum auftritt p

            for (int i = 0; i < lamList.length; i++) {

                for (int j = 0; j <= 12; j++) {
                    p = c.poisson(lamList[i], j);

                    preparedStatement.setInt(1, lamList[i]);
                    preparedStatement.setInt(2, j);
                    preparedStatement.setDouble(3, p);
                    preparedStatement.addBatch();
                }

            }
            System.out.println(preparedStatement.executeBatch().length + "Registrieren Sie die Charge.");
            connection.commit();


//Kumulative Verteilung
            statement.executeUpdate("DROP TABLE IF EXISTS PoissonCDF");
            statement.executeUpdate("CREATE TABLE IF NOT EXISTS PoissonCDF( lam integer, count integer , p real )");
            //Geben Sie den Wert ein
            preparedStatement = connection.prepareStatement("INSERT INTO PoissonCDF values (?, ?, ?);");
            //λ Kumulative Wahrscheinlichkeit, dass ein Ereignis, das in einem bestimmten Zeitraum auftritt, innerhalb eines bestimmten Zeitraums p i-mal oder weniger auftritt

            for (int i = 0; i < lamList.length; i++) {
                double pTotal = 0;
                for (int j = 0; j <= 12; j++) {
                    p = c.poisson(lamList[i], j);
                    pTotal += p;
                    preparedStatement.setInt(1, lamList[i]);
                    preparedStatement.setInt(2, j);
                    preparedStatement.setDouble(3, pTotal);
                    preparedStatement.addBatch();
                }

            }
//Batch schreiben
            System.out.println(preparedStatement.executeBatch().length + "Registrieren Sie die Charge.");
            connection.commit();


        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                if (connection != null) {
                    connection.close();
                }
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}


class Calc {

    int factorial(int n) {
        if (n == 0) {
            return 1;
        }
        return n * factorial(n - 1);
    }

    //Wahrscheinlichkeitsmassendichte, die nur k-mal auftritt, wenn das Ereignis, das in einem bestimmten Zeitraum auftritt, durchschnittlich lam ist
    double poisson(double lam, int k) {
        double total = 0;

        total = Math.pow(lam, k) * Math.pow(Math.E, -lam) / factorial(k);

        return total;
    }

    //Wahrscheinlichkeitsmassendichte (einschließlich 0), die k-mal oder weniger auftritt, wenn das Ereignis, das in einem bestimmten Zeitraum auftritt, durchschnittlich lam ist
    double poisson_cdf(double lam, int k) {
        double p = 0;
        double total = 0;
        for (int i = 0; i <= k; i++) {
            p = poisson(lam, i);
            total += p;
        }
        return total;
    }
}
//Ausführungsergebnis
//Registrieren Sie 52 Chargen.
//Registrieren Sie 52 Chargen.

Die Ausführung ist abgeschlossen. Stellen Sie sicher, dass es richtig ist.


ResultSet resultSet;
            resultSet = statement.executeQuery("select * from Poisson");
            while (resultSet.next()) {
                System.out.print(resultSet.getString("lam"));
                System.out.print(",");
                System.out.print(resultSet.getString("count"));
                System.out.print(",");
                System.out.println(resultSet.getString("p"));
            }
            resultSet = statement.executeQuery("select * from PoissonCDF");
            while (resultSet.next()) {
                System.out.print(resultSet.getString("lam"));
                System.out.print(",");
                System.out.print(resultSet.getString("count"));
                System.out.print(",");
                System.out.println(resultSet.getString("p"));
            }

            /*
Ausführungsergebnis

            1,0,0.367879441171442
            1,1,0.367879441171442
            1,2,0.183939720585721
            1,3,0.0613132401952404
            1,4,0.0153283100488101
             */

Es ist fest darin. Als nächstes möchte ich es in Python laden und in Matplotlib zeichnen.

Python-Code

`plotting.py`


import sqlite3
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

sns.set(style="darkgrid")

conn = sqlite3.connect("math_data.db")
c = conn.cursor()
c.execute('SELECT * FROM Poisson')

#Aufführen
lam_db_list = np.array(c.fetchall())
#Da der numerische Wert am Zeilenanfang λ ist, werde ich ihn vorerst zusammenfassen und für jedes λ grafisch darstellen
lam_db_f = sorted(list(set(map(lambda x: x[0], lam_db_list))))

fig, axe = plt.subplots(1, 2, constrained_layout=True, figsize=(12, 5))

#Erstellen Sie am Anfang der Linie eine Liste für jeden Typ von λ-Zahlen und zeichnen Sie darauf basierend.
for i in range(len(lam_db_f)):
    y_axis = []
    for j in lam_db_list:
        if j[0:1] == lam_db_f[i]:
            y_axis.append(j[2:])

    y_axis = np.array(y_axis).reshape(-1)
    x_axis = range(len(y_axis))
    axe[0].plot(x_axis, y_axis, marker='o', label='$\lambda=%.2f$' % lam_db_f[i])

c.execute('SELECT * FROM PoissonCDF')
lam_db_list = np.array(c.fetchall())
lam_db_f = sorted(list(set(map(lambda x: x[0], lam_db_list))))

for i in range(len(lam_db_f)):
    y_axis = [j[2:] for j in lam_db_list if j[0:1] == lam_db_f[i]]
    y_axis = np.array(y_axis).reshape(-1)
    x_axis = range(len(y_axis))
    axe[1].plot(x_axis, y_axis, marker='o', label='$\lambda=%.2f$' % lam_db_f[i])

conn.close()
axe[0].set_xlabel('k')
axe[0].set_ylabel('probability')
axe[0].set_title('Poisson')
axe[0].legend()
axe[0].grid(True)
axe[0].set_xticks(range(len(x_axis)))
axe[1].set_xlabel('k')
axe[1].set_ylabel('probability')
axe[1].set_title('PoissonCDF')
axe[1].legend()
axe[1].grid(True)
axe[1].set_xticks(range(len(x_axis)))

plt.savefig("poisson_n_cdf.png ")
plt.show()

Ich konnte es ordentlich zeichnen. Sie können auch verschiedene Poisson-Verteilungen zeichnen, indem Sie das auf der Java-Seite übergebene λ-Array ändern.

Schwierigkeiten

Ich habe die DB-Erstellung in umgekehrter Matrix erstellt und versucht, alle Arrays durch Runden aus der ersten Zeilennummer zu berechnen, aber der Code wurde kompliziert. Um die spätere Verwendung zu vereinfachen, müssen wir bei der Erstellung der Datenbank über die Ausgabe nachdenken. Besonders wenn sich die Daten mit einer kleinen Anzahl von unbeweglichen Punkten befassen, werden sie verrückt, deshalb möchte ich vermeiden, dass ich später zu viel mit der Struktur spielen muss.