El problema en esta pregunta es que los flotantes no son fáciles de comparar por su representación binaria.
Lo que todo informático debe saber sobre la aritmética de coma flotante
Si para una intención similar tiene una matriz con los mismos elementos pero mezclada, esto se puede hacer en [math] O (n) [/ math] con un Set simple y con una redefinición de igualdad para float con un error aceptable.
- Cómo usar el caso del interruptor en Java
- ¿Cómo eliminará elementos de manera eficiente mientras itera una Colección?
- Encontré un problema algorítmico y no sé cómo resolverlo. ¿Alguien me puede ayudar?
- ¿Por qué las variables de matriz no tienen una dirección?
- Cómo implementar un árbol de segmentos con treaps
Si por similitud, tiene la intención de elemento con aproximadamente el mismo valor, entonces todavía puede utilizar la primera solución, pero tiene que decidir contra qué nivel de precisión dos números son similares. La solución será nuevamente [matemática] O (n) [/ matemática] pero almacenará diferentes elementos en la matriz.
En ambos casos, debe asegurarse de comparar los flotadores correctamente. La solución anterior sigue siendo [matemática] O (n) [/ matemática], utiliza un conjunto y una clase personalizada para almacenar el valor redondeado flotante con un valor anulado igual.
clase pública CompareFloatSimilarity {
clase estática pública RoundedFloat {
valor privado final BigDecimal;
public RoundedFloat (float fValue, int decimalPlace) {
valor = BigDecimal.valueOf (fValue) .setScale (decimalPlace,
BigDecimal.ROUND_HALF_UP);
}
public Float getFloat () {
devolver nuevo Float (value.floatValue ());
}
@Anular
public int hashCode () {
final int primo = 31;
int resultado = 1;
result = prime * result + ((value == null)? 0: value.hashCode ());
resultado de retorno;
}
@Anular
public boolean equals (Object obj) {
if (esto == obj)
volver verdadero;
if (obj == nulo)
falso retorno;
if (getClass ()! = obj.getClass ())
falso retorno;
RoundedFloat other = (RoundedFloat) obj;
if (valor == nulo) {
if (otro.valor! = nulo)
falso retorno;
} else if (Float.compare (getFloat (), other.getFloat ()) == 0) {
volver verdadero;
}
falso retorno;
}
@Anular
public String toString () {
return Float.toString (getFloat ());
}
}
/ *
* (no Javadoc)
* *
* @ver java.lang.Object # hashCode ()
* /
public static boolean areSimilar (float [] first, float [] second,
int precisión) {
Establezca rounded = new HashSet ();
para (flotante f: primero) {
rounded.add (nuevo RoundedFloat (f, precisión));
}
para (flotante f: segundo) {
if (! rounded.contains (new RoundedFloat (f, precision))) {
System.out.println (f);
falso retorno;
}
}
volver verdadero;
}
/ **
* @param args
* /
public static void main (String [] args) {
float [] first = new float [] {2, 33f, 5, 4500000f, 5, 123.200000f, 1f};
float [] second = new float [] {2, 33f, 5, 4500000f, 5, 123.203f, 1f};
System.out.println (areSimilar (primero, segundo, 2));
System.out.println (areSimilar (primero, segundo, 3));
}
}
