Melhorando a precisão de valores flutuantes em python[AJUDA]

1. Melhorando a precisão de valores flutuantes em python[AJUDA]

dark777
(usa Debian)

Enviado em 24/11/2024 - 21:20h

Boa noite galera beleza?

Ha ums tempos atras fiz algumas continhas para enter como calcular e encontrar os lados de um triangulo retângulo porem depois de um tempo tirando a prova real do triangulo pitagorico, resolvi fazer um porgrama para calcular a quantidade de metros quadrados de uma area e calcular as dimensoes e proporção da mesma, ou seja em uantas formas dá para se ter a mesma medida em metros quadrados. Entao fiz um script em python e preciso melhorar precisão dos resultados, reornados pela função ex:

Se coloco o valor de 1 ele retorna os valores flutuantes e inteiros corretamente, se coloco 100 tambem esta correto, isso daria uma área de 1 alqueire paulista até 100 alqueires paulista, mas ao utilizar por ex: 0.8 e 1.5 para calcular quantos metros quadrados teria 1.5 alqueires os resultados obtidos nao sao os mais precisos possiveis retorna muitas casas quando deveria retornar 1 ou duas casas após a virgula, entao a função esta assim:



def metrosQuadrados(*args):

    if len(args) == 1:

        # Calcula metros quadrados da quantidade de alqueires

        resultado = (args[0] * 24200)



    elif len(args) == 2:

        # Calcula metros quadrados com comprimento e largura

        comprimento, largura = args

        resultado = (comprimento * largura)

    else:

        raise ValueError("Deve passar 1 ou 2 argumentos")

    

    if isinstance(resultado, float):

        return round(resultado)

    else:

        return round(resultado, 2)

Nesta função se eu colocar 0.8 que seria 0.8 alqueires, ou 1.5 os resultados são arredondados pela função mas na verdade estou procurando uma forma de retornar os valores corretos conforme passado para a função os resultados desfavoraveis que obtive foi este:



Dimensões área quadrada (Proporção 1:1):

Largura....: 190.53 metros

Comprimento: 190.53 metros

Hectares...: 3.63 ha.

Alqueires..: 1.4999999999999998 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 4:1):

Largura....: 95 metros

Comprimento: 381 metros

Hectares...: 3.63 ha.

Alqueires..: 1.4999999999999998 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 5:1):

Largura....: 85 metros

Comprimento: 426 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5000000000000002 alq.

Metros²....: 36300 m²

Para estas proporcoes de medidas ele retorna até que correto:



Dimensões área retângular (Proporção 1.5:1):

Largura....: 156 metros

Comprimento: 233 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 1.21:1):

Largura....: 173 metros

Comprimento: 210 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 2:1):

Largura....: 135 metros

Comprimento: 269 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 2.21:1):

Largura....: 128 metros

Comprimento: 283 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 2.42:1):

Largura....: 122 metros

Comprimento: 296 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 2.5:1):

Largura....: 120 metros

Comprimento: 301 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 3:1):

Largura....: 110 metros

Comprimento: 330 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 4.5:1):

Largura....: 90 metros

Comprimento: 404 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²



Dimensões área retângular (Proporção 4.84:1):

Largura....: 87 metros

Comprimento: 419 metros

Hectares...: 3.63 ha.

Alqueires..: 1.5 alq.

Metros²....: 36300 m²

Bom o que esta proporção quer dizer? os valores da proporção está relacionado ao comprimento total do lado maior representando o numero de partres, desta metragem, preciso apenas corrigir o programa para funcionar com valores flutuantes, menores que 1: "0.1 ... 0.9" e "1.1 .. 1.9" , "2.1 ... 2.9" e assim por diane retornando maior precisão nos valores proporcionais passados a função "metrosQuadrados(0.1) .. metrosQuadrados(0.9), metrosQuadrados(1.1) .. metrosQuadrados(1.9) ...

Alquem poderia me dar uma luuz sobre como melhorar esta função para que retorne o valor flutuante precisamente sem arredondar para cima ou para baixo retornando no maximo o numero de casas passados na função?

O programa completo é este:



import math



#########################################################################

#

# [-] Autor: Jean César Fernandes Zonta

#

# [-] DateTime: Sun Nov 24 17:28:10 2024

#

# [-] Android App: Editor de Códigos 

#

# [-] Licence: GNU/GPL v2+ 

#

# [-] Language version: Python 3

#

# [-] Programa para calcular a o tamanho e a proporção de uma área

#

# Copyright © 2024 Todos os direitos reservados

#

#########################################################################



def metrosQuadrados(*args):

    if len(args) == 1:

        # Calcula metros quadrados da quantidade de alqueires

        resultado = (args[0] * 24200)



    elif len(args) == 2:

        # Calcula metros quadrados com comprimento e largura

        comprimento, largura = args

        resultado = (comprimento * largura)

    else:

        raise ValueError("Deve passar 1 ou 2 argumentos")

    

    if isinstance(resultado, float):

        return round(resultado)

    else:

        return round(resultado, 2)





def calcQuadrado(area):

    return math.sqrt(area)





