WO2018116483A1 - Calculation using numerical values represented inside a computer in undecimal or higher positional notation - Google Patents

Abstract

The present invention utilizes numerical values represented inside a computer in undecimal or higher positional notation to achieve an accurate numerical calculation of a larger number than in the prior art at a higher speed. The nature of the present invention is to pay attention to one having a high share among various costs in a numerical calculation utilizing an array structure and look for "an event such as improves another value while the deterioration of a specific value is kept small (or prevented from occurring)". By using the present invention, the upper limit of numbers that can be treated is dramatically improved. For example, as of 2016, by combining a personal computer and hardware that are generally on the market, such a level that "it becomes possible to perform a numerical calculation of tens of millions of figures to one trillion figures within a time that is not unrealistic" is reached.

Description

Calculations using numerical values expressed in the computer by the decimal notation method of the decimal system or higher

The present invention relates to a numerical calculation using an array structure. More specifically, an accurate numerical calculation for a larger number is realized at a higher speed by using a numerical value expressed inside the computer by an arbitrary scale method. A software that reproduces the "order of bits and their behavior at the hardware level", extends it, and executes operations, thereby realizing accurate numerical calculations for larger numbers faster. It can be regarded as.

The essence of the prior art is the realization of “decimal calculation without using approximate values” using software and character types. Therefore, even if it is a floating point calculation, “an error-free operation that does not depend on an approximate value” can be executed.

In computers, binary systems are used to represent numerical values at the hardware level, and the prior art uses character strings to represent arbitrary numbers in decimal notation, and this allows numerical calculations. Execute. More specifically, it is defined that one character represents 10 types of numbers (characters that a person can recognize as a numerical value), and an array of these characters, that is, a character type array-character string is prepared. Is regarded as an arbitrary number of decimal notation, and further, numerical calculation is executed with the two arrays. At this time, each element of the character array represents “one digit in decimal notation”.

Considering the behavior of possible elements, it can also be regarded as a reproduction and extension of the "Hardware level bit arrangement and its behavior" on software. From this point of view, “1 bit” represents two types of numbers at the hardware level, but the software is used to expand the expression to 10 types per “one character”, thereby preventing “digit loss”. I can say that. In other words, in the hardware level representation, “1 digit” represents 2 types of numbers, but the software expands to 10 types of representation per “1 digit”, and makes it possible to handle “larger numbers”. It is.

JP 2004-178539 A

There are at least three limitations in the prior art. First, the restriction of “handling a character string that humans can recognize as numerical values”, second, the restriction of “using memory as a data storage location”, and third, “using a so-called basic data type” It is a restriction, that is, a restriction of “using an existing framework”.

Using the prior art, it becomes possible to handle a larger number without using approximate values than in the past, but the range of numbers that these three constraints can handle is theoretically and practically used. It is narrowed from.

”Because of the restriction of“ characters that people can recognize as numerical values ”, 256 types of numbers can be expressed in 1 byte, but it is limited to 10 types. This narrows the range of numbers that can be handled.

In the prior art, the required memory capacity increases as the number of “numbers expressed using character strings” increases. The restriction of “use memory for data storage location” has changed the “limit of the number that can be expressed” to “within the range of memory capacity” in theory, and “within the range of available memory capacity” in practical terms. It has narrowed.

In the numerical calculation realized by the prior art, the total number of “units of processing executed” increases as the number of digits increases. Therefore, if the number of instructions required for the “unit of processing to be executed” can be reduced, higher-speed numerical calculation should be realized for the same number. When performing calculations on a computer via software, the basic data type becomes a unit of processing, but this speedup can be realized by moving away from “use of basic data type”. For example, rather than executing an operation using two character types X times, it is better to execute an operation using two “variables or areas of the size of X character types” once for the same number. It can be fast. The implicit restriction of “use basic data type” in the prior art makes the numerical calculation processing heavy, and the possibility that “numerical calculations for larger numbers are performed at a more practical speed” It can be said that it is narrowing.

By looking at the prior art from the standpoint numbering system and refining the technical idea from that viewpoint, the number of types that can be expressed in single digits is increased and the number that can be handled as a result is increased. Let At the same time, the same number can be expressed with less capacity.

The current hardware has higher performance than when the prior art was invented. By taking the current storage medium that did not exist when the prior art was invented and moving the data storage location used for numerical calculations to this storage medium, the upper limit of the number that can be handled Replace the constraint from “memory capacity” to “capacity of storage medium other than memory”. As a result, the upper limit of the number that can be handled by the increased capacity increases. At the same time, it becomes possible to avoid contention with other applications on the memory. Moreover, it becomes easy to take in parallel processing because a margin arises in memory. These are means for solving the problems from the viewpoints of practical use and high speed.

The calculation processing at the hardware level does not increase the required time by the number of bits handled. On the other hand, the number that can be expressed doubles every time the number of bits to be handled increases by one. By using this property, it will be possible to handle “higher speed processing for the same number”, and “larger numbers in exchange for larger storage capacity at the same time”. become. This speeding-up is realized by applying a process simulating “an arithmetic operation process provided in advance in the basic data type” to an arbitrary number of consecutive bits. More specifically, by creating a type that imitates a part of the basic data type function and using it as an element in "Numerical calculation using an array structure", "Faster numerical calculation is possible for the same number" "At the same time, a larger number of numerical calculations in exchange for a larger storage capacity".

To put it simply, this speedup is achieved by removing the restriction of “using so-called basic data types”.

Compared to the prior art, the upper limit of the number that can be handled is dramatically improved.

For example, by combining personal computers and hardware (GPU and high-performance hard disks) that are generally on the market as of 2016, numerical calculations of tens of millions to trillions of digits in unrealistic time Can be performed. This is because it is merely processing a sequence of millions to tens of millions of consecutive bits.

And, the present invention should be able to be reflected in a system in which a plurality of connected nodes operate in cooperation. In this case, further improvements are expected in the range and speed of numbers that can be handled.

The conceptual diagram of the conversion to the decimal notation at the time of input / output. The figure which illustrated "the main computer" and "the apparatus which performs or assists numerical calculation independently". A computer that is subordinate to the main computer on the network. The figure which illustrated performing a numerical calculation using an array structure using a network. The figure which illustrated "the main computer" and "the apparatus which contains two or more in FIG. 2". The figure which showed invention in steps from the viewpoint of the range of the number which can be handled.

The following definitions simplify the expression of frequently used concepts.
First, the definition of “numerical calculation using array structure” will be described. Numerical calculation using the “character string that can be recognized as a number” by the prior art, “array having basic data type as an element” or “arbitrary arbitrary number of bits based on an array structure” The numerical calculation using “arrangement” is referred to as “numerical calculation using an array structure”.

Second, the definition of “element” will be described. "An array with basic data type as an element" or "arbitrary number of bits arranged in an array structure" regarded as a certain number of ^Pn base notation corresponds to one digit in ^Pn base notation Let's call this part an "element". In the prior art “numerical calculation using a character string that a person can recognize as a number”, a character type of one character, that is, one byte corresponds to an element. In numerical calculation using an array of the basic data type, each element in the array corresponds to an element. In numerical calculation using an arbitrary number of bits arranged as an array structure, it is defined to represent one digit, and one divided section corresponds to an element.

Third, the definition of “unit of calculation processing” will be described. A series as a unit for performing four arithmetic operations in “numerical calculation using a character string of a prior art” or “numerical calculation using an arbitrary number of consecutive bits arranged in an array or array” of the present invention This process is referred to as a “unit of calculation processing”. The content of the series of processing varies depending on the type of arithmetic operation. In addition, “addition of digits” is subtracted, “subtraction of digits” is subtracted, “addition of one digit and another digit” is added in integration, Is a process of performing one subtraction by numerical calculation using an array structure from the number “.”

More simply, it is a calculation that we can consider as a unit when performing a calculation on paper. For addition, subtraction, and integration, calculation for each digit is regarded as a “unit of calculation processing”. With regard to division, the “accumulation and subtraction” that we perform when entering a new digit in the quotient is regarded as “repetition of subtraction”, and one of these repeated subtractions is regarded as “unit of calculation processing” .

Fourth, the definition of “total number of calculation processes” will be described. In the numerical calculation using the array structure, the total number of the above-mentioned calculation processing units executed when a certain arithmetic operation is performed is referred to as the “total number of calculation processing”. . Even if this value is a numerical calculation for the same two numbers, it differs depending on the type of calculation.

Fifth, the definition of “required amount for expression” will be described. In the numerical calculation using the array structure, the minimum capacity required to express a certain number N is referred to as “required amount during expression”.

Sixth, the definition of “Required amount for calculation” will be described. Let us say that the minimum required capacity for performing numerical calculations using the array structure is called the necessary amount at the time of calculation. The required amount at the time of performing numerical calculation using a certain number N and a certain number N ′ is the sum of “required amount when expressing N” and “required amount when expressing N ′”.

Note that this value is the "minimum capacity required to perform numerical calculations" and does not take into account the area for storing the calculation results. If the calculation result is to be secured only by the necessary amount at the time of calculation, one of the areas representing the two numbers is regarded as an “area for storing the calculation result” and is executed while rewriting it. However, since it becomes impossible to cope with overflow, it is necessary to secure an area for storage separately from the necessary amount at the time of calculation if the overflow is surely handled.

The embodiment will be described based on the above definitions. In Table 8 on page 35, “Overview of the embodiment” is described. Table 6 on page 34 summarizes “definitions of frequently used words” and Table 7 summarizes “meaning of frequently used expressions”. FIG. 5 of FIG. 1/2 is “Overview of the Invention”. Please refer to these as you continue to read. I will explain the meaning of the formula more concretely.
The feasibility of the numerical calculation of the present invention depends on “required capacity” and “time required for calculation”. If these values are sufficiently realistic, it should be feasible. We will see under what circumstances these values are realistic. Hereinafter, the three elements of “total number of elements”, “time required to access the storage medium”, and “time required to execute the unit of calculation processing” will be described.

First, the total number of elements will be described. “Total number of elements” is set to “K”. The total number of elements coincides with the number of digits when an attempt is made to express a certain number N in ^Pn base. Therefore, K can be expressed as follows.

From this, the denominator of the S is increased the larger the value of P ^n, it can be seen that the value of K that is "the total number of elements" less.

Next, we will describe “time required to access the storage medium”. The time required to read one byte from the memory area of the computer is “T”.

“R” is the time required to establish communication with a storage medium other than the memory. For example, the time required for opening a file in the file input / output process is R. The difference between “time required to read 1 byte from a storage medium other than memory” and “time required to read 1 byte from memory” is defined as “Q”. For example, the difference between “time required to read 1 byte from the file excluding time required to open the file” and “time required to read 1 byte from the memory”. In general, just because the capacity of reading from a storage medium has increased X times, the time required for reading does not increase X times. Therefore, it can be said that Q is very small (Q << 1).

In numerical calculation using an array structure, when “L” bytes are used per element, that is, when L bytes are used to represent one digit, “time required to access the storage medium” per element, in other words, For example, the “time required to read one element from the storage medium” is expressed as follows using R, L, Q, and T.

For example, in “numerical calculation using a character string of the prior art”, one digit is expressed by one byte. Therefore, the value of L in this case is 1, and the formula should be as follows.

Next, “Time required for the unit of calculation processing” will be described.

Suppose that the time required to execute a unit of calculation processing using a 1-byte element is “U”. The required time that increases every time the element size increases by 1 byte is defined as “I”.

Generally, just because the number of bits to be processed at a time has increased X times, the processing time does not increase X times, and the rate of increase is slight. For example, in C language, the time required for arithmetic processing between 8-byte long long int types is not twice the time required for arithmetic processing between 4-byte int types, and the rate of increase is 1.5. Less than double. Therefore, it can be said that the value of I is very small (I << 1). The fact that the value of I becomes very small will be described more specifically in paragraph 197.

I and U are used to represent the time required for the unit of calculation processing. When using L bytes per element, in other words, when using L bytes to represent one digit, the “time required for the unit of calculation processing” is as follows.

For example, in the numerical calculation using the character string of the prior art, one digit is expressed by 1 byte, and the above formula is as follows.

When expressing a certain number N in P ^n-ary, if expressed one digit at L bytes, inevitably you might think might become the 2 ^8L ary necessarily adopt 2 ^8L ary do not have to.

The best examples are the prior art “numerical calculation using a character string that a person can recognize as a number” and “numerical calculation using a character string that cannot be recognized by a person as a number” described later, This is a comparison with “Numerical calculation using an array of 1-byte variables”. It can be said that the former expresses numbers in decimal or hexadecimal notation for the purpose of the invention. On the other hand, in the latter, a number is expressed in a maximum 256-decimal system. However, in both cases, one digit is expressed by 1 byte ( ²⁸ bits).

In this way, when L bytes are used to represent one digit, it is possible to define the range of numbers to be used without using up all the numbers that can be represented by L bytes. The range depends on the purpose.

If you want to pursue higher performance, you should use all numbers that can be expressed in L bytes. If this method is used for the purpose of easy development by more programmers, the decimal system should be adopted where the programmer touches, and the larger base should be adopted for internal processing. Seems good.

As an application, in order to speed up the display processing of numbers, a situation where a ^10n- ary system is adopted may be considered. The speeding up of the display using the ^10n- ary system will be described later (from paragraph 143).

Hereinafter, changes in values related to “total number of elements”, “time required to access a storage medium”, and “time required to execute a unit of calculation processing” will be described.

First, changes in the value of K will be described. K represents “total number of elements”. The value of K in the case of a certain number N tried to deal with ^{P n-ary} is _log ^(P n) N. The denominator when the base of this equation is converted to 10 is S. Therefore, the value of S decreases as the value of ^Pn increases. A decrease in the value of S means a decrease in the value of K, and a decrease in the value of K means that the total number of elements decreases. The element represents one digit in the case where a certain number N is expressed on the computer by ^Pn base. Therefore, reducing the total number of elements means that the number of digits required to express a certain number is reduced, and this is synonymous with “decreasing the total number of calculation processes”.

Speaking of the calculation that we do on paper, the smaller the number of digits, the less the total number of operations using each digit, but by changing the bottom of the scaled number method, the content of the operation is It can be realized as it is. It is rather inconvenient for us to raise the bottom and perform calculations, because we are not used to anything other than decimal. On the other hand, there is no such inconvenience in computers, and literally mechanical execution is possible. Where we give a particular meaning to a particular bit pattern, it remains an “n-bit sequence” for the computer. Where we have the meaning of “representing 10 types of numbers” in one byte, it remains “an 8-bit sequence” for computers.

The above change in the value of K can be approximated as “the total number of calculation processes decreases as the value of P ⁿ increases”. In other words I than in representation in correspondence with the present invention, as in the numerical calculation using the "array structure, when attempting to express a certain number N in P ⁿ ary, the value of P ⁿ increases, the computing The total number will decrease. "

The value of K also depends on the value of log ₁₀ N. log ₁₀ N depends on the value of N. The value of N represents the number to be handled. The larger the number handled, the greater the value of N. Therefore, it can be understood that the larger the number handled, the larger the value of K. In other words, the expression corresponding to the present invention is expressed as follows: “In numerical calculations using an array structure, the larger the number to be handled, that is, the number to be expressed by the array structure, the value of K becomes “This is because the value of log ₁₀ N increases.”

As described above, the two reasons for changing the value of K mentioned in paragraphs 43 to 47 are summarized as follows: “In the numerical calculation using the array structure, the value of K decreases as the value of P ⁿ increases, and the value of N It can be said that it increases as the value increases.

Note that the value of P seems to be limited. When one digit is expressed by n bits, a maximum of 2 ⁿ numbers can be expressed. The value of P is 2 if all the numbers that can be represented by n bits are used up. From here, it will adjust the value of the bottom to a value smaller than 2 ⁿ depending on the application, it seems generally probably be limited to 10 ^x ary. This will be described from paragraph 143 as “speeding up display”. What I want to say now is that the value of P is likely to be 2 or 10.

Second, the change in the value of L will be described. The value of L is the number of bytes required to express one digit when trying to express the number N on the computer in the ^Pn base notation in the numerical calculation using the array structure. The larger the value of P ⁿ , that is, the greater the number represented by one element, the larger the value of L increases.

In other words, in an expression corresponding to the present invention, “in numerical calculation using an array structure, when a certain number N is to be expressed in the ^Pn- ary system, one digit increases as the value of ^Pn increases. The value of L, which is the capacity required to express “is increased”. The following inequality holds between n and L.

Thirdly, changes in the values of R, Q, and T will be described.

R is the time required to establish communication with a storage medium other than the memory. Q is the difference between “time required to read 1 byte from a storage medium other than memory” and “time required to read 1 byte from memory”. Accordingly, the values of R and Q are both affected by hardware performance. The higher the “access speed of the storage medium other than the memory” employed, the smaller the values of R and Q.

Note that if the “access speed of the storage medium other than the memory” is faster than the memory access, the value of Q turns negative. This can occur, for example, when an external device (5 in FIG. 2) specialized for numerical calculation using an array structure is created. More specifically, the external device includes “a storage medium that exceeds the memory performance of the main body”, “arithmetic processing device”, and “software for executing numerical calculations using an array structure”. In this case, the numerical calculation is performed independently in response to a request from the main computer and the result is returned to the main computer.

T value is the time required to read 1 byte from the memory area. Therefore, the value of T depends on the memory performance. The value of T increases as the memory with lower performance is employed, and the value of T decreases as the memory with higher performance is employed.

From the above, it can be seen that the values of R, Q, and T depend on the hardware performance.

It is difficult to improve hardware performance directly from the software side. If there is something that can be done from the viewpoint of software, it is “selecting an access method to a storage medium other than the memory”. For example, whether to use an API prepared for file input / output, whether to use an API for formatting, or an assembly language. Depending on the access method, the values of R and Q should be different.

While attempts to improve hardware performance directly from a software perspective do not appear to be a general and realistic approach, incorporating higher performance hardware is common and practical, while at the same time With favorable facts. The favorable fact is that the performance of various hardware has continued to rise.

The present invention itself relies on the fact that “the access speed to the storage medium has increased” and the “capacity has increased” much more than when the prior art was invented. If the performance improvement will continue in the future, in the numerical calculation using the array structure, the improvement that is established between “current and present” should also be realized between “present and future”.

Fourth, the change in I and U values will be described. “Time required to execute a unit of calculation processing using a 1-byte element” is U, and “Increase in required time that is increased every time the size of an element to be handled increases by 1 byte” is I. Therefore, the values of U and I depend on the performance of the arithmetic processing unit.

It seems that these values can be improved from the software side by using parallel processing together. For example, it is conceivable to incorporate parallel processing as part of a unit of calculation processing.

The changes in “K”, “L”, “R, Q, T” and “I, U” have been described above. Here, the numerical calculation index using the array structure is “V”. Let me denote it by the following formula. Each part enclosed in {} corresponds to “total number of elements”, “time required to access the storage medium (per element)”, and “required time per unit of calculation” (per element). .

Furthermore, let {R + L (Q + T)} be α and {(L−1) I + U} be β for the above formula, and let us return to the discussion again.

Fifth, "What does the value of S, α, β decrease?" K is a value that supports the total number of instructions, and S is a value that decreases the value of K. α and β are equations relating to the speed per element. Therefore, when log ₁₀ N is regarded as a constant, “S · α · β takes a smaller value” means that “a numerical calculation using an array structure is faster when a number of the same size is handled. It can be understood that this means that "the operation is performed". If the upper limit of the capacity required at the time of calculation is not considered, it means that “a larger number can be handled at the same time”, that is, “the capacity of the storage medium satisfies the capacity required at the time of calculation. It is understood that the smaller the values of S, α, and β, the larger number can be handled at the same time.

Sixth, we will describe “capacity of storage media required when performing numerical calculations using an array structure”. L appearing as α and β is a capacity necessary to represent one element, that is, a capacity necessary to represent one digit in the numerical calculation using the array structure. The value of K is the total number of elements required to express a certain number N in the numerical calculation using the array structure, that is, the number of digits required. Therefore, in the numerical calculation using the array structure, the “capacity required when expressing a certain number N” is equal to the number obtained by multiplying the value of K by the value of L. Therefore, when numerical calculation of two numbers N and N ′ is performed using the array structure, the “capacity required for the storage medium” is “capacity required to express N” and “ It is a value obtained by adding together “capacity necessary for expressing N ′”.

From now on, in the numerical calculation using the array structure, the minimum required capacity to express a certain number is “required amount when expressing”, and the minimum necessary to perform numerical calculation using a certain two numbers This capacity is called “calculated amount”.

If the required amount at the time of expression of a certain number N is E (N) and the required amount at the time of calculation for a certain number N and N ′ is F (N, N ′), it is expressed by the following equation.

Based on the above, as stated in the 63rd paragraph, “When the capacity of the storage medium satisfies the capacity required at the time of calculation, the smaller the value of S · α · β, the larger at the same time. "When the storage medium capacity satisfies the required amount at the time of calculation, the smaller the value of S / α / β, the larger the value at the same time” In other words, you can handle numbers.

Note the relationship between K and L, and the relationship that the value of L increases as the value of K decreases. P ⁿ is the size of the base when a certain number N is expressed by the scaled number method. The value of K is the total number of digits required when a certain number N is expressed in ^Pn decimal notation, that is, an element required when a number N on the computer is expressed in ^Pn decimal notation. The total number of The value of L is a capacity required to represent one digit at this time.

The value of K is larger the value of P ⁿ becomes large, it becomes smaller. The value of L increases as the value of ^Pn increases. When increasing the value of P ⁿ for a certain number N, the value of K decreases and the value of L increases. At this time, if the “decrease rate for K” exceeds the “increase rate for L”, the required amount for expression “KL” and the “necessary amount for calculation” represented by the addition should decrease. is there.

For example, with respect to the prior art “numerical calculation using a character string that a person can recognize as a number”, the condition that “a person can be recognized as a number” is abolished. This can happen when moving to "Numerical calculation using the array of".

But constant Both the value of 1 byte L, the value of the bottom of a weighted number value of K is reduced by that increased to 2 ⁸ up to 10 ^1. Therefore, in this case, the required amount for expression becomes smaller at the same number, and the required amount for calculation becomes smaller. That is, KL improves.

On the other hand, this is not the case when “the size of the element is increased and the base size of the scaled number method is increased to reduce the value of K”. For example, when the size of the element is increased by X times, in other words, when P ⁿ is maximized to P ^(xn) , the value of K decreases for the same number, and the minimum is (1 / X) times. However, since the value of L, which is the size of the element, is also multiplied by X, the value of K · L as a whole is not reduced.

When log ₁₀ 2 is 0.3, for the same number, in the former case, KL is the maximum (1/2) because “S and thus K decreases (1 / 2.4) times and L is constant”. 4) Decrease by a factor of 2. However, in the latter, since the decrease rate of K and the increase rate of L are offset, the improvement of KL as in the former cannot be obtained. Regarding KL, the difference between the former and the latter can be expressed as follows. Note that the value of (KL / K'L) is (1 / 2.4) in the former, whereas the value of (K'XL / KL) is 1 in the latter.

Based on the above, in numerical calculations using an array structure, only if the number that can be represented by one digit is increased without changing the capacity necessary to represent one digit, It can be seen that the “quantity” and thus the “calculation required amount” become smaller for the same number. This means that the effect can be obtained as if the capacity of the storage medium has not been increased.

In the numerical calculation using the array structure, this improvement is realized by eliminating the condition of “character string that humans can recognize as numbers” as described above, and “character strings that cannot be recognized by humans” It is only when adopting. In implementing the present invention, it would be difficult to achieve this improvement by other means.

Based on this consideration, from the implementation point of view, it is clear that “characters including characters that cannot be recognized by humans if they try to save the size of the storage medium when handling larger numbers using the array structure. Not only can the speed be improved for the same number, but the required amount at the time of expression can be saved up to (1 / 2.4) times by simply extending to the column. I will come back to this later.

As mentioned above, the 64th to 75th paragraphs describe the required change in storage medium capacity when performing numerical calculations using array structures. Here, I will stop the discussion on V and its configuration and describe the “effects obtained by adopting a storage medium other than memory”. This is a topic corresponding to (g) in FIG.

The prior art tries to solve the digit loss on the memory. In the numerical calculation using the array structure, the required capacity of the storage medium increases as the number to be handled increases. If the place where the data is handled is limited to the memory, the total capacity of the memory becomes the upper limit of the number that can be handled. Therefore, we introduced a storage medium with a larger capacity, changed the storage location of the array structure representing a certain number to this storage medium, and in exchange, “the array structure representing the number on this storage medium is retained. It holds three values: a reference to a location that is being used, or a key value for accessing the location, “total number of elements”, and “number of bits of each element (size)”. By doing so, it is possible to simplify the competition in memory with other applications, and to increase the upper limit of the number that can be handled.

When performing numerical calculations, for the two numbers to be calculated, refer to the location where the array structure is stored on the software side, acquire the data represented by any element, and use that data as an arbitrary The unit of calculation processing is executed. Then, the result of the numerical calculation for each element is stored in another part of the storage medium (if the required capacity is minimized, the longer array structure is rewritten).

Since the reference is held, it is possible to grasp where the array structure representing a certain number starts. In addition, since the total number of elements and the element size are known, it is possible to access any element and to know the end of the array structure. That is, an access method such as “subscript access” adopted in many programming languages is possible on a storage medium other than the memory.

* Access speed to storage media depends on hardware performance. Therefore, by adopting a storage medium having a higher access speed, a direct improvement in access to the storage medium should be obtained.

From the software perspective, it seems difficult to improve hardware performance directly. However, it is possible to try an indirect improvement by selecting an “access means”. For example, whether to use a file input / output API, a format API, or an assembly language. In the implementation, it seems to be good to adopt the means that are convenient for the purpose.

The main change caused by transferring data representing a certain number to a storage medium other than the memory is only the part related to the access procedure to the storage medium other than the memory, and in the numerical calculation using the array structure Note that there is no particular change in the behavior of the elements themselves. This is the end of the introduction of storage media other than memory. Let me return to the discussion about V and its configuration again.

Seventh, “Reason for reducing the values of S, α, and β” is described. There are two ways to reduce the size via software and the size via hardware. First, the improvement in the case of reducing the size via software, that is, at the software level will be described.

As stated in the 48th and 50th paragraphs, the value of S and thus the value of K decreases as the number of elements per element increases. In addition, the value of L increases stepwise as the number represented by the element increases. The increase in the value of L is the reason why the values of α and β increase. Accordingly, in the numerical calculation using the array structure, when the number to be numerically calculated is to be expressed by the ^Pn base system, the values of S, α, and β can be said as follows. “As the value of ^Pn increases, the value of S decreases. On the other hand, the values of α and β increase.”

Therefore, when increasing the value of ^Pn , if the rate of decrease of S is greater than the rate of increase of α and β, the value of S · α · β will decrease. In other words, while the product of “S decrease rate” and “α · β increase rate” is less than 1, the value of S · α · β decreases as ^Pn increases.

It should be noted that at this time, “required storage medium capacity” is not considered. If the storage medium does not satisfy at least the “necessary amount at the time of calculation”, no matter how small the values of S · α · β cannot be, numerical calculation cannot be realized. The required amount for calculation is determined by the required amount for expression. The required amount for expression increases as N increases. As mentioned in paragraph 75, the improvement in expression requirements is exceptional.

Hereinafter, “increase in ^Pn that decreases S · α · β” will be divided into three.

The first of as "an increase in P ^n, such as to reduce the S · α · β", a character that "people from the" numerical calculation person has used a string that can be recognized as the number "of prior art can not be recognized as the number Consider the fluctuations of S, α, and β that occur when moving to “Numerical calculation using a character string including”. This topic corresponds to the consideration of changes that occur when expanding from (d) to (c) in FIG. The value of P ^n, the former is 10 ^1, the latter is maximum ^{2 8.} The fluctuations in K that accompany the transition from the former to the latter are as follows.

The value of S with the migration of log ₁₀ 2 from the former When 0.3 to the latter is (1 / 2.4) times approximately. On the other hand, there is no change in the value of L. This is because the restriction that limited 256 characters per byte to 10 (or 16) characters has been eliminated. In both the former and the latter, the size of L, which is the capacity required to represent one digit on the computer, remains 1 byte, so there is no change in the values of α and β.

Therefore, in this case, the values of S, α, and β are improved. In addition, only in this case, the exceptional K · L improvement is as described in the 69th to 75th paragraphs.

In this case, both “K · L” and “S · α · β” can be improved. It can be seen that for the same number, numerical calculation can be performed faster with less capacity.

The above improvement can be described in more detail as follows. “The values of S and β decrease while the values of α and β remain unchanged” simply means that only the value of K decreases. The value of K is the total number of numbers, that is elements of digits when then an attempt is made to represent the N in P ^n. Since the “total number of calculation processes” is proportional to the “total number of elements”, a simple decrease in the value of K means that “the total number of calculations has been reduced without changing the contents of the calculation process”. is doing. The fact that the values of α and β remain unchanged and only the value of S is reduced means that the total number of calculations is reduced, and higher-speed processing is possible for the same number. In this situation, the exceptional K / L improvement in paragraphs 69-71 was added, "From numerical calculations using character strings that humans can recognize as numbers" from "characters that humans cannot recognize as numbers" It is the main content of the improvement obtained by moving to “Numerical calculation using character type array”.

In short, “reduction in required amount for expression, required amount for calculation”, “acceleration for the same number”, and “increase in the number that can be handled with“ same capacity ”at the same time”. This is the only improvement that can be seen in the "Increase in the number that can be handled with the same capacity at the same time", otherwise "In exchange for using larger capacity", the same Note that you will be able to handle larger numbers in time. This is because as described in paragraph 72, the improvement of K · L cannot be obtained in other cases. It should be noted that this improvement is centered on whether “a person can be recognized as a number or not” and the size of the element itself remains 1 byte.

In addition, “a character string including a character that cannot be recognized by a person” can be rephrased as “an array having a 1-byte variable as an element”. In other words, if it is a 1-byte variable, it does not have to be a character type. This means that a maximum of 256 types of numbers can be expressed in an 8-bit sequence, and high-speed arithmetic operations that are not inferior to the basic data type can be executed using two “8-bit sequences”. , Implying that an 8-bit sequence is acceptable. This plays a very important role in the discussion of “means for increasing the value of the“ third ” ^Pn ”.

In the above, we have described the first “Increase in ^Pn to decrease S, α, and β”. As mentioned earlier, “Numerical calculation using an array of 1-byte variables” ^Let 's say that the operation of replacing “1 byte variable” with “basic data type other than 1 byte variable” is the second “increase in ^Pn to decrease S, α, β” Get it.

In the following, the second “increase in ^Pn that decreases S · α · β” will be described. This topic corresponds to consideration of changes that occur when the process shifts from (c) to (b) in FIG. There is no particular change in the value of S compared to the previous discussion. If the element size becomes X times, the value of S becomes 1 / X times. For example, when the 4-byte integer type is adopted instead of the 1-byte character type in the C language, the value of S is ¼. The formula is as follows.

On the other hand, the value of L, which is the element size, is quadrupled. Therefore, the values of α and β increase.

Generally, just because the capacity read from the storage medium has increased X times, the required time does not increase X times. Also, just because the number of bits to be processed at a time is X times does not mean that the required time is X times. In both cases, the increase in required time is less than X times.

For example, when comparing reading of 1 byte and reading of 1000 bytes, the required time hardly changes even though the reading capacity is 1000 times. Further, when the operation between 1 byte and the operation between 4 bytes are compared, the required time is less than 1.5 times even though the number of bits handled at a time is 4 times. Put differently, number despite a two ³² times that can be handled, the required time is not less than 1.5 times. These are known facts. Since it depends on the performance of the hardware, it was 1.5 times, but it should be closer to 1 in practice. If applied to the C language, it can be understood that the situation where the operations between int types require 1.5 times as long as the operations between char types is unthinkable in current hardware performance.

Therefore, the values of α and β are not X times just because the value of L is X times, and in recent storage media, this is especially expressed by α (time required to access the storage media). It is remarkable. More specifically, it can be said that this opening depends on the values of “Q of α” and “I of β”, in particular, the value of Q is small in recent storage media.

When the element size is multiplied by X, the value of S · α · β decreases in the range where the product of “S decrease rate” and “product of α and β increase rate” is less than 1, Based on the above facts, it can be seen that the difference between the two increases as the value of X increases. The formula is as follows.

I would like to say that the amount of decrease by (1 / X) exceeds the amount of increase by X (Q + T) and (X-1) · I, and this difference is widening. This “global difference” will be described in more detail in paragraphs 197 and after.

Approximating the above considerations, “Generally, in numerical calculations using an array structure, the value of S ・ α ・ β is improved by increasing the size of the element, that is, by increasing the size of the bottom. Can be obtained. " At this time, note the following two points.

The first point to note is that there is no change in the value of KL even if the size of the element is increased. If the value of L, which is the size of the element, is X times, the value of S is reduced to 1 / X times, and the value of K is also reduced to 1 / X times. The value of K · L is offset by the decrease in K and the increase in L, and no change occurs. Therefore, it can be seen that “when only the size of the element is increased for the same number, the speed is improved, and the capacity of the storage medium required at this time is not particularly changed”.

Another way of looking at it is that if you try to represent a larger number while the speed remains improved, you need a larger capacity. The broken line part of the following formula | equation compares the both. If the number of N digits is increased by X while maintaining the speed, X times the capacity is required. That is, if the element size and the number of elements are increased by X times, the required amount at the time of expression becomes XKL. I understand that.

This is what I said in paragraph 94, "Please keep this in mind." From "Numerical calculation using character strings that humans can recognize as numbers", "Use arrays with 1-byte character types as elements." In this respect, the change in KL when shifted to “numerical calculation” is different from the change in KL in other cases.

Exceptions to the KL improvements mentioned in paragraphs 69-71. Normally, if the numerical calculation is performed with the same number of elements (as before improvement) while maintaining the speed, the required amount for expression and hence the required amount for calculation increase.

The second point to note is that if you replace the 1-byte character type with the X-byte basic data type, you can improve S, α, and β. This means that no improvement can be obtained when numerical calculation is performed with the “array to be performed” regarded as one element. This is because in the latter case, the number of instructions for the “unit of calculation processing” is simply X times. A comparison of β (time required for the unit of calculation processing) between the former and the latter is as follows.

In the latter case, even if an improvement of 1 / X times is obtained for S, it is offset by the coefficient of β. This means that "the time required for the unit of calculation processing with the increase in the base is improved by the size of the segmented variable such as an array or a programmer defined variable (class). It cannot be obtained in the case of expansion, and a sequence of consecutive bits must be processed in a lump ”. For example, as described above, in the “operation using an array having two 4-byte variables as an element” and “operation using an 8-byte variable”, the former required time is “an operation using a 4-byte variable”. It is twice as long as “once,” but the latter is less than 1.5 times. In the C language, the int type is a 4-byte variable, and the long long int type is an 8-byte variable. However, just because the size of the variable is double, the time required for the calculation does not double. However, in the case where a long long int type operation is reproduced using two int type variables, the required time is about twice that of the int type operation. This is because operations between int types are executed twice. About these things, it seems that you can be convinced as a well-known fact.

Based on these two points, the discussion from the 96th paragraph is summarized as follows. In the numerical calculation using the array structure, the larger the element size, the faster the processing for the same number. At this time, there is no change in the required capacity of the storage medium. However, in order to obtain this improvement, each element is represented by a continuous bit sequence, and in the case of serial operation, the bit sequence must be processed in a lump. In other words, this improvement cannot be obtained even if the size of the element is increased by using a partitioned area such as an array or a compound variable.

The above is the improvement obtained by moving from "Numerical calculation using arrays with 1-byte variables as elements" to "Numerical calculation using arrays with elements of basic data types other than 1-byte variables" It is.

More specifically, “By reducing the total number of elements, it becomes possible to perform faster numerical calculations for the same number”. “With the same number of elements, a larger number can be handled if the necessary amount at the time of calculation can be satisfied.”

The costs that accompany this improvement are “an increase in access time to the storage medium per element” and “an increase in the time required for the unit of calculation per element”.

As described above, the values of S, α, and β when “1 byte variable” in “Numeric calculation using an array of 1 byte variable” is replaced with “basic data type other than 1 byte variable” I talked about the changes in the 96th to 113th paragraphs. Next, let me describe the third “Increase in ^Pn to decrease S, α, and β” in the form of further promoting the above improvement.

In the following, the third “increase in ^Pn that decreases S · α · β” will be described. This topic corresponds to consideration of the change that occurs along with the transition from (b) to (a) in FIG.

Acceleration in terms of speed can be obtained when the size of each element is increased without using a segmented area such as an array or compound variable. The improvements I made in the 96th to 113th paragraphs were roughly such.

As I mentioned in paragraph 95, this improvement can be seen more abstractly and it can be said that "an improvement in speed can be obtained by using an arbitrary number of consecutive bits".

Specifically, the location of the elements in the improvements described in paragraphs 96 to 113, that is, the location of “basic data type other than 1-byte character type” is expressed as “arbitrary arbitrary number of consecutive bits”. If it can be replaced, it can be said that further speed improvements are obtained.

In order to realize this replacement, “reserving a continuous bit sequence on a memory and a storage medium other than the memory” and “processing the bit sequence collectively” are necessary. The former is a memory allocation problem, and the latter is a bit operation problem at the software level.

First, I will describe the former specifically. In this case, it is necessary to make adjustments in a language that can allocate “a sequence of consecutive bits longer than the basic data type” on the memory. The reason why the “arrangement of bits on a storage medium other than the memory” is not taken into account is that it is easy to express an arbitrary bit arrangement on the storage medium other than the memory. When expressing on a storage medium other than memory, the key points are "where a certain number of expressions start", "where a certain number of expressions end", and "the size of each element" Three points. This is as stated in the paragraph “Introduction of storage medium other than memory” in paragraphs 77-83. In short, it solves with “reference to an array structure held in a storage medium other than a memory”, “size of one element”, and “total amount of elements”.

Next, the latter will be specifically described. “Processing a sequence of consecutive bits all at once” is a combination of the four arithmetic operations provided in advance in the basic data type with AND operators, OR operators, XOR operators, bit shift operators, etc. To reproduce at the bit pattern level. To put it more simply, it means “make your own basic data type arithmetic operation function for a bit sequence longer than the basic data type”. In other words, it is only necessary to prepare two “regions longer than the basic data type” and reproduce the behavior as close as possible to the “four arithmetic operations included in the basic data type”.

