6 posts tagged “java”

Splash Screen

package org.jmy.views.components;

import java.awt.BorderLayout;

import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JProgressBar;
import javax.swing.JWindow;

import org.firmed.views.util.ViewUtil;

public class JSplash extends JWindow {
    private static final long serialVersionUID = 8644899390279522763L;

    public JSplash(ImageIcon icon) {
    super();

    JLabel label = new JLabel(icon);
    JProgressBar bar = new JProgressBar();
    bar.setIndeterminate(true);
    
    getContentPane().add(label, BorderLayout.CENTER);
    getContentPane().add(bar, BorderLayout.SOUTH);

    pack();

    ViewUtil.centerFrameOnScreen(this);
    }

}

package org.jmy.views.components;

import java.awt.Container;
import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.GraphicsEnvironment;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Window;
import java.lang.reflect.Method;

public class ViewUtil {
    private ViewUtil() {
    }

    public static Point getCenterPoint() {
    final GraphicsEnvironment localGraphicsEnvironment = GraphicsEnvironment
        .getLocalGraphicsEnvironment();
    try {
        final Method method = GraphicsEnvironment.class.getMethod(
            "getCenterPoint", (Class[]) null);
        return (Point) method.invoke(localGraphicsEnvironment,
            (Object[]) null);
    } catch (Exception e) {
    }

    final Dimension s = Toolkit.getDefaultToolkit().getScreenSize();
    return new Point(s.width / 2, s.height / 2);
    }

    public static Rectangle getMaximumWindowBounds() {
    final GraphicsEnvironment localGraphicsEnvironment = GraphicsEnvironment
        .getLocalGraphicsEnvironment();
    try {
        final Method method = GraphicsEnvironment.class.getMethod(
            "getMaximumWindowBounds", (Class[]) null);
        return (Rectangle) method.invoke(localGraphicsEnvironment,
            (Object[]) null);
    } catch (Exception e) {

    }

    final Dimension s = Toolkit.getDefaultToolkit().getScreenSize();
    return new Rectangle(0, 0, s.width, s.height);
    }

    public static void centerFrameOnScreen(final Window frame) {
    positionFrameOnScreen(frame, 0.5, 0.5);
    }

    public static void positionFrameOnScreen(final Window frame,
        final double horizontalPercent, final double verticalPercent) {

    final Rectangle s = getMaximumWindowBounds();
    final Dimension f = frame.getSize();
    final int w = Math.max(s.width - f.width, 0);
    final int h = Math.max(s.height - f.height, 0);
    final int x = (int) (horizontalPercent * w) + s.x;
    final int y = (int) (verticalPercent * h) + s.y;
    frame.setBounds(x, y, f.width, f.height);

    }

    public static void positionFrameRandomly(final Window frame) {
    positionFrameOnScreen(frame, Math.random(), Math.random());
    }

    public static void centerDialogInParent(final Dialog dialog) {
    positionDialogRelativeToParent(dialog, 0.5, 0.5);
    }

    public static void positionDialogRelativeToParent(final Dialog dialog,
        final double horizontalPercent, final double verticalPercent) {
    final Dimension d = dialog.getSize();
    final Container parent = dialog.getParent();
    final Dimension p = parent.getSize();

    final int baseX = parent.getX() - d.width;
    final int baseY = parent.getY() - d.height;
    final int w = d.width + p.width;
    final int h = d.height + p.height;
    int x = baseX + (int) (horizontalPercent * w);
    int y = baseY + (int) (verticalPercent * h);

    final Rectangle s = getMaximumWindowBounds();
    x = Math.min(x, (s.width - d.width));
    x = Math.max(x, 0);
    y = Math.min(y, (s.height - d.height));
    y = Math.max(y, 0);

    dialog.setBounds(x + s.x, y + s.y, d.width, d.height);

    }

}

Este es un programa para ajustar distribuciones continuas y discretes a funciones de probabilidades, además genera números aleatorios para 14 distribuciones teóricas con sus respectivos gráficos.

Aquí unas imágenes:

Otros programas para ajustes de curvas son BestFit, EasyFit y StatFit pero no son gratuitos.

Este post es para los que han tratado de implementar algunos de los mejores generadores de números aleatorios, generalmente es una tarea en la materia de simulación.

Primero pueden pasar por esta lista de los mejores generadores. Ahora elijan un generador.

Apple random number generator

Defining the LCD parameters.

n = 2^35 = 34359738368;
a = 5^13 = 1220703125;
b = 0;
x0 = 111;

For1

Como se ve en la fórmula se multiplica A por X0 para obtener el X1, luego A por X1 y así sucesivamente.
El problema se presenta cuando el X0 se hace demasiado grande y supera al Long.MAX de modo que no se puede confiar en los resultados que se obtienen. La solución podría el uso del BigInt en Python o BigInteger en Java, pero esto es algo innecesario y limita la solución del problema al uso de estos lenguajes.

La solución que planteo es la siguiente:

    private AtomicLong raiz;
    private long multipli;
    private long modulo;
    private final static long DIV = 7000000000L;

    public Apple() {
        this.raiz = new AtomicLong(111);
        this.multipli = 1220703125;
        this.modulo = 34359738368;
    }

    public long nextLong() {
        if (raiz.get() > DIV) {
            raiz.set( ( ( ( (DIV * multipli) % modulo) * (raiz.get() / DIV) )
                       + ( ( (raiz.get() % DIV) * multipli) % modulo) ) % modulo );
          }
          else {
            raiz.set( (multipli * raiz.get() ) % modulo);
          }
          return raiz.get();
    }

El valor de DIV se obtiene dividiendo el Long.MAX (2^63~) sobre el valor de multipli.
El método nextLong() verifica que el valor de Xn no sea mayor que DIV, de esta manera se evita que se sobrepase el valor máximo del tipo long. Luego se obtiene el nuevo valor de la raíz con una transformación matemática de la fórmula.

Y finalmente aquí está un programa en Java que somete a los generadores a 7 pruebas estadísticas de aleatoriedad: