Utilizing Semi-structured Complex Numbers to Develop the First Division by Zero Calculator

1. Introduction

1.1. Semi-structured complex numbers: a recent development in division by zero

Recently there has been a range of research involving division by zero. Table 13, Appendix 1, shows sample of such research conducted from 2018 to 2022 on “division by zero” including using division by zero to explain cancer development. The problem of division by zero can simply be stated as: What is $\frac{a}{0}$ where “a” is any complex number. There have been several solutions to the problem the most recent being the invention of the semi-structured complex number set $ℍ$ [1]. The first attempt at creating this number set was riddled with issues [1], however, a second paper [2] was written to reformulate and strengthen the theory of semi-structured complex numbers and in the process produced several profound results. Table 1 shows the major results developed in paper [2].

Results 1 to Result 9 in Table 1 provide some significant foundational results for semi-structured complex numbers. Nevertheless, it is necessary to go beyond just the foundational setting and look at how this new number set can be applied in a practical setting particularly in the area computer science where real world problems are constantly being modelled and solved using mathematical tools.

1.2. Potential importance of Semi-structured complex numbers to computer science

Computers are generally run on computer programs (software). On a fundamental level these computer programs consist largely of arithmetic and logic operations. In writing and running a computer program, errors can occur. These errors are often called “exceptions”.

An exception is an event, which occurs during the execution of a program, that disrupts the normal flow of the program's instructions [3]. There are several types of program exceptions one of the most fundamental being a Run-time exception. Examples of this type of exception include a user entering invalid input into a program or a program attempting to divide by zero [4].

If a program has several statements and an exception happens midway through its execution, the statements after the exception do not execute, and the program crashes. To prevent this, exceptions are usually handled in a process called “Exception Handling”. In exception handling specialised computer program instructions are used to tell the computer program what to do if an exception occurs. An example of such instructions is the popular “try-catch blocks” (or some variation of this) used in many programming languages. This is shown in Figure 1.

The "Try block” is a computer instruction that detects the exception (or error) during program execution and the “Catch block” tells the computer program what to do to deal with (or handle) the exception or error. Although exception handling is common practice in computer programs, they do have several disadvantages. These are given in Table 2.

Since most computer programs use real and or complex number arithmetic in their operations, “division by zero” can caused Run-time exceptions. Considering the disadvantages listed in Table 2, it would be ideal to reduce run-time exceptions caused by “division by zero”. This can easily be done if semi-structured complex numbers are used in computer programming.

However, proving the utility of such numbers in computer programming requires comparing the performance of a computer program when semi-structured numbers are implemented in that program verses when exception handling is used instead. Very little has been done to show such a comparison.

1.3. Semi-structured complex numbers and a division by zero calculator

One of the simplest programs that can be written to show the utility of semi-structured complex numbers is an arithmetic calculator program.

In the standard arithmetic calculator, users can enter valid arithmetic equations and the calculator produces a result. Equations are generally entered in what is called “infix notation”. Infix notation operators such as $+,÷,\times ,-$ lies between a pair of operands (numbers or letters). An example of infix notation is $2+3$.

The calculator converts the infix notation into postfix notation. In postfix notation the operator is followed by every pair of operands. For example, $2+3$ in postfix notation becomes $2 3+$. The calculator then evaluates the postfix expression. Table 3 provides three further examples of infix and postfix expressions.

Infix expressions are readable and solvable by humans who can easily distinguish the order of operators and use the parenthesis to solve parts of equations before others. Computer calculators have difficulty efficiently evaluating infix expressions (being unable to differentiate between parenthesis and operators). Therefore, infix expressions are generally converted to postfix form and then evaluated by the calculator.

Arithmetic equations entered by the user can easily contain division by zero. In standard arithmetic calculators whenever division by zero occurs the program halts and some exception handling occurs. It would be instructive to write a standard arithmetic calculator that can perform division by zero operations to determine how well the program would perform under thousands of random calculations including calculations involving division by zero. Such a calculator would need to be made to execute arithmetic operations on semi-structured complex numbers. However, very little has been done to pursue such an endeavour.

1.4. Measuring the performance of a division by zero calculator

When creating a computer program, it is important to measure the performance of the computer program against some standard or benchmark. In such cases performance metrices and a well-known benchmark are needed.

In general, the performance of a computer program is measured in terms of its efficiency. Algorithm efficiency relates to how many resources a computer needs to expend to process an algorithm. When creating an algorithm, it is important to make it as streamlined as possible, so it does not strain the software or device that runs it. If an algorithm is not efficient, it is not considered fit for its purpose. Two main measures of algorithm efficiency are space complexity and time complexity. Space complexity measures how much memory is used to process the input and output of the algorithm as well as the algorithm itself [6]. On the other hand, the time complexity measures how long it takes to process the algorithm [7].

Space complexity is the measurement of total space required by an algorithm to execute properly. For example, the input memory space complexity can simply be a measure of the size of the file (in bytes or kilobytes) containing the input data for the program. Likewise, the output space complexity can be a measure of the size of the file (in bytes of kilobytes) containing the output data for the program. The amount of memory required to run a program can be measured in many ways. The best algorithm should have a low level of space complexity. The less space required, the faster it executes.

Most computer languages generally have functions (special computer instructions) to measure time complexity for a computer program. For example, in Python (one of the most popular computer languages used today) functions such as time.start() and time.stop() are placed before and after a computer program respectively and are used to measure the start and stop times for a computer program. Subtracting the values produced by these functions gives the runtime of the computer program. When comparing two algorithms to solve the same problem, the algorithm with the smaller time complexity is considered the better of the two algorithms. To show that the division by zero calculator is useful it must outperform a standard arithmetic calculator in terms of efficiency (that is, in terms of the space and time complexity).

1.5. Major Contributions of this research

Given the potential importance of semi-structured complex numbers in computer science, the aim of this paper was:

To demonstrate the utility of semi-structured complex numbers in computer science by developing a division by zero calculator.

In the process of achieving the stated aim, the following major contributions are made in this paper:

1.

A representation for semi-structured complex numbers that enables it to be easily used in arithmetic operations by a computer program was developed. The semi-structured complex numbers $x+yi+zp$ is represented by the 3-tuple (or ordered triple) given by $\left(x,y,z\right)$.

2.

It was demonstrated that the division by zero calculator outperforms the standard calculator in terms of efficiency (that is space and time complexity).

3.

It was shown that the number set $ℍ$ reduced the amount of error handling required to run a computer program.

The rest of this paper is devoted to providing a detailed explanation of how the major contributions outlined were arrived at.

2. Method

2.1. Representing semi-structured complex numbers for use in a computer program

The first step was to represent a typical semi-structured complex number in a simple form that can be used in a computer program. In this case, the computer program would be an arithmetic calculator. The typical semi-structured complex number has the form:

$$x+yi+zp$$

(3)

Here $x,y,z$ are real numbers. The numbers $x,y,z$ are the important aspects of the semi-structured complex numbers. For the calculator created in this paper, the semi-structured complex number can simply be represented as a triple written as $x, y, z$. Hence:

$$x+yi+zp=x,y,z$$

(4)

The format shown in Equation (4) is called semi-structured complex triple format. More examples of this format are given in Table 4.

The advantage of this format is that it is unambiguous in terms of meaning and very little space is required to store a semi-structured complex number.

2.2. Develop a semi-structured complex numbers equation generator

With the representation of semi-structured complex numbers given in Equation (4) it is now simple to generate arithmetic equations that can be used to evaluate the efficiency of a calculator. Hence, an equation generator was developed to create equations to be evaluated by both a standard and a division by zero calculator. The equations produced are random but valid infix equations consisting of operators ($+,÷,\times ,-$) and semi-structured complex number operands that have the form $x,y,z$. Collectively, these operators and operands are called tokens. The rules for generating a random arithmetic equation are simple:

i.

Generate a random odd number greater than or equal to three. The random odd number indicates the number of tokens (arithmetic operators and operands) that the equation would have. The number of tokens must be a minimum of three tokens, that is, an operand followed by an operator followed by another operand. Every valid equation greater than three tokens in length will have an odd number of tokens.

ii.

Every equation must start and end with an operand.

iii.

Operators were always in even positions within the infix expression and operands always in odd positions.

iv.

For the sake of simplicity brackets were not produced in the infix expressions, instead the precedence of operators indicated the order in which operators were to be evaluated.

