Perceptrón multicapa. Cálculo real de todas las variables partiendo de un dataset básico.

Tras los posts anteriores (visualizaciones esquemáticas de formulas) el siguiente paso pasa por realizar el cálculo real de todas las variables (salidas, errores y pesos actualizados) partiendo de un dataset(D) de un sólo registro.



Código Java:

package perceptron_p;

import java.util.ArrayList;
import java.util.List;

public class Perceptron_p {

   public static void main(String[] args) {

      //sketch: num neuronas
      List<Integer> nN = new ArrayList<>();
      nN.add(2);
      nN.add(3);
      nN.add(2);
      nN.add(1);

      double µ = 0.001;
      int r = 0; // num. registro del dataset
      int nK = nN.size(); // num. de capas = 4
      int nE = nN.get(0); // num. de entradas = 2
      int nS = nN.get(nK - 1); // num. de salidas = 1

      int max = nN.stream().mapToInt(i -> i).max().getAsInt(); // num. max. neuronas por capa
      String tmp;
      double d_tmp;

      // Inicializar dataset (sólo 1 registro o fila)
      double[][] D = new double[1][3];
      D[0][0] = 0.48d; // entrada 1
      D[0][1] = 0.33d; // entrada 2
      D[0][2] = 0.81d; // salida  1

      // Inicializar pesos W, WBias, Y
      double[][][] W = new double[nK][max][max];
      double[][] WB = new double[nK][max];
      double[][] Y = new double[nK][max];
      double[][] E = new double[nK][max];

      System.out.println("Inicializar pesos con valores aleatorios:\n");
      for (int k = 1; k < nK; k++) {
         for (int j = 0; j < nN.get(k); j++) {
            for (int i = 0; i < nN.get(k - 1); i++) {
               W[k][j][i] = Math.random();
               System.out.format("W[%d][%d][%d] = %f\n", k, j, i, W[k][j][i]);
            }
            WB[k][j] = Math.random();
            System.out.format("WB[%d][%d] = %f\n\n", k, j, WB[k][j]);
            Y[k][j] = 0.f;
            E[k][j] = 0.f;
         }
      }

      // 0.0:-------------------------------------------------------------------
      System.out.println("Forward:\n");
      int k = 1;
      for (int j = 0; j < nN.get(k); j++) {
         tmp = "";
         d_tmp = 0f;
         for (int i = 0; i < nE; i++) {
            tmp += String.format("( D[%d][%d] * W[%d][%d][%d] ) + ", r, i, k, j, i);
            d_tmp += D[r][i] * W[k][j][i];
         }
         Y[k][j] = F(d_tmp + (-1 * WB[k][j]), 0);
         System.out.format("Y[%d][%d] = F{ %s( -1 * WB[%d][%d] ) } = ", k, j, tmp, k, j);
         System.out.println(Y[k][j]);
      }

      // 0.1:-------------------------------------------------------------------
      System.out.println("");
      for (k = 2; k < nK; k++) {
         for (int j = 0; j < nN.get(k); j++) {
            tmp = "";
            d_tmp = 0f;
            for (int i = 0; i < nN.get(k - 1); i++) {
               tmp += String.format("( Y[%d][%d] * W[%d][%d][%d] ) + ", k - 1, i, k, j, i);
               d_tmp += Y[k - 1][i] * W[k][j][i];
            }
            System.out.format("Y[%d][%d] = F{ %s( -1 * WB[%d][%d] ) } = ", k, j, tmp, k, j);
            Y[k][j] = F(d_tmp + (-1 * WB[k][j]), 0);
            System.out.println(Y[k][j]);
         }
         System.out.println("");
      }

      // 1.0:-------------------------------------------------------------------
      System.out.println("Backward:\n");
      k = nK - 1;
      for (int j = 0; j < nS; j++) {
         E[k][j] = D[r][nE + j] - Y[k][j];
         System.out.format("E[%d][%d] = ( D[%d][%d] - Y[%d][%d] ) = ", k, j, r, nE + j, k, j);
         System.out.println(E[k][j]);
      }

      // 1.1:-------------------------------------------------------------------
      System.out.println("");
      for (k = k - 1; k > 0; k--) {
         for (int j = nN.get(k); j > 0; j--) {
            tmp = "";
            d_tmp = 0.d;
            for (int i = nN.get(k + 1); i > 0; i--) {
               tmp += String.format("( E[%d][%d] * W[%d][%d][%d] ) + ", k + 1, i - 1, k + 1, i - 1, j - 1);
               d_tmp += E[k + 1][i - 1] * W[k + 1][i - 1][j - 1];
            }
            System.out.format("E[%d][%d] = %s%s = ", k, j - 1, tmp, "0 ");
            System.out.println(d_tmp);
            E[k][j - 1] = d_tmp;
         }
         System.out.println("");
      }

      // 2.0:-------------------------------------------------------------------
      System.out.println("Ajuste pesos:\n");
      k = 1;
      for (int j = 0; j < nN.get(k); j++) {
         for (int i = 0; i < nE; i++) {
            W[k][j][i] += (µ * E[k][j] * F(Y[k][j], 1) * D[r][i]);
            System.out.format("W'[%d][%d][%d] = W[%d][%d][%d] + ( µ * E[%d][%d] * F'(Y[%d][%d]) * D[%d][%d] ) = ", k, j, i, k, j, i, k, j, k, j, r, i);
            System.out.println(W[k][j][i]);
         }
         WB[k][j] += (µ * E[k][j] * F(Y[k][j], 1) * -1);
         System.out.format("WB'[%d][%d] = WB[%d][%d] + ( µ * E[%d][%d] * F'(Y[%d][%d]) * (%d) ) = ", k, j, k, j, k, j, k, j, - 1);
         System.out.println(WB[k][j] + "\n");
      }

      // 2.1:-------------------------------------------------------------------
      System.out.println("");
      for (k = 2; k < nK; k++) {
         for (int j = 0; j < nN.get(k); j++) {
            for (int i = 0; i < nN.get(k - 1); i++) {
               W[k][j][i] += (µ * E[k][j] * F(Y[k][j], 1) * Y[k - 1][i]);
               System.out.format("W'[%d][%d][%d] = W[%d][%d][%d] + ( µ * E[%d][%d] * F'( Y[%d][%d] ) * Y[%d][%d] ) = ", k, j, i, k, j, i, k, j, k, j, k - 1, i);
               System.out.println(W[k][j][i]);
            }
            WB[k][j] += (µ * E[k][j] * F(Y[k][j], 2) * (-1));
            System.out.format("WB'[%d][%d] = WB[%d][%d] + ( µ * E[%d][%d] * F'(Y[%d][%d]) * (%d) ) = ", k, j, k, j, k, j, k, j, -1);
            System.out.println(WB[k][j] + "\n");
         }
         System.out.println("");
      }
   }