For example, the standard C ++ has a class called bitset. By using this class, “reserving a continuous sequence of bits longer than the basic data type” can also be used to collectively process a sequence of consecutive bits. Can also be solved. In addition, since binary file input / output can be used in the same way as a normal type, “expression on a storage medium other than memory” can be easily performed. In the C language, the 8-byte long long int type is the most efficient for integer calculations. However, using bitset, a sequence of 9 or more consecutive bits is assigned, and the bit pattern required for any four arithmetic operations is assigned to this sequence. By performing the processing at the level, the functions of the four arithmetic operations provided in advance in the long long int type can be reproduced at the bit pattern level. Since the long long int type is a sequence of 64 consecutive bits, it is only necessary to prepare two sequences of 72 or more consecutive bits and reproduce the behavior similar to the long long int type for the four arithmetic operations. By using bitset and various operators (&, |, ^, <<, >>, etc.), it is possible to make a long long int type arithmetic operation function for a size of 9 bytes or more. “Processing (algorithm) at a bit pattern level necessary for arbitrary four arithmetic operations” is a known technique.

The improvement obtained by replacing the element with the “basic data type excluding the 1-byte character type” with the “arbitrary number of consecutive bits” is the above-mentioned improvement of the “1-byte character type It is the same quality as the improvement obtained by moving from "Numerical calculation using array" to "Numerical calculation using basic data type excluding 1-byte character type".

In the numerical calculation using the array structure, this “basic four arithmetic operations at the bit pattern level” is executed most frequently. In the implementation, when the behavior of the basic data type is reproduced with respect to “longer bit sequence”, it seems to be good to try to increase the speed even if it is detailed.

As mentioned above, I have described the improvement at the software level in three parts regarding “reasons for reducing the values of S, α, and β” over the 84th to 124th paragraphs. In the following, I will describe the improvement at the hardware level for “reason for reducing the values of S, α, and β”.

First, let me describe the improvement of α and β. As stated in paragraphs 53 to 56, the Q value that appears as α and the I value that appears as β depend on the performance of the hardware. The value of T that appears as α depends on the memory. In implementation, the values of Q and I are improved by adopting “storage media other than memory with faster reading speed” and “higher performance processing device”, and adopt “memory with faster reading speed”. As a result, the value of is improved.

The improvement of the values of α and β while keeping the value of S means that only the time required for the unit of calculation processing is improved. Therefore, it can be said that the larger the total number of calculation processes, the more remarkable the improvement effect. It can be said that “the total number of calculation processes” is proportional to the value of K, and the value of K is proportional to the value of the number N to be expressed. Therefore, it can be understood that “the larger the number handled, the more remarkable the effect obtained by adopting high-performance hardware”. In other words, if the rate of increase of α and β is small in the first place, it is impossible to obtain a visible improvement for this point unless a certain number of numbers is handled.

Based on the above, the following can be said from the implementation point of view. First, if the purpose of the implementation is “to handle as many numbers as possible” rather than “to handle large numbers with a specific value as the upper limit”, it is better to introduce higher-performance hardware. I think that the. Second, computer-related technologies are said to be unreadable, but if hardware performance continues to improve, the values of R, Q, T, and I will become smaller and smaller. . From the viewpoint of this unpredictability, a product that adopts a specification that can operate with more hardware is higher in terms of improving the values of R, Q, T, and I based on improved hardware performance. The product should be more adaptable and longer breathing. The above is the improvement of α and β at the hardware level.

Next, let me describe the use of multiple devices. This is mainly a topic about (e) and (f) of FIG. The conditions for numerical calculation using the array structure can be summarized as follows. First, "can handle variables", "can handle arrays", "can use memory and storage media other than memory, or can prepare a memory that does not conflict with other applications" and "numerical calculations" If at least these four conditions are satisfied, a system for handling a larger number can be realized. Furthermore, regarding software, "arbitrary bit sequences can be arbitrarily assigned" and "processing such as the four arithmetic operations provided for basic data types in various programming languages can be reproduced for any number of bit sequences" By satisfying these two conditions, it is possible to speed up the numerical calculation in the above-described system.

・ If these requirements are met, an external device specialized for numerical calculations using array structures should be possible. If these requirements are satisfied, it should be possible to reflect the method of claim 1 from “various personal computers on the market” to supercomputers.

Here, let me describe the “element behavior” on the software. There is no difference from the prior art in the behavior of the fundamental elements of the present invention. In other words, it seems convenient and easy to adopt a calculation algorithm according to the prior art. “To increase the size of elements in the prior art” is one of the key points of the present invention. The prior art is merely “processing an arbitrary number of“ characters ”using an array structure”. The extension of the present invention is “processing an arbitrary number of“ basic data types ”using an array structure”, or further extending “an arbitrary number of“ longer bit sequences ”using an array structure”. It's just a "process". That is, in either case, it is merely “processing of elements of an array structure”. Therefore, if a “giant array structure with character type elements” can be easily processed with known techniques, the similar “giant array structure with basic data types as elements” is further developed. The extended “huge array structure with elements of longer bit sequences that mimic the function of the basic data type” should be able to be easily processed by known techniques. From the point of view that “all are processing of a huge array structure”, the only difference is the size of the element.

This parallel algorithm makes it easy to incorporate parallel processing. This is because each digit can be handled independently. “Handling each digit independently” is just a common process of “handling each element of the array structure independently”. Therefore, this can also be easily realized by known techniques.

The greater the number of digits that can be represented, in other words, the greater the capacity required to represent a digit, and in other words, the greater the size of the elements, the greater the benefits of introducing parallel processing. Should be higher. Therefore, when parallel processing using a GPU or the like is introduced, a further improvement in speed is expected when a larger number is handled. If the performance of hardware specialized for parallel processing such as GPUs continues to improve in the future, this can be a convenient fact for the problem of the present invention. It should be noted that the introduction of parallel processing into the prior art technique was judged to be easily analogized and was not included in the claims.

In turn, as stated in paragraph 130, providing an external device specialized for numerical computation using an array structure is an effective means for the subject of "handle larger numbers faster". Can be. It takes a form such as “Receiving an instruction relating to calculation from the main computer as an external device, completing the arithmetic processing, and returning the obtained result to the main computer”.

This device has “software that can execute the method according to claim 1”, and thereby performs numerical calculation using an array structure. The method described in claim 2 or claim 3 is incorporated in this software as necessary. The connection with the main computer should be feasible with known techniques. For example, connection using USB or wireless LAN is conceivable. In any case, it is desirable from the viewpoint of handling a larger number that a larger-capacity storage medium prepared for numerical calculation using an array structure is included in this device. Seem. As described in paragraph 54, the value of Q can turn negative depending on the configuration of the apparatus. That is, faster access to the storage medium can be realized than when the main computer executes alone.

There are cases where this device is responsible for all of the processing and cases where a part of the processing is performed auxiliary, but the operation contents are arranged in a single unit using a storage medium other than the memory by the main computer. This is the same as when performing numerical calculations using. The only difference is whether an external device does all of that or assists some. In any case, the processing content of the numerical calculation remains the same, only the place where it is executed is changed. As stated in the 132nd paragraph, in the numerical calculation using the array structure, since each digit is independent for a certain number of expressions, it is easy to share such processing at the software level. Such a combination of external devices can be regarded as a form of introduction of parallel processing if the viewpoint is changed.

So far, I have described an external device specializing in numerical computation using an array structure. The device itself should be fully feasible with known techniques. It is only necessary to be able to operate a dedicated processing unit specialized for the "specific purpose for the self" and a self-dedicated storage area specialized for the "specific purpose for the self". is there. The “specific purpose” corresponds to a numerical calculation using an array structure. That is, software for executing numerical calculations using an array structure is provided in the existing apparatus configuration. This apparatus corresponds to the apparatus described in claims 4 and 5. FIG. 2 is an illustration of such a device.

The present invention can be realized by a plurality of computers connected by a network. For example, one main computer is determined, this computer is set as a UI, and the remaining computers are regarded as the external devices described above (FIG. 3).

It is possible to include software for performing numerical calculations in each computer. It is also possible to provide a device specialized for parallel processing such as GPU. A large-capacity storage medium can be provided. If importance is attached to speed, the capacity can be reduced, but the memory itself can be regarded as a storage medium. As in the case of the external device described above, if the performance of the storage medium used by the subordinate computer exceeds the memory performance of the main computer, the value of Q will turn negative.

In this case, the behavior of the element itself does not change. All you have to do is assign which computer is responsible for "from which digit to which digit" for a certain number. This does not go beyond the scope of parallel processing. In other words, it is a common process of dividing the array structure and associating the generated thread with each partition. “Linking computers on a network” should be feasible with a known technique. If an existing protocol is adopted, it should be executable even when a plurality of OSs coexist.

Conversely, there is also a form in which this structure is constructed using a plurality of external devices described in the 134th to 137th paragraphs. In this case, it is not necessary to adopt a network communication protocol. FIG. 4 is an example of this, and 6 in FIG. 4 is a device that includes a plurality of the above-mentioned external devices.

As mentioned above, over the 126th to 141st paragraphs, I have mainly described improvements at the hardware level in the “reason for reducing the values of S, α, and β”. It can be said that the effect is more conspicuous by utilizing the hardware.

Next, let me describe the speeding up of the display. First, let me describe the display issues. When shifting from a numerical calculation using a “character string that can be recognized as a number” to a numerical calculation using an “array having a 1-byte variable as an element”, a display problem arises.