With these rules, the algorithm for the semi-structured complex numbers equation generator is given in Table 5. From Table 5 the variables, (minimum operand value, maximum operand value) in line 1 of the algorithm represented the range of numbers used in the semi-structured complex triple $x,y,z$. Each component of the triple will have an integer value that falls within the range (minimum operand value, maximum operand value). This gives the user control of the values in the semi-structured complex number triples. Additionally, equation length (L) represented the length of the equation to be generated. This number must always be odd.

Examples of the sort of equations generated by the algorithm shown in Table 5 are given in Table 6.

All the equations shown in Table 6 are valid infix expressions containing semi-structured complex number operands. These equations are evaluated according to the normal rules of semi-structured complex number arithmetic given in paper [2].

2.3. Developing common algorithms for calculator programs

Both the division by zero calculator and the standard calculator share the same basic algorithms and only differ in the way they handle the division by zero operation. These algorithms are discussed here in turn.

2.3.1. The Postfix Convertor

Once the algorithm for the equation generator was created the next step was to create an infix to postfix evaluator. The algorithm for the infix to postfix evaluator is given in Table 14 in Appendix 2. From Table 14 the variable “Operator stack” is a stack used to store the operands as the algorithm runs. A stack can be thought of as a container where operators and operands can be placed (pushed) on top of each other. Only the token on top of the stack can be removed (or popped) first. Users of a stack can also see (or peek) the token at the top of the stack without removing the top token.

2.3.2. The Postfix Evaluator

Once the equation generated has been converted from infix to postfix format, the postfix expression must be evaluated. The general postfix evaluator is given in Table 15 in Appendix 2. The primary part of the postfix evaluator is the “Arithmetic Machine” which performs the actual arithmetic on the operand given to the postfix evaluator.

2.4. Developing an Arithmetic Machine for a standard and a division by zero calculator

Two “Arithmetic Machines” were developed for this research. The first was an arithmetic machine for the standard calculator “Arithmetic Machine STD” and the second was an arithmetic machine for the division by zero calculator “Arithmetic Machine DBZ”.

A standard arithmetic calculator has only 4 basic operations addition, subtraction, multiplication, and division. Modern calculators will show an error message when division by zero is performed. In which case the user of the calculator must reset the calculator before the calculator can be used to perform another arithmetic operation.

In the standard calculator developed for this paper when the calculator faces a division by zero operation it will output an error and the calculator will use a try-catch statement to deal with the division by zero error. The try catch statement will show an error message and reset the calculator for the next equation to be processed. This operation is part of the “Arithmetic Machine STD” given in Table 7 for the standard calculator. The “Arithmetic Machine STD” given in Table 7 takes two semi-structured complex numbers $x,y,z$ and $a,b,c$ and performs one of the simple arithmetic operations on these numbers.

In the algorithm shown in Table 7, the try catch statement for division by zero is given in lines 7 to line 8. If the second operand is not zero, then the try catch statement is not executed and the algorithm continues to line 9. The algorithm also has a “Multiply” function in line 11 and line 13. This function is given in Table 16 in Appendix 2. This “Multiply” function multiplies two semi-structed complex numbers according to the normal rules of multiplication for semi-structured complex numbers given in paper [2].

The “Arithmetic Machine DBZ” algorithm for the division by zero calculator was similar to the algorithm shown in Table 7. However, the “Arithmetic Machine DBZ" handles division by zero differently as shown in Table 8.

In the algorithm shown in Table 8, if the second operand is zero, then the algorithm simply changes the second operand (line 7) to the unstructured unit value $p$ (represented as the triple 0,0,1 in semi-structured complex number format shown in Equation (4)) where $p=\frac{1}{0}$. The algorithm then goes on to use the “Multiply” function in line 10. This function is given in Table 16 in Appendix 2.

The final general algorithm for both the standard calculator and the division by zero calculator is given in Table 9.

All the algorithms discussed thus far was developed and executed on an online Python platform [8]. The speed of the platform was largely dependent on the speed of the servers on which the platform was ran. Since both calculators was ran from this platform, it provided a uniform starting point to evaluate their efficiency.

2.5. Simulation procedure to compare standard and division by zero calculator

To determine the efficiency of the standard calculator and the division by zero calculator, the space and time complexity of both calculators were compared. The measures for space and time complexity are given in Table 10.

To begin, the space complexity for the standard calculator was first examined. This was done by examining the processing and output memory involved in running the standard calculator. The standard calculator was put through 20 simulations.