   // Función Activación - Derivada
   private static double F(double n, int op) {
      double fx;
      switch (op) {
         case 0: // función sigmoide
            fx = 1.0 / (1.0 + Math.pow(Math.E, -n));
            break;
         case 1: // derivada función sigmoide
            fx = 1.0 / (1.0 + Math.pow(Math.E, -n));
            fx = fx * (1 - fx);
            break;
         default:
            fx = 0.f;
            break;
      }
      return fx;
   }

}


Resultado:

run:
Inicializar pesos con valores aleatorios:

W[1][0][0] = 0,835049
W[1][0][1] = 0,308429
WB[1][0] = 0,052288

W[1][1][0] = 0,217787
W[1][1][1] = 0,348034
WB[1][1] = 0,588298

W[1][2][0] = 0,961801
W[1][2][1] = 0,796138
WB[1][2] = 0,044188

W[2][0][0] = 0,994101
W[2][0][1] = 0,211034
W[2][0][2] = 0,711812
WB[2][0] = 0,952732

W[2][1][0] = 0,423756
W[2][1][1] = 0,953356
W[2][1][2] = 0,249125
WB[2][1] = 0,973105

W[3][0][0] = 0,842807
W[3][0][1] = 0,794736
WB[3][0] = 0,290240

Forward:

