# Working With Number – Infinity Adding – Decimal, Precise Float Calculation – Python

The previous chapter of Infinity Adding was discussing in regard to storing two integer numbers in string format and how to apply a mathematical addition equation on the two strings of digits by adding one digit at a time to produce an answer.

When we are discussing in regard to a mathematical calculation, one of the important components is how to deal with numbers that have a fractional part. In the computer world, numbers that carry a fractional part are often called float or floating point values. When calculating a floating point value, a majority of computer’s program will not calculate the precise value. Computer’s program will often round a floating point value to get a near precise calculation. Sometimes even on basic mathematical equations that only involved addition, the computer can’t generate a precise floating point calculation.

For example, when you are working within the Python three’s environment and apply this mathematical equation of -2771.71848 + -511349501.829. Python will give you the answer of -511352273.547. Nonetheless, if we were to calculate the answer manually, we know that the correct answer is -511352273.54748. This type of method is the computer’s standard basic method for calculating values with a decimal placement. However, what happened if we truly need a precise decimal point value to be calculated without rounding the answer, and the numbers that involve in the equation have the possibility to have more than five hundred digits behind the decimal? This is chapter two of Infinity Adding, “Decimal, Precise Float Calculation”.

Note: The source code of chapter one and two of the Infinity Addition subject are prototypes. The prototypes purposes are to demonstrate the procedures for adding large numbers together. They are not meant for a production environment due to efficiency issue. Chapter three will have a production version of the source code.

This is a sample log of the result I got from executing the script that attaches to this article compare to Python’s built-in float calculation. For each answer, the one of the left is Python’s answer, and the one on the right is the answer provided by the script at the end of this article.

```Question: -53.78519 + -351803590.5
Python Answer: -351803644.285 | infiA: -351803644.28519

Question: -8991.44839 + -572899167.283
Python Answer: -572908158.731 | infiA: -572908158.73139

Question: -6902.31431 + -575112629.308
Python Answer: -575119531.623 | infiA: -575119531.62231

Question: -5576.33772 + -619783977.418
Python Answer: -619789553.756 | infiA: -619789553.75572

Question: -7965.24203 + -149464159.521
Python Answer: -149472124.763 | infiA: -149472124.76303
```

### How To Add Two Floating Numbers Together In String Format

When storing numbers with a fractional part in string format, the first challenge we would have when we are applying a mathematical equation on the string is the digits behind the decimal. The string of number can be split into an array, where one index of the array holds the digits before the decimal and the other index holds the digits behind the decimal. Nevertheless, there is a high possibility that the amount of digit behind the decimal that each string has can vary. That can be solved by padding zeroes on the right of the shorter string to make both strings of number contain the exact same amount of digits behind the decimal.

Besides array, we can also split one string with the fractional part into two strings. After the split, one string can carry the digits before the decimal, and the other string can carry the digits behind the decimal. Thus, if we were going to add two strings of numbers that contain a fractional part together, we can have up to four strings. An example of this would be if we were to add A and B together where both A and B does contain a fractional part. Then we would split A into two. Where A1 can contain the digits before the decimal and A2 contains the digits behind the decimal. The same scenario would also apply to B1 and B2.

In this chapter, the majority of the information is in regard to the source code and explanations of the programming procedures for the source code.

Let first start with evaluating the input value of the string. First I use a conditional statement to test if the string is positive or negative in value by looking at the first character in the string. If the first character in the string is a negative sign, the variable isaNeg will be assigned with the value of one, of which can also be equal to a boolean value of true. For anything else, we assign a zero value to isaNeg. To get a character by position in Python, we could use the <string_variable_name>[<position>] option. Which can grab a character from the inputted position in a string, with the zero position being the first position in the string.

Note that you can also use a boolean declaration here with a true or false value. Nevertheless, I used a digit value here for isaNeg in the prototype to demonstrates another method for evaluating and storing a true or false value.

```isaNeg = 1 if a is "-" else 0
```

After evaluating whether if the string can be a negative value or not, I removed any plus or minus sign using the lstrip() function of Python. The lstrip() function will trim both the minus and the plus sign from the left side of the string. We would also want to remove leading zeroes. This is because leading zeroes before the decimal do not offer any additional value to the number.

```a = a.lstrip("+-")
a = a.lstrip("0")
```

We would then need to initialize a third evaluation on the input. If the user input .123 without putting a zero in front of the decimal then we have to append a single zero to the front of the decimal. Therefore, we would evaluate whether if the first character of the string is a decimal. If it is a decimal, we add a zero to the string. If the first character is not a decimal, the string will be itself. For this procedure in Python, we could either use the “re” library for regex conditional evaluation. Nevertheless, we can just simply check the first position of the string using the “[]” option. Then we can evaluate for whether if that position does contain a decimal.

```a = "0" + a if (a is ".") else a
```

After the above evaluation, I then evaluate if the string does contain a decimal by using Python’s built-in “in” keyword. If the string does contain a decimal, I would use Python’s split() function on A string’s value. If there is only one decimal, the split() function will return two arrays. The first array, which is the array with the 0 index. That array will hold the digits that are before the decimal. The second array, which is the array with the 1 index. That array will hold the digits that are behind the decimal.

When splitting the value of variable A, I assigned the value from array one to a variable named adec. Array one is the ending part of the string which is the right side of the decimal. Thus, adec is now holding the digits that are behind the decimal. Since trailing zeroes on the right side of the decimal do not alter the value of the number in any way, I then removed all the trailing zeroes from variable adec. I will then use the split() function on A variable’s value to assign A variable with the digits that are before the decimal. After the procedure, variable A is now holding all the digits that are before the decimal.

```if ("." in a):
a = a.split(".")
```

When it comes to the strings that contain the digits behind the decimal, in the event where they do not contain a value, it would be very inefficiency to add the empty strings together. Also, the digits behind the decimal have to be added together first before the digits before the decimal. To be able to execute the equation efficiently, we would have to wrap our code block for adding the digits behind the decimal right before the code block for adding the digits before the decimal. On the first two lines of the below code, adeclen and bdeclen are the lengths of the strings that contain the digits behind the decimal. The if statement code block will only execute if either one of the lengths of the strings that contain the digits behind the decimal is higher than zero. In others word, either adec or bdec need to have a length for the code block to execute.

```adeclen = len(adec)
bdeclen = len(bdec)
if (adeclen > 0 or bdeclen > 0):
# Equation code goes here
```

While reading through the strings in a while loop or in a for loop, let assume the “i” variable is the index count and we will use it as the read position value to get a digit from our strings. We would only read the string that contains the digits behind the decimal if the current position value in the “i” variable is lower than the string’s maximum length. If the read position is within the string length, we would get a digit from that string at that position. Then we would convert the digit that we just obtained to an integer format. For anything else, we assign a value of zero in lieu of the string’s value.

```x = int(adec[i] if i < adeclen else 0
```

When calculating the carry-over value for the next equation, we simply evaluate if the temporary answer’s value is higher than nine. If the temporary result value is higher than nine then we would assign one to the carry-over value. In a mathematical addition equation that only involves two sets of digits then the carry-over value can never be larger than the value of one. In the temporary result value, for anything else that is below the value of nine, we would assign a zero value to the carry-over value.

When assigning a value to the output, it is a constant that we will always assign the rightmost digit from the temporary answer to the left of the output string. We can base our evaluations on two conditions to get the rightmost digit from the temporary answer. If the result value is higher than nine, we take a value of ten and subtract to the temporary result value. For anything else, we simply keep the result value. This method can only be applied to a mathematical addition equation. Also, we can only apply this method when adding only two sets of digits together. This is because the carry-over value can never be larger than a value of one.

```temp = x + y + carryOver
carryOver = 1 if temp > 9 else 0
temp = temp - 10 if temp > 9 else temp
output = str(temp) + output
```

After adding the entire two strings of digits behind the decimal together and the output string contained the full result value for the equation. We would then need to append a decimal point to the front of the output string before going into our next calculation. We then check for any zeroes to the right of the output string and remove all ending zeroes. As opposed to a whole number, trailing zeroes to the right side of the digits that are behind a decimal point do not provide any additional value. After removing all the zeroes, if the last character is only the decimal then we would also remove the decimal. The previous two procedures are done through the rstrip() and the replace() function. The rstrip() function which will strip the right side on the string from any zeroes. Then the replace() function will remove the decimal from the output variable in the event where the leftmost character of the string is the decimal.