For the first simulation, 1000 equations were randomly generated (equation generator is given in Table 5) with each equation having a length (L) of 5 tokens. The 5 tokens consisted of 2 operators chosen at random from the group $\left[\times ,÷,+,-\right]$ and Three operands in the form $\left(x,y,z\right)$ with each component of the operand being integers generated within the range $-1$ to $1$. The range was kept small to increase the probability that there was division by zero operations within the set of 1000 equations.

The average number of operations per equations was found using the equation $\frac{L-1}{2}$, where L is the length of the equation (number of tokens). This value was recorded as the variable “No. of operations per equation”.

In the process of generating the equations the number of equations with division by zero was calculated and recorded as the variable “No. of Equations with division by zero operations”. This was calculated by parsing each equation to determine if it had the subsequence “/ 0,0,0”. If the subsequence existed, then the equation was recorded as having a division by zero operation.

Additionally, the number of division by zero operations that exist across all 1000 equations was calculated and recorded in the variable “Total no. of division by zero operations”. The “No. of operations per equation”, “No. of Equations with division by zero operations” and “Total no. of division by zero operations” represent the characteristics of the equations that was processed by the standard calculator.

The 1000 equations were fed into the standard calculator algorithm (shown in Table 9 with the user input for type of “Arithmetic machine” set to 1), and the total memory used to process all the equations was calculated and recorded. This was done using the Python functions tracemalloc.start() and tracemalloc.stop(). The result was recorded in the variable “Total Processing Memory”. The total number of equations successfully calculated (that is equations that did not throw any exception errors) was recorded in the variable “No. of equations successfully computed”.

The average processing memory per operation was calculated then recorded. This was done using the following formula given in Equation (5). This value was recorded as “Average Processing Memory Per operation”.

$$\frac{Total Processing Memory}{No. of operations per Equation\times No. of Equations successfully completed}$$

(5)

In cases where an equation had division by zero in the standard calculator, the calculator did not compute a result but threw an exception and an error message was displayed and recorded as output.

After calculating the result of each equation, the output of the results of all 1000 equations were recorded in a text file. The total output memory (the size of the text file in bytes) was then recorded.

Once the space complexity of the standard calculator was examined the time complexity for the calculator was also examined. The total time taken to process all 1000 equations for the first simulation was calculated using the Python functions time.start() and time.stop(). The function time.start() was placed at the beginning of the standard calculator function to start measuring processing time and time.stop() was placed at the end of the standard calculator function to end the measurement. The time taken to process one equation was given by Equation (6).

$$time taken=time.start()-time.stop()$$

(6)

The total time taken to process all 1000 equations was recorded as “Total Processing Time”. The number of operations successfully computed by the standard calculator per unit time was calculated using Equation (7).

$$\frac{No. of operations per Equation\times No. of Equations successfully computed}{Total Processing Time}$$

(7)

The result was recorded as “No. of operations per unit time”.

Once the space and time complexity for the standard calculator for the first simulation was determined, the process of calculating the characteristics of the equations, the space complexity and the time complexity of the standard calculator was repeated for 19 more simulations. For each simulation the length (L) of the equations was increased by 10 tokens from the previous simulation. The results were then tabulated.

The entire process of calculating the characteristics of the equations, the space and time complexity for 20 simulations of 1000 equations was repeated for the division by zero calculator. The results were then tabulated.

After the results were tabulated for the standard calculator and the division by zero calculator, three graphs were drawn. The first graph was a graph of “Average processing Memory per operation vs. Number of division by zero operations”. This graph was meant to determine how processing memory was affected by the presence of division by zero operation.

The second graph was a graph of “Total Output memory vs. Number of equations with division by zero”. This graph was meant to determine how the two calculators handle division by zero affected the amount of memory needed to output the results.

Finally, a graph of “Number of operations per unit time vs. Total number of operations” was plotted. The first two graphs provide a deeper look at the space complexity of the two calculators, whilst the final graph provides a closer look at the time complexity of the calculators.

3. Results

Table 11 and Table 12 shows the results of the simulations conducted on both the standard calculator and the division by zero calculator respectively. From Table 11 and Table 12 as the length of the equations increased the number of operations per equation, number of equations with division by zero, and total number of divisions by zero operations also increased. This implies that the complexity of the equations increased with each successive set of simulations. The space and time complexity columns indicated how well each type of calculator handled the increase in equation complexity.

