Имея некоторые серьезные проблемы с десятичными типами (сложные круги) Cdecimal

Question

У меня возникли проблемы с десятичными символами.

1. В настоящее время я работаю над некоторыми формулами, которые требуют использования кружков (не Pi) в качестве фактора; или определитель отношения.

2. При использовании данных такого типа я часто использую повторяющиеся бесконечные числа. Есть ли способ убедить Python обращаться с ними как таковыми, не определяя каждое значение самостоятельно через десятичный модуль?

Это требует точного представления при расчете планетарных и атомных орбиталей. Есть миллионы возможностей, поэтому я не могу использовать ловушки или потолки.

For example, I often see rounding errors even with Cdecimal like this one:
initial_input_over_n 
5.500000000000000000000000000000000000000000000000000000000000001
initial_input_over_np 
53.50000000000000000000000000000000000000000000000000000000000001"

Это усугубляется, когда вы начинаете умножать их вместе и делить; где все отношение должно быть 1, потому что это два бесконечных числа (кружка), разделенных вместе, но я получаю выключенное число из-за округленного выбора.

Чрезвычайно важно не допустить округления для этого. Энтропия должна быть удалена из системы.

Это необходимо, потому что мне нужно обработать эти числа до одного определенного числа, чтобы добавить в остальную часть системы, без использования принудительных чисел.

До сих пор я пробовал десятичные типы, но не могу понять, какой будет правильный код, чтобы эти числа оставались такими, как задумано. Я использую столько разных входных данных, что мне нужно, чтобы он был гибким, поскольку он исчисляется сотнями миллионов.

import decimal
from decimal import *
getcontext().prec = 64

input("Press Enter To Continue ...\n\n\n"

"# Input = Total number of points\n"
"# N     = Number of points traveled\n"
"# NP    = Number of points remaining\n\n")

IN = decimal.Decimal (input("Enter Input: "))
N = decimal.Decimal (input("Enter N: "))
NP = decimal.Decimal (input("Enter NP: "))

IN = 0.5 if IN == 0 else IN
N = 0.5 if N == 0 else N
NP = 0.5 if NP == 0 else NP

_input = IN
n = N
np = NP

# - Used to allow lowercase letters in code. Ensures no division by zero 
errors occur.

# input = total number of points
# n     = number of points traveled
# np    = number of points remaining


                     # ----------------- #
                     #    Read Ratios    #
                     # ----------------- #

initial_sine_base       = _input + n + np

initial_sine_input      = initial_sine_base / _input
initial_sine_n          = initial_sine_base / n
initial_sine_np         = initial_sine_base / np

initial_sine_ratio      = initial_sine_input + initial_sine_n + 
initial_sine_np
initial_sine_over_base  = initial_sine_ratio / initial_sine_base

initial_input_over_base = _input / initial_sine_ratio
initial_n_over_base     = n / initial_sine_ratio
initial_np_over_base    = np / initial_sine_ratio

initial_input_over_n    = _input / initial_sine_n
initial_input_over_np   = _input / initial_sine_np
initial_input_over_nnp  = _input / (initial_sine_n + initial_sine_np)

initial_n_over_input    = n / initial_sine_input
initial_n_over_np       = n / initial_sine_np
initial_n_over_inputnp  = n / (initial_sine_input + initial_sine_np)

initial_np_over_input   = np / initial_sine_input
initial_np_over_n       = np / initial_sine_n
initial_np_over_inputnp = np / (initial_sine_input + initial_sine_n)

#Subdivides

check   = (n * _input * np)
unknown = (n * _input * np) / initial_sine_base

#Circle Ratios

plus_one  = (_input + _input + n + n + np) / n
minus_one = (_input + _input + n + np) / n

sub_divide_half = 2

Другим примером является умножение или деление двух одинаковых окружностей;

plus_one  = (_input + _input + n + n + np) / n
minus_one = (_input + _input + n + np) / n

#Circle Ratios
plus_one 33.18181818181818181818181818181818181818181818181818181818181818
minus_one 32.18181818181818181818181818181818181818181818181818181818181818

Как только я начинаю делить их вместе или использовать любые операторы, они распадаются, но в целом они находятся всего в 1 целом числе от другого.

Цель состоит в том, чтобы поддерживать отношения полностью стабильными, поэтому я могу сделать деление половины равным 2 только через входы. Мне просто нужно получить его, чтобы Python вычислял соответствующие соотношения вплоть до точного десятичного числа. Когда я это делаю, все портится, когда я продвигаюсь дальше и ввожу более сложные вычисления.

Все это должно быть сделано только путем деления или умножения, поэтому ярлыки находятся вне стола.

The inputs I used for reference were input = 118, n = 11, np = 107

Answer 1

Например, я часто вижу ошибки округления даже с Cdecimal, как это один: initial_input_over_n 5.500000000000000000000000000000000000000000000000000000000000001

Это может произойти в 2 ситуациях:

1. Вы выполнили операцию с вещественным числом (т. Е. Десятичным числом, созданным путем установки десятичного числа из целого числа или действительного числа; decimal.Decimal(2.5)). Реальное будет неточным и, возможно, будет устанавливать десятичное число в то, что вы не ожидаете. Главный пример: decimal.Decimal(1/3) будет выключен.
2. Скорее всего: Вы не установили округление так, как ожидаете; десятичный модуль поддерживает 8 способов округления. См. документы для доступных значений.

В качестве отступления: следующий код приведет к проблемам:

IN = 0.5 if IN == 0 else IN

Вы устанавливаете IN в число с плавающей запятой, если оно вводится как ноль. Подведет дивизии.

>>> b = d.Decimal('123')
>>> IN = 0.5
>>> b / IN
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for /: 'decimal.Decimal' and 'float'