c++ - utilizo - ¿Cómo inicializo un flotador a su valor máximo/mínimo?

se utilizo la variable local sin inicializar c++

Question

¿Cómo puedo codificar un valor máximo o mínimo absoluto para un flotante o doble? Quiero buscar el máximo / mínimo de una matriz simplemente recorriendo y atrapando la más grande.

También hay infinito positivo y negativo para flotadores, ¿debería usarlos en su lugar? Si es así, ¿cómo denote eso en mi código?

Answer 1

¿Puedo sugerirle que inicialice sus variables "max y min hasta ahora" no hasta el infinito, sino al primer número en la matriz?

Answer 2

No es necesario inicializar al más pequeño / más grande posible para encontrar el más pequeño / más grande en el conjunto:

double largest = smallest = array[0];
for (int i=1; i<array_size; i++) {
    if (array[i] < smallest)
        smallest = array[i];
    if (array[i] > largest0
        largest= array[i];
}

O, si lo haces más de una vez:

#include <utility>

template <class iter>
std::pair<typename iter::value_type, typename iter::value_type> find_extrema(iter begin, iter end) {
    std::pair<typename iter::value_type, typename iter::value_type> ret;
    ret.first = ret.second = *begin;
    while (++begin != end) {
        if (*begin < ret.first)
           ret.first = *begin;
        if (*begin > ret.second)
           ret.second = *begin;
   }
   return ret;
}

La desventaja de proporcionar código de muestra: veo que otros ya han sugerido la misma idea.

Tenga en cuenta que si bien el estándar tiene un min_element y un max_element, su uso requeriría escanear los datos dos veces, lo que podría ser un problema si el array es grande. Los estándares recientes lo han abordado agregando un elemento std::minmax_element , que hace lo mismo que find_extrema anterior (encuentre los elementos mínimo y máximo en una colección en una sola pasada).

Editar: Abordando el problema de encontrar el valor más pequeño que no sea cero en una matriz de unsigned: observe que los valores sin firmar se "envuelven" cuando llegan a un extremo. Para encontrar el valor más pequeño distinto de cero, podemos restar uno de cada uno para la comparación. Cualquier valor cero se "ajustará" al mayor valor posible para el tipo, pero la relación entre otros valores se mantendrá. Después de que terminemos, obviamente agregamos uno al valor que encontramos.

unsigned int min_nonzero(std::vector<unsigned int> const &values) { 
    if (vector.size() == 0)
        return 0;
    unsigned int temp = values[0]-1;
    for (int i=1; i<values.size(); i++)
        if (values[i]-1 < temp)
            temp = values[i]-1;
    return temp+1;
}

Tenga en cuenta que esto todavía utiliza el primer elemento para el valor inicial, pero todavía no necesitamos ningún código de "caso especial", ya que se ajustará al mayor valor posible, cualquier valor distinto de cero se comparará como más pequeño. El resultado será el menor valor distinto de cero, o 0 si y solo si el vector no contiene valores distintos de cero.

Answer 3

Para encontrar manualmente el mínimo de una matriz, no necesita conocer el valor mínimo de float:

float myFloats[];
...
float minimum = myFloats[0];
for (int i = 0; i < myFloatsSize; ++i)
{
  if (myFloats[i] < minimum)
  {
    minimum = myFloats[i];
  }
}

Y código similar para el valor máximo.

Answer 4

Puede usar -FLT_MAX (o -DBL_MAX ) para el número negativo de magnitud máxima y FLT_MAX (o DBL_MAX ) para positivo. Esto le da el rango de valores posibles de flotación (o doble).

Probablemente no desee usar FLT_MIN ; corresponde al número positivo de menor magnitud que se puede representar con un flotante, no al valor más negativo que se puede representar con un flotador.

FLT_MIN y FLT_MAX corresponden a std::numeric_limits<float>::min() y std::numeric_limits<float>::max() .

Answer 5

Puede usar std::numeric_limits que se define en <limits> para encontrar el valor mínimo o máximo de los tipos (siempre que exista una especialización para el tipo). También puede usarlo para recuperar infinito (y poner un - en frente para infinito negativo).

#include <limits>

//...

std::numeric_limits<float>::max();
std::numeric_limits<float>::min();
std::numeric_limits<float>::infinity();

Como se señala en los comentarios, min() devuelve el valor positivo más bajo posible. En otras palabras, el valor positivo más cercano a 0 que se puede representar. El valor más bajo posible es el negativo del valor máximo posible.

Por supuesto, las funciones std::max_element y min_element (definidas en <algorithm> ) pueden ser una mejor opción para encontrar el valor más grande o más pequeño en una matriz.