Y[1][0] = F{ ( D[0][0] * W[1][0][0] ) + ( D[0][1] * W[1][0][1] ) + ( -1 * WB[1][0] ) } = 0.6107146316470909
Y[1][1] = F{ ( D[0][0] * W[1][1][0] ) + ( D[0][1] * W[1][1][1] ) + ( -1 * WB[1][1] ) } = 0.40880474360914854
Y[1][2] = F{ ( D[0][0] * W[1][2][0] ) + ( D[0][1] * W[1][2][1] ) + ( -1 * WB[1][2] ) } = 0.6637837549590786

Y[2][0] = F{ ( Y[1][0] * W[2][0][0] ) + ( Y[1][1] * W[2][0][1] ) + ( Y[1][2] * W[2][0][2] ) + ( -1 * WB[2][0] ) } = 0.5530844896875817
Y[2][1] = F{ ( Y[1][0] * W[2][1][0] ) + ( Y[1][1] * W[2][1][1] ) + ( Y[1][2] * W[2][1][2] ) + ( -1 * WB[2][1] ) } = 0.46028147962310223

Y[3][0] = F{ ( Y[2][0] * W[3][0][0] ) + ( Y[2][1] * W[3][0][1] ) + ( -1 * WB[3][0] ) } = 0.6322090580829307

Backward:

E[3][0] = ( D[0][2] - Y[3][0] ) = 0.17779094191706935

E[2][1] = ( E[3][0] * W[3][0][1] ) + 0  = 0.14129683962211012
E[2][0] = ( E[3][0] * W[3][0][0] ) + 0  = 0.1498433870202291

E[1][2] = ( E[2][1] * W[2][1][2] ) + ( E[2][0] * W[2][0][2] ) + 0  = 0.1418609770496571
E[1][1] = ( E[2][1] * W[2][1][1] ) + ( E[2][0] * W[2][0][1] ) + 0  = 0.16632825764793913
E[1][0] = ( E[2][1] * W[2][1][0] ) + ( E[2][0] * W[2][0][0] ) + 0  = 0.2088347664166445

Ajuste pesos:

W'[1][0][0] = W[1][0][0] + ( µ * E[1][0] * F'(Y[1][0]) * D[0][0] ) = 0.8350717767495889
W'[1][0][1] = W[1][0][1] + ( µ * E[1][0] * F'(Y[1][0]) * D[0][1] ) = 0.3084447906938308
WB'[1][0] = WB[1][0] + ( µ * E[1][0] * F'(Y[1][0]) * (-1) ) = 0.05224031629899943

W'[1][1][0] = W[1][1][0] + ( µ * E[1][1] * F'(Y[1][1]) * D[0][0] ) = 0.21780595558207116
W'[1][1][1] = W[1][1][1] + ( µ * E[1][1] * F'(Y[1][1]) * D[0][1] ) = 0.34804701774866154
WB'[1][1] = WB[1][1] + ( µ * E[1][1] * F'(Y[1][1]) * (-1) ) = 0.5882576504954621

W'[1][2][0] = W[1][2][0] + ( µ * E[1][2] * F'(Y[1][2]) * D[0][0] ) = 0.9618160101133663
W'[1][2][1] = W[1][2][1] + ( µ * E[1][2] * F'(Y[1][2]) * D[0][1] ) = 0.7961484238865005
WB'[1][2] = WB[1][2] + ( µ * E[1][2] * F'(Y[1][2]) * (-1) ) = 0.04415614986229021


W'[2][0][0] = W[2][0][0] + ( µ * E[2][0] * F'( Y[2][0] ) * Y[1][0] ) = 0.9941217290526374
W'[2][0][1] = W[2][0][1] + ( µ * E[2][0] * F'( Y[2][0] ) * Y[1][1] ) = 0.21104869817169436
W'[2][0][2] = W[2][0][2] + ( µ * E[2][0] * F'( Y[2][0] ) * Y[1][2] ) = 0.7118355488714299
WB'[2][0] = WB[2][0] + ( µ * E[2][0] * F'(Y[2][0]) * (-1) ) = 0.9527319900854492