The former should use decimal or hexadecimal notation for the purpose of the invention. On the other hand, the latter is expanded to a maximum of 256 base. The latter can be a character string by definition, but such a character string will be mixed with symbols other than numbers and so-called garbled characters, so it should no longer be a "character string that people can recognize as numbers". . In the case of expansion to 256 notation, 256 types of characters must be properly used for each digit, and it is difficult to pass the number as intended from a person to a computer via such a character string.

This problem can be solved on the software side. To put it simply, only the parts touched by humans are expressed in decimal notation, and the internal processing is extended to a maximum of 256 decimals per byte. More specifically, it is as follows. “Character string that human can recognize as a number” or “number” is passed to the computer, and the received computer converts it to “array with 1 byte variable as an element” as a maximum 256-ary expression, and after this conversion Is stored inside, and calculation is performed using this array. Then, it is converted into decimal notation only when it is displayed.

The same applies to “numerical calculation using basic data types excluding character types” and “numerical calculation using an arbitrary number of bits arranged in an array structure”. In these cases, if the base of the scale system is extended to the ^Pn base system, a “character string that a person can recognize as a number” or “number” is passed to the computer, It is converted to an “array structure having elements that can represent P ⁿ number of hits”, and numerical calculation is executed using the array structure after the conversion. And only when it displays, it converts to decimal notation again (FIG. 1).

For example, when a 4-byte int type is used as an element in C language, the following method can be used. 2 Estimate how many digits are needed to represent ³² , and prepare an array having elements of the necessary number of digits. It should be noted that the rough estimate does not matter if there are many digits, but if it is small, it will not be possible to deal with overflow. Such an approximation can be obtained by an equation for obtaining K. Suppose X digits are needed. Prepare an array with X 4-byte elements. Divide the number received by 2 ³² to get the remainder and quotient. Assign the remainder to the last element of the array. The quotient obtained again is divided by 2 ³² to obtain the remainder and the quotient. The remainder is assigned to “one element younger than the previous operation”. This operation is repeated until the quotient becomes zero. This operation is the same as when we perform the conversion of the base of the scale system on paper. Finally, the value is checked from the beginning of the array, and the element where a non-zero portion appears for the first time is obtained, and this is used as the first element of the array. If you do not want to waste the memory area, copy this array to an arbitrary area, discard it, and consider the copied value as a numeric expression.

When using "Sequential bit sequence", the operation changes slightly for "preparation of array", "substitution of remainder", and "detection of location where non-zero appears for the first time". The behavior is the same. In this example:

First, regarding “preparation of array”, it is sufficient to secure the memory area by the value obtained by multiplying “number of digits required” by “element size (4 bytes)”. Second, for "remainder assignment", negate all 32-bit sections regarded as elements of the array structure, and then execute an OR operation with "present section" and "value to be substituted" Just do it. Thirdly, with regard to “detection of a location where an element that is not 0 for the first time appears”, the bit sequence may be examined 32 bits at a time from the top, and the group that was 0 may be shifted left 32 bits and deleted. . It should be noted that this operation is facilitated by using a class called bitset provided in the standard C ++ mentioned in the 122nd paragraph. Specifically, functions are already provided for memory reservation, assignment, and bit shift. All that is required is an "approximate number of digits". As described above, such an approximation can be obtained by an equation for obtaining K.

The conversion process does not have to be executed every time an operation is performed, but should be performed once when a person passes a “character string regarded as a numerical value” to a computer and once when it is displayed. At the time of display, a “character array for display” is prepared separately from the array of the main body, and each element is filled with “numeric value in decimal notation” and displayed. If the values of the array of the main body are not changed in this way, the calculation can be resumed without conversion after display.

Speaking only of the above-mentioned conversion function, for example, there is a class that has “pointer to array structure for use in numerical calculation” and “display function” as members in standard C ++, and this class receives characters received from the user. It is conceivable that the pointer is initialized with a column and displayed with a “display function” at the time of display.

The number that a person can input by inputting to the calculator via the UI should not be so large. For example, it is difficult to imagine a situation in which a person directly manually inputs a number of 100 million digits. Since such a large number of digits will not be handled, it can be said that the load of such conversion processing is not so much concerned with the input. When used by humans, it seems that the appearance of “a smaller value is entered and the number of digits expands as a result of repeated internal numerical calculations, and this is displayed as a result”. However, issues remain with regard to output. This is because an enormous number of digits can be displayed during output. When large numbers are frequently output, it is necessary to deal with them.

One means for greatly omitting the conversion process at the time of display is conceivable. This is “speeding up display” and corresponds to the method according to claim 2. Suppose that 2 ⁿ bits are used to represent one element. At this time, the base value of the scaled number method is not expanded to the maximum 2 ⁿ , but is limited to 10 ^x (10 ^x <2 ⁿ ). The fact that there is no particular problem in suppressing the degree of expansion is as stated in the 38th to 41st paragraphs.

In this way, the character string can be displayed from the beginning, and the conversion process at the time of display can be completed with a smaller burden than when the number of characters is expanded to ²ⁿ . On the other hand, when the base is suppressed to 10 ^{x, the} number that can be expressed is smaller than when the base is expanded to 2 ⁿ . For example, there are fewer numbers that can be represented by the same number of digits in the decimal system than in the 256-base system.

By fastening the 10 ^x ary, although time required for the display is greatly reduced, and this "substantially" is specifically converted into decimal from "2 ^n-ary, and displays the processing It is the difference between the “time required for processing” and the “time required for the process of converting from 10 ^× decimal system to decimal system and displaying”.

In the ^10x decimal system, it is possible to know in advance how many digits the maximum number of digits is when expressed in decimal notation. In addition, there is an advantage that it is not necessary to worry about overflow when converting.

First, a character array having elements corresponding to the number of digits required for decimal notation is prepared. Aliquoted I than the digit number of elements that took this sequence 10 ^x ary notation. Each partition generated by equally dividing corresponds to each digit of the 10 ^x-ary. For each of the sections, conversion to decimal is completed if “10 ^x decimal digit values” are sequentially satisfied from the end in order from the end. Note that the remaining digits are filled with zeros.

The “character array expressing a certain number of decimal notation” thus formed can have a leading zero in the block including the largest digit in the 10 ^× decimal system, in other words, the leftmost digit. That is, one or more zeros can follow from the beginning. Therefore, it is necessary to detect an element in which a non-zero character appears for the first time, and prepend it so that this is the head. Since this display array is a character array, such an operation can be easily realized. A portion where a non-zero character appears for the first time may be used as the start address of the character string, and such an operation, that is, an operation of filling the character string forward is a known technique. Through this process, even if a plurality of 0s are arranged from the top, it should be possible to display without problems. Hereinafter, the above method will be described more specifically.

Table 1 shows a step-by-step process for converting the number xyz represented by three digits in decimal notation to decimal. It can be seen that the number that requires 3 digits in decimal notation does not exceed 6 digits in decimal notation. First, a character array having six elements is prepared ((1) in Table 1). Since the number of digits required in the decimal system is 3, the 6 elements of the array are divided into 3 equal parts. Then, it can be classified in a state of two elements per section ((2) in Table 1). Each section can correspond to each digit in decimal notation ((3) in Table 1). After that, it is sufficient to fill with the value of each digit in the corresponding decimal notation in order from the last element of each section. Then, what is concrete about this "filling with the value of each digit in the corresponding decimal notation in order from the last element of each partition" is more concrete using Table 2. Let me tell you.

Table 2 shows a step-by-step process for converting a number represented as “123” in decimal notation into decimal notation. * In the table represents an arbitrary value. As described above, first, a character array having six elements is prepared ((1) in Table 2). Dividing into three sections, each section is associated with each digit in decimal notation ((2) in Table 2). Specifically, the elements of subscript numbers [4] and [5] correspond to the first place from the right in decimal notation, and the elements of [2] and [3] correspond to the second place. , [0], [1] correspond to the third place. Then, [4] and [5] are filled with 3, [2] and [3] are filled with 2, and [0] and [1] are filled with “1” in order from the end of each partition. That is, 3 is assigned to [5], 2 is assigned to [3], and 1 is assigned to [1]. ((3) in Table 2). At this time, if there is an element to which nothing is assigned for each section, 0 is assigned. In other words, [4] in the operations [4] and [5], [2] in the operations [2] and [3], and 0 in [0] in the operations [0] and [1]. To do. ((4) in Table 2). This completes the conversion to decimal notation. However, since the top of the array is 0, this needs to be corrected. The character string is corrected by prepending it ((5) in Table 2). You can display this afterwards.

Such an operation can be executed sequentially from the first section. In the case of employing other than 10 ^x-ary, it is necessary to consider the overflow must Ika doing the conversion operation from a small digits. On the other hand, in the case of the ^10x base system, there is no overflow in conversion, so it is possible to perform conversion from a large place and display sequentially from the converted part. In the above example, it is possible to start processing from [0] [1] and display “1”, “02”, “03” sequentially. Regarding the padding of characters, since it can be understood that [0] [1] is the head, this operation may be performed only at the time of the first process.

By the way, this character filling operation seems to be a left bit shift at the hardware level. Based on these element behaviors, etc., in the fourth paragraph, “When considering the possible element behaviors, it is a“ reproduction and extension of hardware-level bit arrangement and behavior ”on software”. I told you.

It should be noted that, for the value of decimal notation 123, since each digit is a numerical value, it is necessary to convert it into a character code when storing the numerical value in a character type array for display. This is the same even in cases other than the ^10x base. For example, in Windows, characters from 0 to 9 are represented by 48 to 57. Therefore, in order to convert a numerical value of 0 to 9 into a displayable character of 0 to 9, it is necessary to add 48. As mentioned above, over the 143rd to 162nd paragraphs, the speeding up of the display has been described. Examples will be described below.