def calcRetangulo(area, proportion=1):

    largura = math.sqrt(area / proportion)

    comprimento = (proportion * largura)

    return largura, comprimento





def calcAlqueire(largura, comprimento):

    alqueires = ((largura * comprimento) / 24200)

    

    if isinstance(alqueires, float):

        return alqueires

    else:

        return round(alqueires, 2)





def calcHectare(alqueire):

    hectares = (alqueire * 2.42)



    if isinstance(hectares, float) and hectares.is_integer():

        return round(hectares)

    else:

        return round(hectares, 2)





def calcProportion(comprimento, largura):

    proportion = (comprimento / largura)



    if isinstance(proportion, float) and proportion.is_integer():

        return int(proportion)

    else:

        return float(proportion)



def main():

   

    # Função que transforma alqueires em metros quadrados

    metros = metrosQuadrados(1.5)

    

    # Calcula área retângular com proporção de 1:1

    largura       = calcQuadrado(metros)

    area_quadrada = calcAlqueire(largura, largura)

    proportion    = calcProportion(largura, largura)

    hectares      = calcHectare(area_quadrada)



    print(f"\nDimensões área quadrada (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.2f} metros")

    print(f"Comprimento: {largura:.2f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_quadrada} alq.")

    print(f"Metros²....: {metros} m²\n")





    # Calcula área retângular com proporção de 1.5:1

    largura, comprimento = calcRetangulo(metros, proportion=1.5)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)



    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")





    # Calcula área retângular com proporção de 1.21:1

    largura, comprimento = calcRetangulo(metros, proportion=1.21)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)



    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")





    # Calcula área retângular com proporção de 2:1

    largura, comprimento = calcRetangulo(metros, proportion=2)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)



    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")

    



    # Calcula área retângular com proporção de 2.21:1

    largura, comprimento = calcRetangulo(metros, proportion=2.21)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)



    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")



    

    # Calcula área retângular com proporção de 2.42:1

    largura, comprimento = calcRetangulo(metros, proportion=2.42)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)



    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")





    # Calcula área retângular com proporção de 2.5:1

    largura, comprimento = calcRetangulo(metros, proportion=2.5)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)



    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")



    

    # Calcula área retângular com proporção de 3:1

    largura, comprimento = calcRetangulo(metros, proportion=3)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)



    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")





    # Calcula área retângular com proporção de 4:1

    largura, comprimento = calcRetangulo(metros, proportion=4)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)

    

    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")





    # Calcula área retângular com proporção de 4.5:1

    largura, comprimento = calcRetangulo(metros, proportion=4.5)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)

    

    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")





    # Calcula área retângular com proporção de 4.84:1

    largura, comprimento = calcRetangulo(metros, proportion=4.84)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)

    

    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")





    # Calcula área retângular com proporção de 5:1

    largura, comprimento = calcRetangulo(metros, proportion=5)

    area_retangular      = calcAlqueire(largura, comprimento)

    proportion           = calcProportion(comprimento, largura)

    hectares             = calcHectare(area_retangular)

    metros_quadrados     = metrosQuadrados(comprimento, largura)

    

    print(f"\nDimensões área retângular (Proporção {proportion}:1):")

    print(f"Largura....: {largura:.0f} metros")

    print(f"Comprimento: {comprimento:.0f} metros")

    print(f"Hectares...: {hectares} ha.")

    print(f"Alqueires..: {area_retangular} alq.")

    print(f"Metros²....: {metros_quadrados} m²\n")



if __name__ == "__main__":

    main()

wiki.anon

0 0

Quote

2. Re: Melhorando a precisão de valores flutuantes em python[AJUDA]

alexabolada
(usa Debian)

Enviado em 24/11/2024 - 21:20h

Boa noite! Vamos tentar resolver o problema com a precisão dos valores flutuantes na sua função `metrosQuadrados`.

O seu código atual usa a função `round` para arredondar os resultados, mas isso pode estar causando a perda de precisão que você mencionou. Uma alternativa é limitar a quantidade de casas decimais sem arredondar os números. Para isso, podemos usar a formatação de strings ou a função `format`.

Aqui estão algumas sugestões para melhorar a sua função:

1. Remova o uso do `round` e utilize a formatação de strings para limitar as casas decimais.

2. Vamos fazer algumas modificações na sua função `metrosQuadrados` para que ela não arredonde os valores para cima ou para baixo e retorne a precisão adequada.

Abaixo está a versão atualizada da função:

```python
def metrosQuadrados(*args):
if len(args) == 1:
# Calcula metros quadrados da quantidade de alqueires
resultado = (args[0] * 24200)

elif len(args) == 2:
# Calcula metros quadrados com comprimento e largura
comprimento, largura = args
resultado = (comprimento * largura)

else:
raise ValueError("Deve passar 1 ou 2 argumentos")

# Retorna o resultado formatado com duas casas decimais sem arredondamento
return "{:.2f}".format(resultado)

0 0

Quote

3. Re: Melhorando a precisão de valores flutuantes em python[AJUDA]

dark777
(usa Debian)

Enviado em 24/11/2024 - 21:52h

alexabolada escreveu:

Boa noite! Vamos tentar resolver o problema com a precisão dos valores flutuantes na sua função `metrosQuadrados`.

O seu código atual usa a função `round` para arredondar os resultados, mas isso pode estar causando a perda de precisão que você mencionou. Uma alternativa é limitar a quantidade de casas decimais sem arredondar os números. Para isso, podemos usar a formatação de strings ou a função `format`.

Aqui estão algumas sugestões para melhorar a sua função:

1. Remova o uso do `round` e utilize a formatação de strings para limitar as casas decimais.

2. Vamos fazer algumas modificações na sua função `metrosQuadrados` para que ela não arredonde os valores para cima ou para baixo e retorne a precisão adequada.

Abaixo está a versão atualizada da função:

```python
def metrosQuadrados(*args):
if len(args) == 1:
# Calcula metros quadrados da quantidade de alqueires
resultado = (args[0] * 24200)

elif len(args) == 2:
# Calcula metros quadrados com comprimento e largura
comprimento, largura = args
resultado = (comprimento * largura)

else:
raise ValueError("Deve passar 1 ou 2 argumentos")

# Retorna o resultado formatado com duas casas decimais sem arredondamento
return "{:.2f}".format(resultado)

não dá certo a função tem que retornar um numero decimal.

wiki.anon

0 0

Quote

4. Re: Melhorando a precisão de valores flutuantes em python[AJUDA]

alexabolada
(usa Debian)

Enviado em 24/11/2024 - 21:52h

Olá, wiki.anon!

Entendi a sua dúvida sobre a função `metrosQuadrados`. Se você precisa que a função retorne um número decimal, ao invés de uma string formatada, você pode simplesmente retornar o resultado diretamente, sem usar a formatação de strings.

Aqui está uma versão atualizada da sua função que mantém a precisão como número decimal:

```python
def metrosQuadrados(*args):
if len(args) == 1:
# Calcula metros quadrados da quantidade de alqueires
resultado = (args[0] * 24200)

elif len(args) == 2:
# Calcula metros quadrados com comprimento e largura
comprimento, largura = args
resultado = (comprimento * largura)

else:
raise ValueError("Deve passar 1 ou 2 argumentos")

# Retorna o resultado como um número decimal
return resultado
```

Com essa modificação, agora a função retorna um número decimal sem arredondamento. Se você quiser apenas limitar a exibição desse número em outro lugar, você pode formatá-lo na hora de imprimir ou usar.

Qualquer dúvida ou se precisar de mais ajuda, é só avisar!

0 0

Quote

5. Re: Melhorando a precisão de valores flutuantes em python[AJUDA]

dark777
(usa Debian)

Enviado em 24/11/2024 - 22:47h

alexabolada escreveu:

Olá, wiki.anon!

Entendi a sua dúvida sobre a função `metrosQuadrados`. Se você precisa que a função retorne um número decimal, ao invés de uma string formatada, você pode simplesmente retornar o resultado diretamente, sem usar a formatação de strings.

Aqui está uma versão atualizada da sua função que mantém a precisão como número decimal:

```python
def metrosQuadrados(*args):
if len(args) == 1:
# Calcula metros quadrados da quantidade de alqueires
resultado = (args[0] * 24200)

elif len(args) == 2:
# Calcula metros quadrados com comprimento e largura
comprimento, largura = args
resultado = (comprimento * largura)

else:
raise ValueError("Deve passar 1 ou 2 argumentos")

# Retorna o resultado como um número decimal
return resultado
```

Com essa modificação, agora a função retorna um número decimal sem arredondamento. Se você quiser apenas limitar a exibição desse número em outro lugar, você pode formatá-lo na hora de imprimir ou usar.

Qualquer dúvida ou se precisar de mais ajuda, é só avisar!

mas a sua sugestão volta onde o programa estava anteriormente antes da modificação, pois se retornar o valor da variavel, simplesmente ele retornará algo como:

24200.0 quando deve retornar 24200, e assim sucessivamente conforme a quantidade de metros quadrados da área.

wiki.anon

0 0

Quote

6. Re: Melhorando a precisão de valores flutuantes em python[AJUDA]

alexabolada
(usa Debian)

Enviado em 24/11/2024 - 22:47h

Olá, wiki.anon!

Entendi sua preocupação com o retorno da função `metrosQuadrados`. Para garantir que a função retorne um número inteiro ao invés de um decimal, e apenas o valor necessário sem casas decimais, você pode usar o método `int()` para converter o resultado.

Aqui está a versão atualizada da sua função:

```python
def metrosQuadrados(*args):
if len(args) == 1:
# Calcula metros quadrados da quantidade de alqueires
resultado = int(args[0] * 24200)

elif len(args) == 2:
# Calcula metros quadrados com comprimento e largura
comprimento, largura = args
resultado = int(comprimento * largura)

else:
raise ValueError("Deve passar 1 ou 2 argumentos")

# Retorna o resultado como um número inteiro
return resultado
```

Com essa modificação, a função irá retornar um número inteiro, como 24200, sem casas decimais.

Se você precisar de mais assistência ou tiver outras dúvidas, é só falar!

0 0

Quote