W'[2][1][0] = W[2][1][0] + ( µ * E[2][1] * F'( Y[2][1] ) * Y[1][0] ) = 0.4237764313332067
W'[2][1][1] = W[2][1][1] + ( µ * E[2][1] * F'( Y[2][1] ) * Y[1][1] ) = 0.953369304782218
W'[2][1][2] = W[2][1][2] + ( µ * E[2][1] * F'( Y[2][1] ) * Y[1][2] ) = 0.2491472992670435
WB'[2][1] = WB[2][1] + ( µ * E[2][1] * F'(Y[2][1]) * (-1) ) = 0.9731049511389623


W'[3][0][0] = W[3][0][0] + ( µ * E[3][0] * F'( Y[3][0] ) * Y[2][0] ) = 0.8428289253648974
W'[3][0][1] = W[3][0][1] + ( µ * E[3][0] * F'( Y[3][0] ) * Y[2][1] ) = 0.7947544171128877
WB'[3][0] = WB[3][0] + ( µ * E[3][0] * F'(Y[3][0]) * (-1) ) = 0.29024004297076156


BUILD SUCCESSFUL (total time: 2 seconds)

Perceptrón multicapa. Ajuste pesos.

Siguiendo el hilo anterior en esta ocasión se procede ajustar los pesos (W) para minimizar el error. Para ello son utilizadas las siguientes variables:

μ  = Tasa de aprendizaje
δ  = Error neurona (E)
Ø  = Bias (-1)
ʄ  = Función de activación
ʄ' = Derivada de la función de activación
ΔW = Delta de los pesos



Función Sigmoide:

ʄ(x)  = 1 / ( 1 + e^(-x) )


Derivada función Sigmoide:

ʄ'(x) = ʄ(x) * ( 1 - ʄ(x) )


Cálculo deltas(Δ) de los pesos:

ΔW = µ * δ * ʄ'(x) * Y
ΔW = µ * δ * ʄ'(x) * Ø -> para ajuste pesos del Bias(Ø)


Ajuste pesos:

W' = W + ΔW



Código Java:

package ajustePesos;

import java.util.ArrayList;
import java.util.List;

public class AjustePesos {

   public static void main(String[] args) {

      //sketch: num neuronas
      List<Integer> nN = new ArrayList<>();
      nN.add(2);
      nN.add(3);
      nN.add(2);
      nN.add(1);

      double µ = 0.001;
      int r = 0; // num. registro del dataset
      int nK = nN.size(); // num. de capas = 4
      int nE = nN.get(0); // num. de entradas = 2
      int nS = nN.get(nK - 1); // num. de salidas = 1
      String tmp;

      // 2.0:-------------------------------------------------------------------
      System.out.println("Ajuste pesos:\n");
      k = 1;
      for (int j = 0; j < nN.get(k); j++) {
         for (int i = 0; i < nE; i++) {
            System.out.format("W'[%d][%d][%d] = W[%d][%d][%d] + ( µ * E[%d][%d] * F'(Y[%d][%d]) * D[%d][%d] )\n", k, j, i, k, j, i, k, j, k, j, r, i);
         }
         System.out.format("WB'[%d][%d] = WB[%d][%d] + ( µ * E[%d][%d] * F'(Y[%d][%d]) * %d)\n\n", k, j, k, j, k, j, k, j, - 1);
      }

      // 2.1:-------------------------------------------------------------------
      System.out.println("");
      for (k = 2; k < nK; k++) {
         for (int j = 0; j < nN.get(k); j++) {
            for (int i = 0; i < nN.get(k - 1); i++) {
               System.out.format("W'[%d][%d][%d] = W[%d][%d][%d] + ( µ * E[%d][%d] * F'( Y[%d][%d] ) * Y[%d][%d] )\n", k, j, i, k, j, i, k, j, k, j, k - 1, i);
            }
            System.out.format("WB'[%d][%d] = WB[%d][%d] + ( µ * E[%d][%d] * F'(Y[%d][%d]) * (%d) )\n\n", k, j, k, j, k, j, k, j, -1);
         }
         System.out.println("");
      }

   }

}


Resultado:

run:
Ajuste pesos:

W'[1][0][0] = W[1][0][0] + ( µ * E[1][0] * F'(Y[1][0]) * D[0][0] )
W'[1][0][1] = W[1][0][1] + ( µ * E[1][0] * F'(Y[1][0]) * D[0][1] )
WB'[1][0] = WB[1][0] + ( µ * E[1][0] * F'(Y[1][0]) * -1)

W'[1][1][0] = W[1][1][0] + ( µ * E[1][1] * F'(Y[1][1]) * D[0][0] )
W'[1][1][1] = W[1][1][1] + ( µ * E[1][1] * F'(Y[1][1]) * D[0][1] )
WB'[1][1] = WB[1][1] + ( µ * E[1][1] * F'(Y[1][1]) * -1)

W'[1][2][0] = W[1][2][0] + ( µ * E[1][2] * F'(Y[1][2]) * D[0][0] )
W'[1][2][1] = W[1][2][1] + ( µ * E[1][2] * F'(Y[1][2]) * D[0][1] )
WB'[1][2] = WB[1][2] + ( µ * E[1][2] * F'(Y[1][2]) * -1)


W'[2][0][0] = W[2][0][0] + ( µ * E[2][0] * F'( Y[2][0] ) * Y[1][0] )
W'[2][0][1] = W[2][0][1] + ( µ * E[2][0] * F'( Y[2][0] ) * Y[1][1] )
W'[2][0][2] = W[2][0][2] + ( µ * E[2][0] * F'( Y[2][0] ) * Y[1][2] )
WB'[2][0] = WB[2][0] + ( µ * E[2][0] * F'(Y[2][0]) * (-1) )

W'[2][1][0] = W[2][1][0] + ( µ * E[2][1] * F'( Y[2][1] ) * Y[1][0] )
W'[2][1][1] = W[2][1][1] + ( µ * E[2][1] * F'( Y[2][1] ) * Y[1][1] )
W'[2][1][2] = W[2][1][2] + ( µ * E[2][1] * F'( Y[2][1] ) * Y[1][2] )
WB'[2][1] = WB[2][1] + ( µ * E[2][1] * F'(Y[2][1]) * (-1) )


W'[3][0][0] = W[3][0][0] + ( µ * E[3][0] * F'( Y[3][0] ) * Y[2][0] )
W'[3][0][1] = W[3][0][1] + ( µ * E[3][0] * F'( Y[3][0] ) * Y[2][1] )
WB'[3][0] = WB[3][0] + ( µ * E[3][0] * F'(Y[3][0]) * (-1) )


BUILD SUCCESSFUL (total time: 5 seconds)

Perceptrón multicapa. Propagación hacia atrás.

Descripción:

En base al valor de salida del dataset (D02), se visualiza la base conceptual para el cálculo de los errores (Exx) de cada neurona (Yxx) de una red neuronal tipo perceptrón multicapa. Todo ese proceso se le llama propagación hacia atrás.


Nomenclatura:

Y[k][j]: Salida neurona (capa, posición j-enésima)
E[k][j]: Error neurona (δ) (capa, posición j-enésima)
W[k][j][i]: Peso (capa, neurona destino, neurona origen)



Código Java:

package backward;

import java.util.ArrayList;
import java.util.List;

public class Backward{

   public static void main(String[] args) {

      //sketch: num neuronas
      List<Integer> nN = new ArrayList<>();
      nN.add(2);
      nN.add(3);
      nN.add(2);
      nN.add(1);

      int r = 0; // num. registro del dataset
      int nK = nN.size(); // num. de capas = 4
      int nE = nN.get(0); // num. de entradas = 2
      int nS = nN.get(nK - 1); // num. de salidas = 1
      String tmp;

      // 1.0:-------------------------------------------------------------------
      System.out.println("Backward:\n");
      int k = nK - 1;
      for (int j = 0; j < nS; j++) {
         System.out.format("E[%d][%d] = ( D[%d][%d] - Y[%d][%d] )\n", k, j, r, nE + j, k, j);
      }

      // 1.1:-------------------------------------------------------------------
      System.out.println("");
      for (k = k - 1; k > 0; k--) {
         for (int j = nN.get(k); j > 0; j--) {
            tmp = "";
            for (int i = nN.get(k + 1); i > 0; i--) {
               tmp += String.format("( E[%d][%d] * W[%d][%d][%d] ) + ", k + 1, i - 1, k + 1, i - 1, j - 1);
            }
            System.out.format("E[%d][%d] = %s%s\n", k, j - 1, tmp, "0 ");
         }
         System.out.println("");
      }

   }

}