```output = "." + output
output = output.rstrip("0")
output = output.replace(".","") if (output[len(output) - 1] is ".") else output
```

The above explanations are important code lines for adding a positive number to a positive number. Let discuss some important code lines for adding a positive number to a negative number. Or a negative number to a positive number. The principles for adding a positive value to a negative value can be described as subtracting the two values. The result value from this type of equation will carry the same negative or positive base as the larger value.

The example below is for the event of when the first string of input being the higher value string. In the first code line, we are subtracting the first string’s digit to the second string’s digit then to any carry-over value. For the second code line, we are assigning a carry-over value bases on a condition. If the result value is less than zero then we assign a value of one to the carry-over value. Otherwise, a value of zero is assigned to the carry-over value. This is easy to achieve when we are only dealing with two sets of digits. If we were dealing with more than two sets of digits then we would have to implement another method.

On the third code line, if the result value is less than zero, or in others word, a negative value. Then we would take a value of ten and add to the result value. Otherwise, we would not alter the result value. We then place the result value to the left of the output string, the code statement for this is on the fourth code line.

```temp = x - y - carryOver
carryOver = 1 if temp < 0 else 0
temp = 10 + temp if temp < 0 else temp
output = str(temp) + output
```

The above is if the first input string is higher in value. When it’s come to the second input string that is higher in value, the equation’s procedures do not change, nevertheless, there are differences between the two equation. When comparing the first line of code to the above equation’s procedure, we are still subtracting the first string’s digit to the second string’s digit. Nonetheless, instead of subtracting to the carry-over value, we are now adding to the carry-over value. The main change in how we are assigning the carry-over value is the temporary result value has to be larger than zero for us to assign a value of one to the carry-over value.

On the third code line below, the ending is very important. The temporary result value that does not need to be modified is now negative in value. If we are going to convert a negative integer value to a string type format and then placing the value to the output string, we would have a minus sign between every digit. Thus, we can either subtract the temporary result value to itself twice to reach its positive value, convert the temporary result value to a string type and grab the rightmost digit, or simply, multiply the result value to a negative value of one.

```temp = x - y + carryOver
carryOver = 1 if temp > 0 else 0
temp = 10 - temp if temp > 0 else (temp - temp - temp)
output = str(temp) + output
```

The code is below is the full function of this tutorial.