Before describing the embodiment, let me explain the premise. In the embodiment, “as of 2016, it is possible to realistically execute a trillion-digit numerical calculation by combining a general personal computer or other hardware that is on the market, or use V in 62 paragraphs. We will look at the feasibility from a cost perspective. Log ₁₀ 2 is treated as 0.3.

First, the cost of the prior art “numerical calculation using a character string that a person can recognize as a number” will be described. This is a more specific topic about (d) in FIG. K is the number of digits required when an arbitrary number is expressed with an arbitrary base, α is the time required to fetch the necessary data from the storage area, and β is the time required for the unit of calculation. is there. Let N be 10 ^{10 ^ 12} . Since 10 ¹² corresponds to 100 billion, 10 ^{10 ^ 12} is a number in which 100 billion 0s are arranged. That is, N is a trillion-digit number in decimal notation. Below (Table 3) for the cost when N is ^{10 10 ^ 12} is obtained by comparing the cases of decimal 256 decimal. The language is assumed to be standard C ++, and the leftmost column represents the type corresponding to the base of the scale system. For example, “a decimal line is a char type” means “a char type is an element in decimal notation”. In the prior art “numerical calculation using a character string that a person can recognize as a number”, it can be said that decimal notation is used for the purpose of the invention. Therefore, the “decimal” line in Table 3 is the value of each expression constituting V when trying to handle 10 ^{10 ^ 12 in} “numerical calculation using a character string that a person can recognize as a number”. .

The number of digits required when 10 ^{10 ^ 12} is expressed in decimal notation is (10 ¹² +1) digits. As it let me get one digit for simplicity rounding results in 10 ^12-digit i.e. that 1T digits necessary. This corresponds to the value of K. In the prior art, one digit is represented by a 1-byte character type. That is, one element is represented by a 1-byte character type. This corresponds to the value of L. Therefore, the capacity of the storage medium required when 10 ^{10 12} is expressed by the prior art is 1 TB with 1T elements of 1 byte. This corresponds to the value of KL.

The value of K is “log ₁₀ 10 ^{10 ^ 12} / log ₁₀ 10”. Therefore, the value of S is 1. Since the value of L is 1, the value of α is “R + Q + T”, and the value of β is “U”.

Suppose that there are a number N ′ of exactly the same conditions, and N and N ′ are used for addition. In this case, the required amount at the time of calculation is 2 TB. This corresponds to the sum of “KL of N” and “KL of N ′”. The “unit of calculation” is addition, subtraction, integration, or division using a 1-byte character type. In this case, addition is performed using a 1-byte character type.

If we add numbers between two digits by writing on the paper, we will perform the addition between the specified digits only the number of digits, that is, twice (overflow for simplicity). Is not considered). At this time, when executing “addition of certain digits”, we recognize each digit to be added once. That is, the number is recognized twice implicitly. Also, for example, if 1 trillion digits are regarded as 1T digits, when we add the numbers of 1 trillion digits by hand on the paper, the addition of predetermined digits is executed at least 1T times. become. And at this time we implicitly recognize the numbers 1T times. That is, the number is recognized 2T times in total.

“Implicit recognition” corresponds to “access to storage medium” on the computer. The time required to do this once is α. “Addition between predetermined digits” is “calculation using two elements”, that is, “unit of calculation”. And the time required for doing this once is β.

Therefore, it can be rephrased as follows in the numerical calculation using the array structure by the computer, that a person manually performs the calculation. “When adding two“ equal ”conditions, α will be executed at least 2K times and β will be executed at least K times.”

However, it should be noted that this is an assumption when the number of digits to be handled is equal, and α is not necessarily executed 2K times and β is not always executed K times. If both values of K are different, it will depend on the smaller value. For example, in the numerical calculation using the array structure, if one trillion digits and one digit are added, α needs to be at least twice and β needs to be at least once. If not one trillion digits, it is not necessary to execute α 2T times and β 1T times. The reason why such an equal condition is assumed is that if the feasibility can be shown in an example in which the number of operations is the largest, it is possible to show the feasibility of numerical calculation with a smaller number of times. The reason why the addition is taken as an example is that it is considered that the “total number of calculation processing units” is most easily understood. Although the “total number of units of calculation” varies depending on the four arithmetic operations, there should be no difference in the concept of increase or decrease in the value of V. In the case of division, the content of “unit of calculation processing” is exceptionally “subtraction using an array structure”. In this case, the concept of increase / decrease in the value of V is the same.

On the other hand, in the “numerical calculation using a character string that a person can recognize as a number”, since “value where K is 1T” is added to each other, α is executed at least 2T times, and β is at least 1T. Will be executed once. More specifically, it can be understood that an operation of reading data of one element (in this case, 1 byte) from the storage medium is executed 2T times, and addition of one element is executed 1T times. In this case, since the required amount at the time of expression is 1 TB, the required amount at the time of calculation is 2 TB.

As of 2016, 2TB memory is not common for computers on the market. Therefore, a storage medium other than the memory is inevitably used together. However, even if this satisfies the requirements for the capacity of the storage medium, it seems unrealistic to add 1 byte 1T times for each numerical calculation. Such numerical calculations should put a heavy load on the entire system. Even if an independent external device is created, it is not an external device, but a separate general computer is prepared, and it is regarded as "dedicated to numerical computation using an array structure" It seems to be a large-scale device that cannot be distinguished from it. Therefore, “Numerical calculation using character strings that humans can recognize as numbers” means that even if a storage medium other than a memory is used in combination, “as of 2016, there are 1 trillion digits of computers on the market. It turns out that it is not suitable for large-scale operations such as “performs operations practically”.

Based on the above considerations using the prior art, let me describe examples.

When moving from “numerical calculation using character strings that humans can recognize as numbers” to “numerical calculation using an array of 1-byte variables”, in other words, from decimal to maximum 256 Consider the overview of the cost of expansion. As I said earlier, we get to continue to take place at 10 10 ^{^ 12} assumption of the numerical calculations of each other. In FIG. 5, this corresponds to the transition from (d) to (c).

The difference from the above consideration is at most “value of S” and “border overflow”. Therefore, simple analogy is effective. Applying the value of the “256-ary” line to the above consideration gives the following.

Α will be executed at least 932G times and β will be executed at least 416G times. More specifically, it is understood that an operation of reading data of one element (in this case, 1 byte) from the storage medium is executed 932G times, and addition of one element is executed 416G times. In this case, the required amount at the time of calculation is 932G.

Note that the values of α and β have not changed. In other words, it should be noted that “the amount of data to be read is 1 byte per element” and “the unit of calculation is addition of 1 byte”. The value of K decreases by about 580 G while the values of α and β remain constant. This means that the number of instructions executed is reduced. Even if it says "reduction of about 580G", it is only about 1 / 2.4 times reduction from a viewpoint of a ratio. However, such a large decrease in absolute quantity is significant from the viewpoint of introducing parallel processing. This is because as the absolute amount decreases, the total number of processes per thread can be reduced while the number of threads remains the same. In other words, a sentence that can be realized by using parallel processing is more realistic.

Also note that the value of L has not changed. For the same number, the total number K of necessary digits is reduced, and the size L per element is not changed, so that the calculation required amount KL is reduced. Specifically, KL has decreased by 1 TB or more. This decrease is the “extraordinary KL improvement” mentioned in paragraphs 69-75.

From this, it can be seen that the number that can be handled with the same calculation requirement as in the prior art is greatly increased. The need for about 416 GB to represent 10 ^{10 ^ 12} in 256 base means that when 1 TB is used, a number about 256 ^{584 G} times can be expressed. In this case, the time required for the numerical calculation should be almost the same as the time required for using 1 TB in the prior art. This is because the size of each element is the same, and the behavior of the elements is almost the same. “The behavior of the elements is almost the same” means “the same as the unit of calculation processing, except that the boundary of overflow is changed from 10 to 256”. “The number that can be expressed per one digit savings is 256 times”, and “the numerical calculation with the same number of digits does not change despite the increase in the number that can be handled”. That is.

However, although a significant improvement can be obtained, it is still not suitable for themes such as “Computers that are on the market as of 2016 practically perform numerical calculations between trillions of digits”. It seems that there is nothing.

We will continue to consider in trillions of digits. Let us consider an overview of costs when using a “basic data type other than a 1-byte character type” and expanding to a base larger than the 256-ary system. FIG. 5 corresponds to the transition from (c) to (b). Table 4 shows specific numerical values in the case of handling 10 ^{10 ^ 12} in order from the smallest bottom size. The contents of each column are the same as in Table 3.

For example, in the numerical calculation of the first embodiment, it is assumed that an int type is adopted instead of a 1-byte character type. The row “int” in Table 4 corresponds to a specific numerical value in this case. When the value of this row is applied to the consideration of the first embodiment, the following is obtained.

Α will be executed at least 208G times and β will be executed at least 104G times. More specifically, it is understood that an operation of reading data of one element (“4” bytes) from the storage medium is executed 208 G times, and addition of one element is executed 104 G times. The required amount at the time of calculation remains 932 GB.

Note that the value of “L” per element is 4 bytes. The content of α at this time is “R + 4Q + T”, and the value of β is “3 · I + U”. For α, the value of Q is quadrupled, and for β, “3 · I” is newly added. However, this change in value is not so burdensome, and the speed improvement due to the decrease in the total number of elements (decrease in S) exceeds the deceleration due to the increase in the values of α and β. This is as stated in the 101st and 102nd paragraphs, but in short, the values of Q and I are very small.

Also note that, since the total number of elements decreases, the size of the elements increases, but “the required amount at the time of calculation does not increase and remains constant”. The details are as described in “Changes in KL Value” in paragraphs 69 to 73, but this is because there is an offset between the decrease in K and the increase in L. Compare with “excellent KL improvement” of 1 TB or more in Example 1.

