La serie armónica es la suma de los inversos de los números naturales.
Código java (numeroArmonico.java):
// Serie armónica hasta el 16
package numeroarmonico;
public class SerieArmonica {
public static void main(String[] args) {
int n = 16;
double sum = 0.0;
for (int k = 1; k <= n; k++) {
sum += 1.0 / k;
System.out.printf("H(%d) = %f\n", k, sum);
}
}
}
Resultado:
run:
H(1) = 1,000000
H(2) = 1,500000
H(3) = 1,833333
H(4) = 2,083333
H(5) = 2,283333
H(6) = 2,450000
H(7) = 2,592857
H(8) = 2,717857
H(9) = 2,828968
H(10) = 2,928968
H(11) = 3,019877
H(12) = 3,103211
H(13) = 3,180134
H(14) = 3,251562
H(15) = 3,318229
H(16) = 3,380729
BUILD SUCCESSFUL (total time: 0 seconds)
La entropía calcula el grado de desorden de un sistema. En este ejemplo será calculada en base a dos tipos de clases (A, B).
En minería de datos se utiliza para encontrar la partición con la máxima ganancia de información posible.
* Procedimiento:
Sea S un conjunto de 1000 pares (AtributoValor, Clase) por ejemplo:
S = {(15, A), (280, B), (319, A), (775, B), (801, B), (850, A), (855, B), (880, B)....}
p1 = núm. de atributos de A / 1000 -> (la fracción de pares con clase = A)
p2 = núm. de atributos de B / 1000 -> (la fracción de pares con clase = B)
La entropía (o contenido de información) para S es:
Entropia(S) = - p1 * log2(p1) – p2 * log2(p2)
* Características resultado:
- Nos tiene que dar un valor entre 0 y 1.
- Si la entropía es pequeña, entonces el conjunto esta muy ordenado.
- Si la entropía es grande, entonces el conjunto esta muy desordenado.
- En este ejemplo al obtener las clases aleatoriamente, nos debería dar una entropía alta, ya que lo aleatorio es sinónimo de desorden.
Código java (DiscretizarEntropia.java):
package discretizarentropia;
public class DiscretizarEntropia {
public static void main(String[] args) {
int nRegistros = 1000;
Object[][] v = new Object[nRegistros][2];
int cont = 0;
for (int i = 0; i < nRegistros; i++) {
v[i][0] = (int) (Math.random() * 1000);
v[i][1] = (int) (Math.random() * 2);
if (v[i][1].equals(0)) {
cont++;
}
}
double p1 = (float) cont / (float) nRegistros;
double p2 = ((float) nRegistros - (float) cont) / (float) nRegistros;
double S = -(p1 * log(p1, 2)) - (p2 * log(p2, 2));
System.out.println("Número de clases A: " + cont);
System.out.println("Número de clases B: " + (nRegistros - cont));
System.out.println("Fracción de pares con clase A (p1) = " + p1);
System.out.println("Fracción de pares con clase B (p2) = " + p2);
System.out.println("Entropia(S) = " + S);
}
private static Double log(double num, int base) {
return (Math.log10(num) / Math.log10(base));
}
}
Resultado:
run:
Número de clases A: 481
Número de clases B: 519
Fracción de pares con clase A (p1) = 0.48100000619888306
Fracción de pares con clase B (p2) = 0.5189999938011169
Entropia(S) = 0.9989581240309595
BUILD SUCCESSFUL (total time: 0 seconds)
En java no existe ninguna función que nos calcule directamente logaritmos en bases distintas a 10. Para ello habrá que crear nuestra propia función.
Código java (Logaritmos1.java):
//Cálculo de logaritmos en distintas bases.
package logaritmos1;
public class Logaritmos1 {
public static void main(String[] args) {
int num = 5;
for (int base = 0; base < 10; base++) {
System.out.println("Logaritmo de 5 en base " + base + " = " + log(num, base));
}
}
private static Double log(double num, int base) {
return (Math.log10(num) / Math.log10(base));
}
}
Resultado:
run:
Logaritmo de 5 en base 0 = -0.0
Logaritmo de 5 en base 1 = Infinity
Logaritmo de 5 en base 2 = 2.3219280948873626
Logaritmo de 5 en base 3 = 1.4649735207179273
Logaritmo de 5 en base 4 = 1.1609640474436813
Logaritmo de 5 en base 5 = 1.0
Logaritmo de 5 en base 6 = 0.8982444017039273
Logaritmo de 5 en base 7 = 0.8270874753469162
Logaritmo de 5 en base 8 = 0.7739760316291209
Logaritmo de 5 en base 9 = 0.7324867603589637
BUILD SUCCESSFUL (total time: 0 seconds)