In terms of space complexity, the total processing memory required to process the 1000 equations per calculator was slightly less with the standard calculator and more with the division by zero calculator. This is probability due to the standard calculator having less to process than the division by zero calculator. Recall that the standard calculator could not process division by zero calculations or division by zero equations. This is clearly seen in the final column of Table 11. Here the standard calculator only processed between 563 to 975 equations out of the 1000 equations given to it across the 20 simulations.

However, when the graph of “Average processing memory per operation vs. Total number of divisions by zero operation” it was clear that the average memory per operation was lower with the division by zero calculator. This implies that there were more successful operations per unit of memory with the division by zero calculator than with the standard calculator as the number of operations (specifically division by zero operations) increases. This is clearly seen in Figure 2.

Additionally, from Table 11 and Table 12 when the total memory output was considered it was clear that the division by zero calculator required less memory to output its results as the complexity of the equations increased (and the number of division by zero operations). This is very likely because every time the standard calculator encountered a division by zero operation it would output an error message (which required more output space than printing a simple numerical answer). Figure 3 illustrates this point more clearly.

When “Total output memory vs. Number of Equations with Division by Zero” is plotted for both the division by zero and standard calculator it was clear that the division by zero calculator outperformed the standard calculator requiring significantly less memory to output its results as the number of division by zero operations increases. Therefore overall, in terms of space complexity, the division by zero calculator outperformed the standard calculator.

Turning attention to time complexity, from Table 11 and Table 12 when the Total Processing Time is considered, the standard calculator showed a smaller time spent processing the equations. Nevertheless, the lower processing time for the standard calculator can be attributed to the fact thar the standard calculator successfully processed less equations than the division by zero calculator.

The difference in time complexity between the two calculators is more clearly seen in Figure 4, when the “Number of operations per unit time against the Total Number of operations” is compared for both calculators.

Clearly from Figure 4, the division by zero calculator was able to process more successful operations per unit time than the standard calculator (this considering that the division by zero calculator was able to successfully process division by zero operations). Therefore, in terms of time complexity the division by zero outperformed the standard calculator.

From the overall results it was also clearly seen that removing the try catch statements to handle division by zero exceptions improved the efficiency of a calculator program. Hence the division by zero calculator outperformed the standard calculator in terms of space and time complexity and thus was considered more efficient than the standard calculator.

4. Discussion

The development of semi-structured complex numbers to resolve division by zero has already proven itself to be useful and a few papers has already been written about the topic. The division by zero calculator developed in this paper is the first of its kind. In this paper it was shown that a division by zero calculator can perform more efficiently than a standard calculator.

Division by zero calculator can be used in science and engineering where singularities that arise in the modelling of real-world problems needs to be solved. Division by zero calculator can also be used to calculate the inverse of singular matrices as well as any other topic where division by zero may appear.

More research and rigorous testing can be done to determine how the division by zero calculator can be improved upon. For example, the division by zero calculator developed here only considered 4 basic arithmetic operations ($+,÷,\times ,-$). However, a more advanced version of the division by zero calculator that considers exponentials, logarithms, trigonometric and hyperbolic operations can be developed. The mathematic operations for these advanced functions have already been developed in other papers on the topic of semi-structured complex numbers. Additionally, calculators capable of graphing division by zero outcomes should also be considered.

5. Conclusion

In this research a division by zero calculator was created and its operational efficiency was tested and compared to the efficiency of a standard calculator. The efficiency of the calculator was measured in terms of space and time complexity.

In the process of determining the efficiency of the calculator four major contributions were made: (1) A representation for semi-structured complex numbers that enables it to be easily used in arithmetic operations by a computer program was developed. The semi-structured complex numbers $x+yi+zp$ is represented by the 3-tuple (or ordered triple) given by $\left(x,y,z\right)$. (2) It was demonstrated that the division by zero calculator outperforms the standard calculator in terms of efficiency (that is space and time complexity); and (3) It was shown that the number set $ℍ$ reduced the amount of error handling required to run a computer program.

The division by zero calculator can be used anywhere that division by zero needs to be calculated. The development of the division by zero calculator provides a firm foundation to advance the number set $ℍ$ as a useful mathematical tool in computer science.