As I said in the 100th paragraph, there is no significant difference in the required time between operations of 1-byte char type and operations of 4-byte int type. The rate of increase is slight. Also, there is no significant difference in the required time between reading 1 byte and 4 bytes from the storage medium. The rate of increase is still slight. In addition, when the numerical calculation using the array structure is performed for the same number, the total number of instructions executed in the former and the latter greatly varies. As seen in Example 1, when the char type was used to the maximum, the value of K was 416G. On the other hand, when the int type is adopted, the value of K decreases to 104G.

Numerical calculation of larger values using such “deviation between decrease rate and increase rate in S / α / β” and “the fact that the value of KL is constant with respect to the increase in the bottom” Is the essence of the present invention. To put it more abstractly, “in numerical calculations using an array structure, those that have a high occupancy among the values that interfere with each other”, there is no change in the specific value, or it remains small. “Find” an event that decreases another value.

In this case, the closer the rate of increase of α and β is to 1, the closer the overall decrease rate is to 1/4. The reason why the rate of increase of α and β approaches 1 is the miniaturization of Q and I, and I mentioned in paragraphs 52-60 that the miniaturization of Q and I is brought about by the improvement of hardware performance. Street. If the hardware performance continues to improve, further improvements should be expected in this area. If we look at this improvement in performance, it would be better to make the product operable with more hardware.

Even at this stage, it is not realistic to “perform a trillion-digit numerical calculation on a general computer”. However, it turns out that a sufficiently large number can be handled even by the transition to the int type alone. Specifically, when the number of digits to be handled is changed from 1T digits to 1G digits, the values of K and KL are simply 10 ⁻³ times. For example, if N is ^{10 10 ^ 9,} the value of K is int type 0.104 g, is 104M. Similarly, if N is 10 ^{10 6} , the value of K is only 0.104 “M” in the int type. In other words, in this range of digits, from the viewpoint of the unit of calculation processing, only a maximum of about 100,000 operations are performed between int types. “N is 10 ^{10 ^ 6} ” means that N is a number of 1 million digits. Such calculation includes a lot of room for parallel processing. The realization that “computers that are on the market as of 2016 practically perform operations of 1 trillion digits” seems to be not simple, if not impossible, only by introducing the int type. It is. “It seems impossible, if not impossible,” means that “when using multiple computers together with a network, or using multiple external devices specialized for numerical calculation of array structures. In some cases, it can be realized. However, it should be highly feasible that “computers on the market as of 2016 practically perform operations between“ 1 million digits ””. When the long long int type is adopted, the feasibility is further increased. A row of “long long int type” in the table shows the numerical value in this case. Reading is the same as in the int type.

What is important is not to say that the transition from char type to int type gives an improvement of nearly ¼ at maximum for V, but the same quality improvement that occurs with the transition from char type to int type. This also occurs when the int type shifts to “a larger variable that can execute the same operation”. In other words, from this point of view, it is very important that I have stated in paragraph 95.

Improvements that accompany the transition from char type to int type arise from the transition from int type to long long int type. Then, if it is possible to execute an arithmetic operation that is inferior to that of the basic data type for "arbitrary number of bits", the improvement that occurs with the transition from int type to long long int type will be long long int It should also occur when moving from type to “longer bit sequence”. As described in the 120th to 122th paragraphs, “to execute an arithmetic operation that is inferior to that of the basic data type” should be sufficiently realized by a known technique. This is because the algorithm employed in such an operation should be the same as that executed in the case of the char type or int type. An arbitrary sequence of bits should be subjected to "a series of fixed operations at the bit pattern level" according to the type of arithmetic operation.

Finally, the case of using “arbitrary number of bits” will be described. This corresponds to the transition from (b) to (a) in FIG. Lines below 256 ^hexadecimal Table 4 represents the cost of using the "sequence of an arbitrary number of bits." Even if the exact same behavior as the basic data type could not be reproduced, it would not be a “large loss that would break the practical execution of numerical calculations using array structures”. Is treated as having been able to adjust the processing without waste for the basic data type. In these cases, the improvement rate of S should continue to exceed the reduction rate of α and β. For example, the line “256 ¹⁶ ” means a case where the four arithmetic operations of the basic data type can be reproduced using a 16-byte section. Similarly, “256 ³² ” is a 32-byte partition, and “256 ¹²⁸ ” is a 128-byte partition. Since there is no particular difference in the manner of change, the reading of each value is the same as in the second embodiment.

It can be seen that the longer the bit sequence is, that is, the lower it is, the more feasible the theme is "computers that are on the market as of 2016 practically perform operations between trillions of digits." . In other words, it can be seen that in an environment of a certain level or higher, the feasibility increases in a smaller environment.

Next, let's take a concrete look at “What kind of improvement is possible when processing that mimics the basic data type using a longer sequence of bits?” By reproducing "four arithmetic operations using a longer bit sequence", faster numerical calculations can be realized. This improvement is because the decrease in the number of instructions caused by increasing the size of the base exceeds the rate of increase in α and β. Thank you. In addition, I mentioned in paragraph 122 that a C ++ bitset class can be used to reproduce “four arithmetic operations using a longer bit sequence”. Specific examples of these will be shown.

Table 5 shows data when "addition using an area of an arbitrary length" is executed "in series" 1 million times using bitset. The “required time” is the time required to execute addition one million times in series, and the unit is seconds. “Rate 1” is a magnification of the area size based on 8 bits, and “Rate 2” is a magnification of the required time based on 8 bits. I wanted to show from a global perspective that the time required is not X times just because the size of the element has increased X times, so the time required has been approximated.

For example, in a row where “number of bits” is 128, the required time is 0.14 to 0.16 seconds, Rate 1 is 16, and Rate 2 is 3. “Rate1” means “16 times as large as the element size is 8 bits”. “Rate2” means that “the required time is about three times as long as 8 bits”. (Note again that these values are approximate. For example, this tripled value is obtained by dividing the 128-bit duration 0.16 by the 8-bit duration 0.06. Rounded up to the nearest whole number) Note that the required time has only tripled despite the fact that the element size has increased by a factor of 16. When applied to V, this means that “with the transition from 8 bits to 128 bits, an improvement of 1/16 is obtained for S, but β is only 3 times worse”. (See the lower right of Table 7 on the next page for the formula). That is, although the number of instructions is simply 1/16, the time required for the instruction unit is only tripled. It should be noted that the deterioration of α is particularly small. This is because there is only a difference between 8-bit reading and 128-bit reading, that is, 1-byte reading or 16-byte reading. The fact that there is almost no difference between the two should be convinced as a known fact.

The rightmost column in Table 5 represents the difference between Rate1 and Rate2. If the required time is X times as the element size is X times, this value should be zero and constant. However, this is not the case, and the value increases as the number of bits increases. Therefore, it can be seen that, generally, the difference between the improvement of S and the deterioration of β increases, and the degree of improvement increases. The value of the time required should change depending on the environment, but the behavior that the degree of improvement increases globally should be the same in any environment.

Note that the calculation in Table 5 does not use any parallel processing. If parallel processing is introduced, further improvements should be obtained. The longer the sequence of bits processed at one time, the easier it will be to divide the process. In other words, it should be easy to introduce parallel processing. In Table 5, parallel processing becomes easier to introduce as it goes downward.

“The challenge in this effort is“ how much wasteful behavior is achieved for the four arithmetic operations using two longer bit sequences ”. If high-speed processing with less waste than that using bitset can be realized by using an assembly language or the like, it is considered preferable to adopt that from the viewpoint of speed. This is because this part is most frequently executed. However, from the standpoint of “an improvement in hardware performance is unpredictable”, specifications that can be executed in more forms should be adopted. In implementation, the two should be compared and a method convenient for the purpose should be adopted.

Finally, please refer to Table 4 again. It can be considered that the lower row, the feasibility of “relatively large-scale numerical calculation from the viewpoint of the current year 2016” that is an operation of 1 trillion digits increases in a smaller environment. Based on the considerations in Table 5, it can be convinced that the implementation of the lower row in Table 4 is never impossible. By using the present invention, it is possible to execute large-scale numerical calculations that cannot be executed as they are just by combining personal computers and hardware that are generally on the market as of 2016. However, it seems to be convinced that it is never impossible.

DESCRIPTION OF SYMBOLS 1 Main computer 6 External device which includes plural number 5 2 Connection 7 Main 3 processing device (arithmetic processing device) regarded as 5 or 6 4 Computer equivalent to computer 4 Storage medium 8 Entire network 5 External device (a ) Range of numbers that can be handled by numerical calculations using character strings that humans can recognize as numbers (b) Range of numbers that can be handled by numerical calculations using arrays with 1-byte variables as elements ( c) Range of numbers that can be handled by numerical calculation using an array whose elements are basic data types other than character types. (d) For numerical calculation using a sequence of bits of arbitrary length based on an array structure. The range of numbers that can be handled (e) The range of numbers that can be handled (f) Increasing click or by use of an external device, increased by a combination of a number in the range (g) a storage medium other than the memory that can be handled, ranging the number of which can be handled

Claims (5)

1. 手法 A method that uses software to perform arithmetic operations using numerical representations of the decimal notation and above expressed in a computer.
2. According to claim 1, by limiting the size of the bottom 10 ^x ary technique to speed up the conversion process to the decimal notation that will be required when the display.
3. A method of increasing the upper limit of the number that can be handled by using the storage location of the data in claim 1 as a storage medium other than the memory of the computer executing claim 1.
4. Claims by a main computer having a storage medium for executing claim 3, having software for executing claim 3, and having at least one arithmetic processing unit for assisting execution of claim 3. A device that assists the execution of 3.
5. An external device including a main computer having a storage medium for executing claim 3, software for executing claim 3, one or more arithmetic processing units for independent execution of claim 3 The apparatus which performs the claim 3 independently in response to the instruction from the above and returns the obtained result to the main computer.

Images