```# "Copyright Notice", please do not remove.
# Written by Kevin Ng
# The full tutorial on this subject can be found @ http://kevinhng86.iblog.website or http://programming.world.edu.
# Release date to http://programming.world.edu will lag one week after release on http://kevinhng86.iblog.website
# This source code file is a part of Kevin Ng's Z library.
# This source code is licenses under CCDL-1.0  A copy of CDDL1.0 can be found at https://opensource.org/licenses/CDDL-1.0

# Notice: This is version 2 of infiA from Kevin Ng's LibZ library.
#         This is not a production version and is a prototype.
#         This version has been tested, but would be too slow in a production environment.
#         This version of infiA support mathematical addition with the decimal.

class libZ:
def infiA(self, a, b):
isaNeg = 1 if a is "-" else 0
isbNeg = 1 if b is "-" else 0
a = a.lstrip("+-")
b = b.lstrip("+-")
a = a.lstrip("0")
b = b.lstrip("0")
a = "0" + a if (a is ".") else a
b = "0" + b if (b is ".") else b
bdec = ""

if ("." in a):
a = a.split(".")

if ("." in b):
bdec = b.split(".")
bdec = bdec.rstrip("0")
b = b.split(".")

aidx = len(a) - 1
bidx = len(b) - 1
bdeclen = len(bdec)
x = 0
y = 0
carryOver = 0
temp = 0
output = ""

if (isaNeg == isbNeg):
if (adeclen > 0 or bdeclen > 0):
i = (adeclen - 1) if (adeclen > bdeclen) else (bdeclen - 1)
while (i > -1):
y = int(bdec[i]) if i < bdeclen else 0
temp = x + y + carryOver
carryOver = 1 if temp > 9 else 0
temp = temp - 10 if temp > 9 else temp
output = str(temp) + output
i = i - 1
output = "." + output
output = output.rstrip("0")
output = output.replace(".", "") if (output[len(output) - 1] is ".") else output

while (aidx > -1 or bidx > -1):
x = int(a[aidx]) if aidx > -1 else 0
y = int(b[bidx]) if bidx > -1 else 0
temp = x + y + carryOver
carryOver = 1 if temp > 9 else 0
temp = temp - 10 if temp > 9 else temp
output = str(temp) + output
output = str(carryOver) + output if (aidx < 1 and bidx < 1) else output
aidx = aidx - 1
bidx = bidx - 1
output = output.lstrip("0")
output = "0" + output if (len(output) < 1 or output is ".") else output
return "-" + output if (isaNeg == 1 and isbNeg == 1) else output
elif (isaNeg != isbNeg):
larger = "a" if (len(a) > len(b)) else ("b" if (len(b) > len(a)) else "1")
if (larger is "1"):
larger = ""
for i in range(0, len(a)):
larger = "a" if int(a[i]) > int(b[i]) else larger
larger = "b" if int(b[i]) > int(a[i]) else larger
larger = "0" if (i == len(a) - 1 and len(larger) < 1) else larger
if (len(larger) > 0):
break
if ((adeclen > 0 or bdeclen > 0) and larger == "0"):
for i in range(0, idx):
y = int(bdec[i]) if i < bdeclen else 0
larger = "a" if (x > y) else ("b" if (y > x) else "0")
if (larger is "a" or larger is "b"):
break
if (larger is "0"):
return larger
elif (larger is "a"):
if (adeclen > 0 or bdeclen > 0):
i = adeclen - 1 if (adeclen > bdeclen) else bdeclen - 1
while (i > -1):
y = int(bdec[i]) if i < bdeclen else 0
temp = x - y - carryOver
carryOver = 1 if temp < 0 else 0
temp = 10 + temp if temp < 0 else temp
output = str(temp) + output
i = i - 1
output = "." + output
output = output.rstrip("0")
output = output.replace(".", "") if (output[len(output) - 1] is ".") else output
while (aidx > -1):
x = int(a[aidx])
y = int(b[bidx]) if bidx > -1 else 0
temp = x - y - carryOver
carryOver = 1 if temp < 0 else 0
temp = 10 + temp if temp < 0 else temp
output = str(temp) + output
aidx = aidx - 1
bidx = bidx - 1
output = output.lstrip("0")
output = "0" + output if (len(output) < 1 or output is ".") else output
return "-" + output if (isaNeg == 1) else output
elif (larger is "b"):
if (adeclen > 0 or bdeclen > 0):
i = adeclen - 1 if (adeclen > bdeclen) else bdeclen - 1
while (i > -1):
y = int(bdec[i]) if i < bdeclen else 0
temp = x - y + carryOver
carryOver = 1 if temp > 0 else 0
temp = 10 - temp if temp > 0 else (temp - temp - temp)
output = str(temp) + output
i = i - 1
output = "." + output
output = output.rstrip("0")
output = output.replace(".", "") if (output[len(output) - 1] is ".") else output
while (bidx > -1):
x = int(a[aidx]) if aidx > -1 else 0
y = int(b[bidx])
temp = x - y + carryOver
carryOver = 1 if temp > 0 else 0
temp = 10 - temp if temp > 0 else (temp - temp - temp)
output = str(temp) + output
aidx = aidx - 1
bidx = bidx - 1
output = output.lstrip("0")
output = "0" + output if (len(output) < 1 or output is ".") else output
return "-" + output if (isaNeg == 0) else output

c = "999999999999999999999999999999.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
d = "999999999999999999999999999999.999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"
print(libZ().infiA(c,d))``` Copyright secured by Digiprove © 2017

This post was written by Kevin and was first post @ http://kevinhng86.iblog.website.
Original Post Name: "Working With Number – Infinity Adding – Decimal, Precise Float Calculation – Python".
• 