Resultado:

run:
Backward:

E[3][0] = ( D[0][2] - Y[3][0] )

E[2][1] = ( E[3][0] * W[3][0][1] ) + 0
E[2][0] = ( E[3][0] * W[3][0][0] ) + 0

E[1][2] = ( E[2][1] * W[2][1][2] ) + ( E[2][0] * W[2][0][2] ) + 0
E[1][1] = ( E[2][1] * W[2][1][1] ) + ( E[2][0] * W[2][0][1] ) + 0
E[1][0] = ( E[2][1] * W[2][1][0] ) + ( E[2][0] * W[2][0][0] ) + 0 


BUILD SUCCESSFUL (total time: 1 second)

Perceptrón multicapa. Propagación hacia adelante.

Descripción:

En base a los valores de entrada Dxx (dataset), Wxxx (pesos) y WBxx (bias pesos), se visualiza la base conceptual para el cálculo de las salidas de las neuronas (Yxx) de una red neuronal tipo perceptrón multicapa. Todo ese proceso se le llama propagación hacia delante.


Nomenclatura:

Y[k][j]: Salida neurona (capa, posición j-enésima)
W[k][j][i]: Peso (capa, neurona destino, neurona origen)
WB[k][j]: Pesos Bias (capa, posición j-enésima)
F: Función Activación


Dataset:
 
D[row][col]: Dataset (fila, columna)

     0     1     2     col(n)
0   D00   D01   D02     .
1   D10   D11   D12     .
2   D20   D21   D22     .
.    .     .     .      .
row(n)    



 
Código Java:

package forward;

import java.util.ArrayList;
import java.util.List;

public class Forward {

   public static void main(String[] args) {

      //sketch: num neuronas
      List<Integer> nN = new ArrayList<>();
      nN.add(2);
      nN.add(3);
      nN.add(2);
      nN.add(1);

      int r = 0; // num. registro del dataset
      int nK = nN.size(); // num. de capas = 4
      int nE = nN.get(0); // num. de entradas = 2
      int nS = nN.get(nK - 1); // num. de salidas = 1
      String tmp;

      // 0.0:-------------------------------------------------------------------
      System.out.println("Forward:\n");
      int k = 1;
      for (int j = 0; j < nN.get(k); j++) {
         tmp = "";
         for (int i = 0; i < nE; i++) {
            tmp += String.format("( D[%d][%d] * W[%d][%d][%d] ) + ", r, i, k, j, i);
         }
         System.out.format("Y[%d][%d] = F{ %s( -1 * WB[%d][%d] ) }\n", k, j, tmp, k, j);
      }

      // 0.1:-------------------------------------------------------------------
      System.out.println("");
      for (k = 2; k < nK; k++) {
         for (int j = 0; j < nN.get(k); j++) {
            tmp = "";
            for (int i = 0; i < nN.get(k - 1); i++) {
               tmp += String.format("( Y[%d][%d] * W[%d][%d][%d] ) + ", k - 1, i, k, j, i);
            }
            System.out.format("Y[%d][%d] = F{ %s( -1 * WB[%d][%d] ) }\n", k, j, tmp, k, j);
         }
         System.out.println("");
      }

   }

}


Resultado:

run: 
Forward:

Y[1][0] = F{ ( D[0][0] * W[1][0][0] ) + ( D[0][1] * W[1][0][1] ) + ( -1 * WB[1][0] ) }
Y[1][1] = F{ ( D[0][0] * W[1][1][0] ) + ( D[0][1] * W[1][1][1] ) + ( -1 * WB[1][1] ) }
Y[1][2] = F{ ( D[0][0] * W[1][2][0] ) + ( D[0][1] * W[1][2][1] ) + ( -1 * WB[1][2] ) }

