Desde Netbeans en modo diseño se añaden los componentes siguiendo esta estructura:
-----------------------------------------------------------------
. JFrame (title: "Graficando perceptrón")
. jPanel1 (aqui se graficará la red neuronal)
. jToolBar1 (barra de opciones)
. jLabel1 (texto: "Estructura")
. jTextField1 (texto: "2,4,4,1")
. jButton1 (texto: "Graficar")
. jButton2 (texto: "Limpiar")
-----------------------------------------------------------------
Código 1 (Muro.java):
package centrar;
public class Muro extends javax.swing.JFrame {
public Muro() {
initComponents();
this.setLocationRelativeTo(null);
}
private void initComponents() { ... } // <- código generado automáticament por Netbeans
private void jButtonGraficarActionPerformed(java.awt.event.ActionEvent evt) {
Dibujar t = new Dibujar(jPanel1.getGraphics(), jPanel1.getWidth(), jPanel1.getHeight(), jTextField1.getText());
}
private void jButtonLimpiarActionPerformed(java.awt.event.ActionEvent evt) {
this.jPanel1.repaint();
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Muro().setVisible(true);
}
});
}
private javax.swing.JButton jButtonGraficar;
private javax.swing.JButton jButtonLimpiar;
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JToolBar.Separator jSeparator1;
private javax.swing.JToolBar.Separator jSeparator2;
private javax.swing.JTextField jTextField1;
private javax.swing.JToolBar jToolBar1;
}
Código 2 (Dibujar.java):
package centrar;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.Stroke;
import java.util.ArrayList;
import java.util.List;
public class Dibujar {
Graphics g;
Graphics2D g2;
public Dibujar(Graphics g, int width, int height, String estruct) {
g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(Color.BLACK);
// tipos grosores pinceles
Stroke stroke02 = new BasicStroke(0.2f);
Stroke stroke04 = new BasicStroke(0.4f);
g2.setStroke(stroke02);
// añadir datos estructura perceptrón
List<Integer> estructura = new ArrayList<>();
for (String aux1 : estruct.split(",")) {
estructura.add(Integer.parseInt(aux1));
}
int maxX = estructura.size();
int maxY = maximo(estructura);
int nParticionesX = maxX + 2; // se suma 2 para margen superior e inferior
int nParticionesY = maxY + 2; // se suma 2 para margen superior e inferior
int uX = width / nParticionesX;
int uY = height / nParticionesY;
float uSeparadorX = (nParticionesX - estructura.size()) / 2f;
float uSeparadorY;
int posIniX = (int) Math.round(uX * uSeparadorX);
int posIniY;
int[][][] recopilador = new int[maxX][maxY][2]; // k, x, y
// capa 0: pre-logical posiciones
for (int x = 0; x < estructura.size(); x++) {
for (int y = 0; y < estructura.get(x); y++) {
uSeparadorY = (nParticionesY - estructura.get(x)) / 2f;
posIniY = (int) Math.round(uY * uSeparadorY);
recopilador[x][y][0] = (posIniX + (int) uX * x) + (int) (uX / 2);
recopilador[x][y][1] = (posIniY + (int) uY * y) + (int) (uY / 2);
}
}
// capa 1: graficar neuronas
int radio = (int) Math.round(uY / 2f);
for (int x = 0; x < estructura.size(); x++) {
for (int y = 0; y < estructura.get(x); y++) {
centrarCirculo(g2, recopilador[x][y][0], recopilador[x][y][1], radio);
}
}
// capa 2: graficar enlaces
int x1, y1, x2, y2;
g2.setColor(Color.DARK_GRAY);
g2.setStroke(stroke04);
for (int x = 0; x < estructura.size() - 1; x++) {
for (int y = 0; y < estructura.get(x); y++) {
for (int k = 0; k < estructura.get(x + 1); k++) {
x1 = recopilador[x][y][0];
y1 = recopilador[x][y][1];
x2 = recopilador[x + 1][k][0];
y2 = recopilador[x + 1][k][1];
g2.drawLine(x1, y1, x2, y2);
}
}
}
}
private void centrarCirculo(Graphics g2, int x, int y, int r) {
x = x - (r / 2);
y = y - (r / 2);
g2.fillOval(x, y, r, r);
}
/* Busca número mayor del listado de la estructura
* Utilizado para acomodar la gráfica al tamaño de la ventana
*/
private int maximo(List<Integer> estructura) {
int max = 0;
for (int i = 0; i < estructura.size(); i++) {
if (estructura.get(i) >= max) {
max = estructura.get(i);
}
}
return max;
}
}
Resultado:
Desde Netbeans y en modo diseño se agrega un jFrame con la opción marcada "Grid Layout" y en propiedades activamos el check [v] undecorated. Se añade luego un jPanel que servirá de lienzo para graficar el tablero.
Para las figuras he instalado una fuente gratuita llamada "Chess Cases".
Código1 (Tabla.java):
package ajedrez;
public class Tabla extends javax.swing.JFrame {
public Tabla() {
initComponents();
this.setBounds(0, 0, 512, 512);
this.setLocationRelativeTo(null);
this.jPanel1.setBounds(0, 0, 512, 512);
this.jPanel1.setBackground(new java.awt.Color(190, 190, 190));
}
private void initComponents() { ... } // Código generado automáticamente por Netbeans.
private void jPanel1MouseClicked(java.awt.event.MouseEvent evt) {
Dibujar t = new Dibujar(jPanel1.getGraphics(), this.jPanel1.getWidth());
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Tabla().setVisible(true);
}
});
}
private javax.swing.JPanel jPanel1;
}
Código2 (Dibujar.java):
package ajedrez;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Stroke;
public class Dibujar {
Rectangle rect = new Rectangle();
public Dibujar(Graphics g, int xy) {
Graphics2D g2 = (Graphics2D) g;
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
g2.setColor(Color.GRAY);
// Crea tablero
int casillas = 8;
int radio = xy / casillas;
for (int j = 0; j < casillas; j++) {
for (int i = 0; i < casillas; i++) {
if ((j % 2) != 0) {
g2.fillRect(2 * radio * i, radio * j, radio, radio);
}
if ((i % 2 != 0)) {
g2.fillRect(radio * i, 2 * radio * j, radio, radio);
}
}
}
// Remarcar contorno
Stroke pincel = new BasicStroke(2f);
g2.setColor(Color.BLACK);
g2.setStroke(pincel);
g2.drawRect(0, 0, xy - 1, xy - 1);
// Piezas
Font font = new Font("Chess Cases", Font.TRUETYPE_FONT, 46);
String piezas = "tmvwlvmt";
for (int i = 0; i < casillas; i++) {
// Inserción piezas negras
g.setColor(Color.BLACK);
rect.setBounds(radio * i, 0, radio, radio);
centrarTexto(g, piezas.charAt(i) + "", rect, font);
rect.setBounds(radio * i, radio, radio, radio);
centrarTexto(g, "o", rect, font);
// Inserción piezas blancas
g.setColor(Color.WHITE);
rect.setBounds(radio * i, radio * 7, radio, radio);
centrarTexto(g, piezas.charAt(i) + "", rect, font);
rect.setBounds(radio * i, radio * 6, radio, radio);
centrarTexto(g, "o", rect, font);
}
}
private void centrarTexto(Graphics g, String texto, Rectangle r, Font f) {
FontMetrics medir = g.getFontMetrics(f);
int x = r.x + (r.width - medir.stringWidth(texto)) / 2;
int y = r.y + ((r.height - medir.getHeight()) / 2) + medir.getAscent();
g.setFont(f);
g.drawString(texto, x, y);
}
}
Resultado:
Desde Netbeans y en modo diseño se agrega un jFrame con la opción marcada "Grid Layout" y en propiedades activamos el check [v] undecorated. Se añade luego un jPanel, que servirá de lienzo para graficar. Algoritmo claramente mejorable de ahí que lo he puesto versión beta.
Código1 (Muro.java):
package pasapalabra;
public class Muro extends javax.swing.JFrame {
public Muro() {
initComponents();
this.setBounds(0, 0, 512, 512);
this.jPanel1.setBounds(0, 0, 512, 512);
this.setLocationRelativeTo(null);
this.repaint();
}
private void initComponents() { ... }// Código generado automáticamente por Netbeans
private void jPanel1MouseClicked(java.awt.event.MouseEvent evt) {
double grados = 0;
Dibujar t = new Dibujar(jPanel1.getGraphics(), this.jPanel1.getWidth() / 2, this.jPanel1.getHeight() / 2, grados);
Instrucciones(t);
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(() -> {
new Muro().setVisible(true);
});
}
private javax.swing.JPanel jPanel1;
// Instrucciones tipo tortuga que dibuja
private void Instrucciones(Dibujar t) {
int n = 25;
String letras = "GFEDCBAZYXVUTSRQPOÑNMLJIH";
double x0, y0, r, grado;
r = jPanel1.getWidth() / 2.5f;
x0 = jPanel1.getWidth() / 2;
y0 = jPanel1.getHeight() / 2;
// Ángulo en radianes (importante)
grado = (2 * Math.PI) / n;
// Dibuja rosco pasapalabra
t.gira(0);
for (int i = 0; i < n; i++) {
t.avanza(r);
t.figura(letras.charAt(i));
t.salta(x0, y0);
t.gira(grado);
}
}
}
Código2 (Dibujar.java):
package pasapalabra;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.RenderingHints;
public class Dibujar {
double x, y, angulo;
Graphics g;
Graphics2D g2;
Rectangle rect = new Rectangle();
public Dibujar(Graphics g, double x, double y, double angulo) {
this.x = x;
this.y = y;
this.angulo = angulo;
this.g = g;
g2 = (Graphics2D) g;
// Filtro "antialiasing"
g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
}
public void gira(double angulo) {
this.angulo += angulo;
}
public void figura(char letra) {
int r = 45; // Radio
double x2 = x - (r / 2);
double y2 = y - (r / 2);
g.setColor(Color.BLUE);
g.fillOval((int) x2, (int) y2, r, r);
g.setColor(Color.WHITE);
rect.setBounds((int) x2, (int) y2, r, r);
centrarTexto(g, "" + letra, rect, new Font("", Font.BOLD, 26));
}
public void avanza(double distancia) {
double x2 = x + distancia * Math.cos(angulo);
double y2 = y - distancia * Math.sin(angulo);
salta(x2, y2);
}
public void salta(double x, double y) {
this.x = x;
this.y = y;
}
private void centrarTexto(Graphics g, String texto, Rectangle r, Font f) {
FontMetrics medir = g.getFontMetrics(f);
int x = r.x + (r.width - medir.stringWidth(texto)) / 2;
int y = r.y + ((r.height - medir.getHeight()) / 2) + medir.getAscent();
g.setFont(f);
g.drawString(texto, x, y);
}
}
Resultado:
Desde Netbeans y en modo diseño se agrega un jFrame con la opción marcada "Grid Layout". Se añade luego un jPanel, que servirá de lienzo para graficar. Algoritmo claramente mejorable de ahí que lo he puesto versión beta.
Código1 (Muro.java):
package triangulopascal_2d;
public class Muro extends javax.swing.JFrame {
public Muro() {
this.setUndecorated(true);
initComponents();
this.setBounds(0, 0, 513, 513);
this.jPanel1.setBounds(0, 0, 512, 512);
this.setLocationRelativeTo(null); // Centrar pantalla
this.repaint();
}
private void initComponents() { ... }
private void formMouseClicked(java.awt.event.MouseEvent evt) {
TrianguloPascal.Dibujar(jPanel1.getGraphics(), this.jPanel1.getWidth());
}
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Muro().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JPanel jPanel1;
// End of variables declaration
}
Código2 (TrianguloPascal.java):
package triangulopascal_2d;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
public class TrianguloPascal {
public static void Dibujar(Graphics g, float xy) {
Graphics2D g2 = (Graphics2D) g;
// Inicialización variables
int u = (int) xy / 32;
int a = 1, b = 29, c = 29;
int[] d1 = triangulo();
int indice = 118;
// Dibuja pirámide de bloques
while (a <= b) {
for (int i = a; i <= b; i = i + 2) {
g2.setColor(Color.BLUE);
g.fillRect(i * u + 1, c * u + 1, 2 * u - 1, 2 * u - 1);
g2.setColor(Color.WHITE);
if (indice >= 0) {
g.drawString(String.format("%1$5s", d1[indice]), i * u, c * u + 20);
} else {
g.drawString(String.format("%1$5s", d1[0]), i * u, c * u + 20);
}
indice--;
}
a++;
b--;
c = c - 2;
}
}
private static int[] triangulo() {
int[] d1 = new int[119];
int[][] d2 = new int[16][16];
d2[1][1] = 1;
int indice = 0;
for (int j = 2; j < 16; j++) {
for (int i = 1; i < 16; i++) {
d2[j][i] = d2[j - 1][i - 1] + d2[j - 1][i];
if (d2[j][i] != 0) {
d1[indice] = d2[j][i];
indice++;
}
}
}
d1[0] = 1;
return d1;
}
}
Resultado:
Tríptico #7: Comandos de empaquetado:
En este apartado mostraremos como se realiza el empaquetado de la aplicación "MiPrograma" #1
public class MiPrograma {
public static void main(String arg[]) {
System.out.println("Mi primer programa");
}
}
00- Desde símbolo del sistema verificar que el aplicativo ya ha sido compilado:
c:\proyecto> dir [enter]
18/11/2018 21:59 <DIR> .
18/11/2018 21:59 <DIR> ..
10/11/2018 17:38 598 MiPrograma.class
10/11/2018 17:38 598 MiPrograma.java
2 archivos 1.196 bytes
c:\proyecto> _
01-
Desde bloc de notas crear el fichero MANIFEST.MF y añadir las
siguientes lineas [según los datos de la aplicación (versión, creador,
clase principal, comentario)]:
Manifest-Version: 1.0
Created-By: Yo mismo
Main-Class: MiPrograma
X-COMMENT: Prueba de empaquetado
02- Guardar dentro la carpeta del proyecto.
03- Acceder al símbolo del sistema (cmd.exe):
Accedemos a la carpeta del proyecto:
> cd c:\proyecto [enter]
c:\proyecto> _
04- Generar fichero ejecutable a partir de la clase:
jar cvfm MiPrograma.jar manifest.mf MiPrograma.class [enter]
05- Ejecutar fichero .jar en linea de comandos:
java -jar Miprograma.jar [enter]
Mi primer programa
> _
Tríptico #6: Bucles (for, while, do-while)
00- Nomenclatura sentencia for:
for (inicio; termino; iteracion) {
sentencia_1;
sentencia_2;
sentencia_n;
}
Ejemplo:
// Contador del 0 al 9
public class MiPrograma_Bucles1 {
public static void main(String arg[]) {
for (int i = 0 ; i < 10; i++) {
System.out.println(i);
}
}
}
01- Nomenclatura sentencia while:
while (expresionLogica) {
sentencias;
}
Ejemplo:
// Contador del 0 al 9
public class MiPrograma_Bucles2 {
public static void main(String arg[]) {
byte a = 0, z = 10;
while (a < z) {
System.out.println(a);
a++;
}
}
}
02- Nomenclatura sentencia do - while
do {
sentencias;
} while (expresionLogica);
Ejemplo:
// Contador del 0 al 9
public class MiPrograma_Bucles3 {
public static void main(String arg[]) {
byte a = 0, z = 10;
do {
System.out.println(a);
a++;
} while (a < z);
}
}
#5 Tríptico: Condicionales
00- Nomenclatura sentencia if-else
if (expresionLogica) {
sentencia_1;
} else {
sentencia_2;
}
Ejemplo 1:
// condicionales if - else
public class MiPrograma_Condicionales1 {
public static void main(String arg[]) {
byte a = 5, b = 2;
if (a < b) {
System.out.println("Valor A es menor al valor B");
} else {
System.out.println("Valor A es mayor al valor B");
}
}
}
Ejemplo 2 (sin uso de sentencias if-else):
// forma de condicional abreviada
public class MiPrograma_Condicionales2 {
public static void main(String arg[]) {
byte a = 5, b = 2;
String resultado = (a < b)
? "Valor A es menor al valor B" : "Valor A es mayor al valor B";
System.out.println(resultado);
}
}
01- Nomenclatura sentencia switch
switch(valor) {
case valor1:
sentencias1;
...
break;
case valor2:
sentencias2;
...
break;
default:
sentencias3;
...
break
}
Código Java:
import javax.swing.JFrame;
import javax.swing.JButton;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class MiPrograma5 extends JFrame implements ActionListener {
// Componentes utilizados (botón)
private JButton boton;
// Constructor
public MiPrograma5() {
setDefaultCloseOperation(EXIT_ON_CLOSE);
setLayout(null); // Permite uso de coordenadas
boton = new JButton("Salir");
boton.setBounds(300, 200, 150, 30);
boton.addActionListener(this);
add(boton);
}
@Override
public void actionPerformed(ActionEvent e) {
if (e.getSource() == boton) {
System.exit(0);
}
}
public static void main(String[] args) {
// Crea ventana y se asignan atributos
MiPrograma5 ventana = new MiPrograma5();
ventana.setBounds(0, 0, 500, 300);
ventana.setTitle("Mi Programa 5");
ventana.setVisible(true);
}
}
Resultado:
Estructuras básicas para la programación.
Preparación visualización consola, visualización ventana, preparación de eventos (ej. pulsar un botón).
01- Para uso básico (cónsola):
public class MiPrograma {
public static void main(String arg[]) {
// ...
}
}
02- Para uso interface gráfica:
import javax.swing.JFrame;
public class MiPrograma2 extends JFrame {
public static void main(String[] args) {
// ...
}
}
03- Para uso interface gráfica y con evento:
import javax.swing.JFrame;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class MiPrograma3 extends JFrame implements ActionListener {
// ...
public MiPrograma3() {
// ...
}
public void actionPerformed(ActionEvent e) {
// ...
}
public static void main(String[] args) {
// ...
}
}
04- Para uso interface gráfica y con múltiples eventos :
import javax.swing.JFrame;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
public class MiPrograma4 extends JFrame implements ChangeListener, ActionListener, ItemListener {
// ...
public MiPrograma4() {
// ...
}
public void actionPerformed(ActionEvent e) {
// ...
}
public void stateChanged(ChangeEvent e) {
// ...
}
public void itemStateChanged(ItemEvent e) {
// ...
}
public static void main(String[] args) {
// ...
}
}
#3 Tríptico: Operaciones aritméticas básicas:
Ejemplo:
// Operaciones básicas
public class MiPrograma_Operaciones {
public static void main(String arg[]) {
float a = 5, b = 2;
float suma = a + b;
float resta = a - b;
float multiplicacion = a * b;
float division = a / b;
float modulo = a % b;
System.out.print("a = " + a);
System.out.println(" ; b = " + b);
System.out.println("suma:" + suma);
System.out.println("resta: " + resta);
System.out.println("multiplicacion: " + multiplicacion);
System.out.println("division: " + division);
System.out.println("modulo: " + modulo);
}
}
#2 Tríptico: Definición:
Una variable en Java es un identificador que representa una palabra de memoria que contiene información.
Tabla de tipos de variables primitivos:
Sintaxis:
Tipo_de_Dato Nombre_de_Variable [= Valor_inicial];
Ejemplo de uso:
int var = 1000;
Introducción:
Rápida introducción a la programación en Java SE mediante una serie de trípticos donde se expone de la forma más resumida posible todo lo básico para empezar a programar.
#0 Tríptico: Preparación del entorno para programación en Java SE.
00- Software utilizado para la puesta a punto:
Windows 10
Jdk1.8.0_171
01- Descargar Java SE Development Kit (JDK) desde la web oficial de Oracle:
https://www.oracle.com/technetwork/java/javase/downloads/index.html
02- Ejecutar e instalar JDK: (poner todo por defecto)
[Siguiente]
[Siguiente]
[Finalizar]
03- Activar variable de entorno en Windows 10:
Configuración avanzada del Sistema > [Variables de entorno...] >
Variables del sistema > Seleccionar variable "Path" > [Editar] >
[Nuevo] > Añadir ruta de acceso a los ficheros de Java:
C:\Program Files\Java\jdk1.8.0_171\bin
[Aceptar]
[Aceptar]
[Aceptar]
#1 Tríptico: Primer programa. Compilación & ejecución:
00- Abrir bloc de notas y escribir código:
public class MiPrograma {
public static void main(String arg[]) {
System.out.println("Mi primer programa");
}
}
01- Guardar como "MiPrograma.java".
02- Compilación del código (genera fichero Miprograma.class):
En linea de comandos de Windows (cmd.exe):
> javac Miprograma.java [Enter]
> _
03- Ejecución del código:
En linea de comandos de Windows (cmd.exe):
> java Miprograma [Enter]
> Mi primer programa
> _
Este método para el cálculo aproximado de una raiz cuadrada apareció en un manuscrito encontrado enterrado en un campo por un campesino de un poblado llamado Bakhshali en 1881. El manuscrito data del siglo III o IV.
Formulación:
x = número a calcular.
n = número que multiplicado por sí mismo, más se aproxima a x.
Código (MetodoBakhsali.java):
// Cálculo raiz cuadrada usando método Bakhsali
package metodobakhsali;
public class MetodoBakhsali {
public static void main(String[] args) {
// Definición variables
double n = 0, r, x = 15;
double min = Double.MAX_VALUE;
double aux;
// Busca número más cercano
for (int i = 1; i < Integer.MAX_VALUE; i++) {
r = i * i;
aux = Math.abs(r - x);
if (aux < min) {
n = i;
min = aux;
} else {
break;
}
}
// Formula método Bakhsali + aproximación
double numerador = Math.pow(n, 4) + 6 * Math.pow(n, 2) * x + Math.pow(x, 2);
double denominador = 4 * Math.pow(n, 3) + (4 * n * x);
double m_bakhsali = numerador / denominador;
double aproximacion = Math.abs(m_bakhsali * 100 / Math.sqrt(x) - 200);
// Mostrar resultados en pantalla
System.out.println("Raiz cuadrada de " + x);
System.out.println("Resultado real:\t\t " + Math.sqrt(x));
System.out.println("Método Bakhsali:\t " + m_bakhsali);
System.out.println("Aproximación: (%): " + aproximacion);
}
}
Resultado:
run:
Raiz cuadrada de 15.0
Resultado real: 3.872983346207417
Método Bakhsali: 3.872983870967742
Aproximación: (%): 99.99998645074668
BUILD SUCCESSFUL (total time: 0 seconds)
A través de este método se puede aproximar el cálculo de una raiz cuadrada de cualquier número de forma rápida y fácil. Era un método utilizado en la antigua Babilonia.
x = número a calcular raiz cuadrada.
n = número que multiplicado por sí mismo más se aproxima a x.
nn = aproximación y/o igualación a x.
* Ejemplo de uso para cáculo de raiz cuadrada de 15
x = 15
Búsqueda de los valores de n y nn ( n · n = nn ):
...
2 · 2 = 4
3 · 3 = 9
4 · 4 = 16 <- este número(nn) es el más cercano a x, por tanto n = 4 y nn = 16
5 · 5 = 25
6 · 6 = 36
...
Código (MetodoBabilonico.java):
// Cálculo raiz cuadrada usando método Babilónico
package metodobabilonico;
public class MetodoBabilonico {
public static void main(String[] args) {
// Definición variables
double n = 0, nn = 0, r, x = 15;
double min = Double.MAX_VALUE;
double aux;
// Busca número más cercano
for (int i = 1; i < Integer.MAX_VALUE; i++) {
r = i * i;
aux = Math.abs(r - x);
if (aux < min) {
n = i;
nn = r;
min = aux;
} else {
break;
}
}
// Formula método Babilónico + aproximación
double m_babilonico = (x + nn) / (2 * n);
double aproximacion = Math.abs(m_babilonico * 100 / Math.sqrt(x) - 200);
// Mostrar resultados en pantalla
System.out.println("Raiz cuadrada de " + x);
System.out.println("Resultado real:\t\t " + Math.sqrt(x));
System.out.println("Método Babilónico:\t " + m_babilonico);
System.out.println("Aproximación: (%): " + aproximacion);
}
}
Resultado:
run:
Raiz cuadrada de 15.0
Resultado real: 3.872983346207417
Método Babilónico: 3.875
Aproximación: (%): 99.94793022297507
BUILD SUCCESSFUL (total time: 1 second)
Esquema general de una red neuronal con estructura {2, 3, 3, 1} (perceptrón multicapa), con sus pesos y su propia nomenclatura.
En este ejemplo trata de "aprender" la operación de sumar teniendo como única referencia la siguiente tabla de verdad:
A grandes rasgos el método utilizado para resolver el problema es la de modificar un peso aleatoriamente aplicándole una tasa de aprendizaje (ts) de 0.001.
Si modificado un peso aleatorio (sumándole 0.001) notamos que disminuye el error, se mantendrá el peso con la modificación realizada anteriormente y pasará al siguiente ciclo. De lo contrario si aumenta el error el valor del peso vuelve a su valor anterior al cambio y así nos aseguramos que el sistema no empeora. Así que por cada ciclo realizado el sistema tiende a mejorar el resultado.
Código 1 (Red.java):
package red;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
public class Red {
public static void main(String[] args) {
// arquitectura perceptron
int nK[] = {2, 4, 1};
int nRegistros = 10;
int nTests = 1000000;
double tasaAprendizaje = 0.001;
TablaSuma tv = new TablaSuma(nRegistros, 3);
// TESTS:
double[] vEntradaTest = new double[nK[0]];
// tabla de entrenamiento fija (sumas)
double tablaVerdad[][] = tv.getTv();
// inicializar pesos (aleatorios)
InicializarPesos iniciarPesos = new InicializarPesos(nK, 0, 1);
List<Double> listaPesos = iniciarPesos.getPesos();
// - GESTIÓN TABLA DE VERDAD -
DescomponerTabla dt = new DescomponerTabla(nK, tablaVerdad);
mostrarTablaEntrenamiento(nRegistros, dt);
// - CALCULOS SALIDAS -
PropagacionAdelante pd = new PropagacionAdelante();
pd.sets(nK, listaPesos, dt.getEntradas(0), 0); // nRegistro=0, op=0 -> tipo funcion
// calculo del vError:
double err[] = new double[tablaVerdad.length];
// inicializar min a valores maximos
double minTotal = Double.MAX_VALUE;
double maxTotal = Double.MIN_VALUE;
pd.run();
// variables basicas
int indice;
double pesoNuevo;
// inicializar variables
double tSalidaDeseada[][] = dt.getTablaSalidasDeseadas();
double vSalidaReal[] = pd.getSalidasFinales();
double vError[] = new double[vSalidaReal.length];
double errorMedio[] = new double[nRegistros];
double errorMedioTotal;
System.out.println("\n01- Iniciando fase de aprendizaje...");
for (int t = 0; t < nTests; t++) { // numero de tests...
indice = (int) (Math.random() * (listaPesos.size())); // escoje un peso aleatorio
pesoNuevo = listaPesos.get(indice);
listaPesos.set(indice, pesoNuevo - (tasaAprendizaje * 2)); // actualiza peso
for (int nRegistro = 0; nRegistro < nRegistros; nRegistro++) { // numero registros...
pd.setPesos(listaPesos);
pd.setEntradas(dt.getEntradas(nRegistro)); // row
pd.run();
vSalidaReal = pd.getSalidasFinales();
// calcular error medio
double tmp = 0;
for (int i = 0; i < vError.length; i++) { // numero salidas finales del registro x
vError[i] = tSalidaDeseada[nRegistro][i] - (vSalidaReal[i] * 100); // row = 0
tmp = tmp + Math.abs(vError[i]);
}
errorMedio[nRegistro] = tmp / vError.length;
}
// calculo error medio total
errorMedioTotal = 0;
for (int i = 0; i < errorMedio.length; i++) {
errorMedioTotal += Math.abs(errorMedio[i]);
}
errorMedioTotal = errorMedioTotal / errorMedio.length;
// Error minimo Total
if (errorMedioTotal < minTotal) {
minTotal = errorMedioTotal;
} else {
listaPesos.set(indice, pesoNuevo); // restaura peso anterior
}
if (errorMedioTotal > maxTotal) {
maxTotal = errorMedioTotal;
}
}
// Fase de testeo.
System.out.println("02- Iniciando fase de Testeo...");
double sDeseada;
double[] real;
double confiable;
double aux1 = 0;
int nTestsConfiabilidad = 100;
for (int i = 0; i < nTestsConfiabilidad; i++) {
vEntradaTest[0] = (Math.random() * 50);
vEntradaTest[1] = (Math.random() * 50);
pd.sets(nK, listaPesos, vEntradaTest, 0); // nRegistro=0, op=0 -> tipo
pd.run();
real = pd.getSalidasFinales();
sDeseada = vEntradaTest[0] + vEntradaTest[1];
confiable = (((Math.abs(real[0] * 100.0 - sDeseada)) * 100.0) / sDeseada) - 100.0;
aux1 += confiable;
}
System.out.println("03- Resultado confiabilidad %:");
double conf = Math.abs(aux1 / nTestsConfiabilidad);
System.out.println(conf + "%");
// Fase de testeo manual.
System.out.println("\nIniciando fase de testeo manual...");
System.out.println("Introduce entrada 1: ");
Scanner leerX1 = new Scanner(System.in);
vEntradaTest[0] = Double.parseDouble(leerX1.next());
System.out.println("Introduce entrada 2: ");
Scanner leerX2 = new Scanner(System.in);
vEntradaTest[1] = Double.parseDouble(leerX2.next());
pd.sets(nK, listaPesos, vEntradaTest, 0);
pd.run();
real = pd.getSalidasFinales();
double ia = real[0] * 100.0;
double iafinal = (conf * ia) / 100;
System.out.println("Salida = " + iafinal);
}
private static void mostrarTablaEntrenamiento(int nFilas, DescomponerTabla dt) {
System.out.println("Tabla de referencia para el entrenamiento:");
for (int i = 0; i < nFilas; i++) {
System.out.println(""
+ Arrays.toString(dt.getEntradas(i)) + "\t "
+ Arrays.toString(dt.getSalidas(i)));
}
}
}
Código 2 (TablaSuma.java):
package red;
class TablaSuma {
final double[][] tv;
TablaSuma(int nFilas, int col) {
this.tv = new double[nFilas][col];
// Tabla de verdad suma
tv[0][0] = 48.0; tv[0][1] = 33.0; tv[0][2] = 81.0;
tv[1][0] = 1.0; tv[1][1] = 38.0; tv[1][2] = 39.0;
tv[2][0] = 41.0; tv[2][1] = 25.0; tv[2][2] = 66.0;
tv[3][0] = 6.0; tv[3][1] = 27.0; tv[3][2] = 33.0;
tv[4][0] = 5.0; tv[4][1] = 42.0; tv[4][2] = 47.0;
tv[5][0] = 18.0; tv[5][1] = 12.0; tv[5][2] = 30.0;
tv[6][0] = 35.0; tv[6][1] = 39.0; tv[6][2] = 74.0;
tv[7][0] = 2.0; tv[7][1] = 17.0; tv[7][2] = 19.0;
tv[8][0] = 44.0; tv[8][1] = 14.0; tv[8][2] = 58.0;
tv[9][0] = 24.0; tv[9][1] = 37.0; tv[9][2] = 61.0;
}
public double[][] getTv() {
return tv;
}
}
Código 3 (Mostrar.java):
package red;
import java.util.Iterator;
import java.util.List;
class Mostrar {
Mostrar(int[] nK, List<Double> listaPesos, List<Double> listaSalidas) {
Iterator pesos = listaPesos.iterator();
Iterator salidas = listaSalidas.iterator();
// mostrar entradas
int k = 0;
System.out.println("\n* Capa(k): " + k);
for (int i = 0; i < nK[0]; i++) {
System.out.println("s[" + k + "][" + i + "] = " + (double) salidas.next());
}
for (k = 1; k < nK.length; k++) {
System.out.println("\n* Capa(k): " + k);
for (int i = 0; i < nK[k]; i++) {
for (int j = 0; j < nK[k - 1]; j++) {
System.out.println("w[" + k + "][" + j + "][" + i + "] = " + (double) pesos.next());
}
System.out.println("s[" + k + "][" + i + "] = " + (double) salidas.next());
System.out.println("");
}
}
}
}
Código 4 (DescomponerTabla.java):
package red;
class DescomponerTabla {
int[] nK;
double[][] tVerdad;
double[][] tEntradas;
double[][] tSalidasDeseadas;
int nEntradas, nSalidas;
public DescomponerTabla(int[] nK, double[][] tablaVerdad) {
this.nK = nK;
this.tVerdad = tablaVerdad;
nEntradas = nK[0];
nSalidas = nK[nK.length - 1];
int nFilas = tablaVerdad.length;
tEntradas = new double[nFilas][nEntradas];
for (int i = 0; i < nFilas; i++) {
System.arraycopy(tablaVerdad[i], 0, tEntradas[i], 0, nEntradas);
}
tSalidasDeseadas = new double[nFilas][nSalidas];
for (int i = 0; i < nFilas; i++) {
for (int j = 0; j < nSalidas; j++) {
tSalidasDeseadas[i][j] = tablaVerdad[i][nEntradas + j];
}
}
}
public double[][] getTablaEntradas() {
return tEntradas;
}
public double[][] getTablaSalidasDeseadas() {
return tSalidasDeseadas;
}
public double[] getEntradas(int fila) {
double[] vEntrada = new double[nEntradas];
System.arraycopy(tEntradas[fila], 0, vEntrada, 0, nEntradas);
return vEntrada;
}
public double[] getSalidas(int fila) {
double[] vSalida = new double[nSalidas];
System.arraycopy(tSalidasDeseadas[fila], 0, vSalida, 0, nSalidas);
return vSalida;
}
}
Código 5 (InicializarPesos.java):
package red;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
class InicializarPesos {
List<Double> listaPesos = new ArrayList<>();
InicializarPesos(int[] nK, int n, int m) {
double[][][] w = new double[nK.length][nPesos(nK)][nPesos(nK)];
double[][] s = new double[nK.length][nNeuronas(nK)];
for (int k = 1; k < nK.length; k++) {
for (int i = 0; i < nK[k]; i++) {
for (int j = 0; j < nK[k - 1]; j++) {
w[k][j][i] = new Random().nextDouble() * (n - m) + m;
// w[k][j][i] = new Random().nextDouble();
listaPesos.add(w[k][j][i]);
}
}
}
}
public List<Double> getPesos() {
return listaPesos;
}
// calcular cantidad de pesos necesarios
private int nPesos(int[] nK) {
int nPesos = 1;
for (int i = 0; i < nK.length; i++) {
nPesos *= nK[i];
}
return nPesos;
}
// calcular cantidad de neuronas necesarias
private int nNeuronas(int[] nK) {
int nNeuronas = 1;
for (int i = 0; i < nK.length; i++) {
nNeuronas += nK[i];
}
return nNeuronas;
}
}
Código 6 (PropagacionAdelante.java):
package red;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
final class PropagacionAdelante {
private int[] nK;
private Iterator ipesos;
private double[] entradas;
private int op;
private List<Double> listaSalidas;
PropagacionAdelante() {
}
public void sets(int[] nK, List<Double> listaPesos, double[] entradas, int op) {
listaSalidas = new ArrayList<>();
this.nK = nK;
this.ipesos = listaPesos.iterator();
this.entradas = entradas;
this.op = op; // tipo de función
}
public void setPesos(List<Double> listaPesos) {
this.ipesos = listaPesos.iterator();
}
public void setEntradas(double[] entradas) {
this.entradas = entradas;
}
public void run() {
double[][] s = new double[nK.length][nNeuronas(nK)];
listaSalidas.clear();
// ENTRADAS:
int k = 0;
for (int i = 0; i < entradas.length; i++) {
s[k][i] = entradas[i] / 100.0;
listaSalidas.add(s[k][i]);
}
// SALIDAS:
double tmp;
for (k = 1; k < nK.length; k++) {
for (int i = 0; i < nK[k]; i++) {
tmp = 0.0;
for (int j = 0; j < nK[k - 1]; j++) {
tmp += s[k - 1][j] * (double) ipesos.next();
}
s[k][i] = fx(tmp, op);
listaSalidas.add(s[k][i]);
}
}
}
public List<Double> getSalidas() {
return listaSalidas;
}
public double[] getSalidasFinales() { // no me gusta nada, pero funciona...
double vSalida[] = new double[nK[nK.length - 1]];
List<Double> aux = listaSalidas.subList(listaSalidas.size() - nK[nK.length - 1], listaSalidas.size());
for (int i = 0; i < aux.size(); i++) {
vSalida[i] = aux.get(i);
}
return vSalida;
}
// METODOS ------------------------------------------------------------------
// funcion de activación(F)
public double fx(double n, int op) {
double fx = 0;
switch (op) {
case 0: // (0,1)
fx = 1 / (1 + Math.pow(Math.E, -n));
break;
case 1: // (-1,1)
fx = Math.tanh(n);
break;
}
return fx;
}
// calcular cantidad de neuronas necesarias
private int nNeuronas(int[] nK) {
int nNeuronas = 1;
for (int i = 0; i < nK.length; i++) {
nNeuronas += nK[i];
}
return nNeuronas;
}
}
Resultado:
run:
Tabla de referencia para el entrenamiento:
[48.0, 33.0] [81.0]
[1.0, 38.0] [39.0]
[41.0, 25.0] [66.0]
[6.0, 27.0] [33.0]
[5.0, 42.0] [47.0]
[18.0, 12.0] [30.0]
[35.0, 39.0] [74.0]
[2.0, 17.0] [19.0]
[44.0, 14.0] [58.0]
[24.0, 37.0] [61.0]
01- Iniciando fase de aprendizaje...
02- Iniciando fase de Testeo...
03- Resultado confiabilidad %:
81.81628816341885%
Iniciando fase de testeo manual...
Introduce entrada 1:
22
Introduce entrada 2:
14
Salida = 36.71309818869402
BUILD SUCCESSFUL (total time: 37 seconds)