Y[2][0] = F{ ( Y[1][0] * W[2][0][0] ) + ( Y[1][1] * W[2][0][1] ) + ( Y[1][2] * W[2][0][2] ) + ( -1 * WB[2][0] ) }
Y[2][1] = F{ ( Y[1][0] * W[2][1][0] ) + ( Y[1][1] * W[2][1][1] ) + ( Y[1][2] * W[2][1][2] ) + ( -1 * WB[2][1] ) }

Y[3][0] = F{ ( Y[2][0] * W[3][0][0] ) + ( Y[2][1] * W[3][0][1] ) + ( -1 * WB[3][0] ) }

BUILD SUCCESSFUL (total time: 0 seconds)
 

Crear una tabla (dataset) usando listas.

En Java no existe el concepto de Listas Multidimensionales. Para ello mediante código se puede simular listas multidimensionales creando listas dentro de otras listas:

List<List<Double>> dataset1 = new ArrayList<List<Double>>();

En el ejemplo se crea una tabla de 3x10 mediante listas con la que se llenará con valores numéricos para luego imprimirlo en pantalla.


Código (DataSets1.java):


package datasets1;

import java.util.ArrayList;
import java.util.List;

public class DataSets1 {

   public static void main(String[] args) {

      //Dataset 2d
      List<List<Double>> dataset1 = new ArrayList<List<Double>>();

      //Agregar 3 sublistas (columnas)
      for (int i = 0; i < 3; i++) {
         dataset1.add(new ArrayList<Double>());
      }

      /*
      @  Añadir datos al dataset (suma)
       */

      //operando 1
      dataset1.get(0).add(48.0);
      dataset1.get(0).add(1.0);
      dataset1.get(0).add(41.0);
      dataset1.get(0).add(6.0);
      dataset1.get(0).add(5.0);
      dataset1.get(0).add(18.0);
      dataset1.get(0).add(35.0);
      dataset1.get(0).add(2.0);
      dataset1.get(0).add(44.0);
      dataset1.get(0).add(24.0);
      //operando 2
      dataset1.get(1).add(33.0);
      dataset1.get(1).add(38.0);
      dataset1.get(1).add(25.0);
      dataset1.get(1).add(27.0);
      dataset1.get(1).add(42.0);
      dataset1.get(1).add(12.0);
      dataset1.get(1).add(39.0);
      dataset1.get(1).add(17.0);
      dataset1.get(1).add(14.0);
      dataset1.get(1).add(37.0);
      //resultado 1
      dataset1.get(2).add(81.0);
      dataset1.get(2).add(39.0);
      dataset1.get(2).add(66.0);
      dataset1.get(2).add(33.0);
      dataset1.get(2).add(47.0);
      dataset1.get(2).add(30.0);
      dataset1.get(2).add(74.0);
      dataset1.get(2).add(19.0);
      dataset1.get(2).add(58.0);
      dataset1.get(2).add(61.0);

      //imprimir dataset1
      System.out.println("'operando1', 'operando2', 'resultado1'");
      for (int i = 0; i <= dataset1.get(0).size() - 1; i++) {
         for (int j = 0; j < dataset1.size(); j++) {
            System.out.print(dataset1.get(j).get(i) + ";\t");
         }
         System.out.println("");
      }

   }

}


Resultado:

run:
'operando1', 'operando2', 'resultado1'
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;        
BUILD SUCCESSFUL (total time: 0 seconds)

Graficando red neuronal (perceptrón).

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:

Graficando tablero de ajedrez.

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:

Graficando rosco del "Pasapalabra" (beta)

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:

Graficando triángulo de pascal (beta)

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:

#7 Empaquetado del proyecto.

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
> _

#6 Comandos de Interacción (for, while, do-while)

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 Comandos de Selección (if, else, switch)

#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
     }

#4.1 Ejemplo. Ejecutar evento al pulsar botón.

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:

#4 Estructuras básicas (consola, interface gráfica, interface gráfica + evento)

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 Operaciones básicas

#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 Variables

#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;

#0 , #1 Guía de inicio rápido

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
    > _

Cálculo raiz cuadrada usando método Bakhsali

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)