US 7644115 B2 Abstract Systems and methods for performing large-radix numeric operations. A first number may be segmented into large-radix segments, wherein numbers of the segments are generated such that radix of the segment is greater than radix of the first number. As a result, a plurality of disparate processor-based computing systems may be configured to perform various numeric operations on the large-radix segments of the number and output results of a numeric operation as a number whose radix is equal to the radix of the first number.
Claims(27) 1. A processor-implemented method for performing numeric operations with improved precision, comprising:
segmenting a first number having a first radix into a plurality of segments according to executable segmentation instructions that:
cause each segment in the plurality of segments to have a second radix that is greater than the first radix of the first number,
identify a segment in the plurality of segments which has a number of digits that is less than the number of digits in the other segments in the plurality of segments, and
append additional digits to the segment in the plurality of segments which has less digits than the other segments in the plurality of segments such that all segments have the same number of digits;
performing a numeric operation on the plurality of segments; and
outputting results of the numeric operation on the plurality of segments as a second number having the first radix.
2. The method of
3. The method of
4. The method of
receiving a third number;
segmenting the third number into segments;
performing a numeric operation on the digits of the integral part and fractional part of the first number using the third number's segments; and
outputting results of the numeric operations as a fourth number having the first radix.
5. The method of
6. The method of
7. The method of
8. A processor-implemented method for performing numeric operations with improved precision, comprising:
identifying an integral part and a fractional part of a first number having a first radix;
segmenting the integral part and fractional part of the first number into a plurality of segments according to executable segmentation instructions that:
cause each segment in the plurality of segments to have a second radix that is greater than the first radix of the first number,
identify a segment in the plurality of segments which has a number of digits that is less than the number of digits in the other segments in the plurality of segments, and
append additional digits to the segment in the plurality of segments which has less digits than the other segments in the plurality of segments such that all segments have the same number of digits;
performing a numeric operation on the plurality of segments; and
outputting results of the numeric operation on the plurality of segments as a second number having the first radix.
9. The method of
storing the segments of the first number into one or more data structures.
10. The method of
receiving a third number having an integral part and a fraction apart;
segmenting the integral part and fraction apart of the third number into segments;
performing a numeric operation on the digits of the integral part and fractional part of the first number using the third number's segments; and
outputting results of the numeric operation as a fourth number having the first radix.
11. The method of
storing the segments of the third number into one or more data structures.
12. The method of
13. The method of
14. A processor-based computing system for performing numeric operations with improved precision, comprising:
a memory medium for storing at least a portion of a first number having a first radix, the first number including an integral part and a fractional part;
a processor operably coupled to the memory medium and configured:
(i) to identify the integral part and fractional part of the first number,
(ii) to segment the integral part and fractional part of the first number into a plurality of segments according to executable segmentation instructions that:
cause each segment in the plurality of segments to have a second radix that is greater than the first radix of the first number,
identify a segment in the plurality of segments which has a number of digits that is less than the number of digits in the other segments in the plurality of segments, and
append additional digits to the segment in the plurality of segments which has less digits than the other segments in the plurality of segments such that all segments have the same number of digits; and
(iii) to perform a numeric operation on the plurality of segments; and
wherein results of the numeric operation on the plurality of segments are output as a second number having the first radix.
15. The system of
store the segments of the first number into one or more data structures.
16. The system of
receive a third number having an integral part and a fraction apart;
segment the integral part and fraction apart of the third number into segments;
perform a numeric operation on the digits of the integral part and fractional part of the first number using the third number's segments; and
output results of the numeric operation as a fourth number having the first radix.
17. The system of
store the segments of the third number into one or more data structures.
18. The system of
19. The system of
20. A computer storage medium having computer readable program code embodied thereon for programming one or more disparate processor-based computing systems to perform numeric operations with improved precision, the program code comprising:
instructions to segment a first number having a first radix into a plurality of segments according to executable segmentation instructions that:
append additional digits to the segment in the plurality of segments which has less digits than the other segments in the plurality of segments such that all segments have the same number of digits;
instructions to perform a numeric operation on the plurality of segments; and
instructions to output results of the numeric operation on the plurality of segments as a second number having the first radix.
21. The medium of
instructions to store the segments of the first number into one or more data structures.
22. The medium of
23. The medium of
instructions to receive a third number;
instructions to segment the third number into segments;
instructions to perform a numeric operation on the digits of the integral part and fractional part of the first number using the third number's segments; and
instructions to output results of the numeric operations as a fourth number having the first radix.
24. The medium of
instructions to store the segments of the third number into one or more data structures.
25. The medium of
26. The medium of
27. A processor-implemented method for performing numeric operations with improved precision, comprising:
segmenting a first number having a first radix, an integral part and a fractional part, wherein the first number is segmented into a plurality of integral part segments and a plurality of fractional part segments according to executable segmentation instructions that:
cause each segment in the plurality of integral part segments and fractional part segments to have a second radix that is greater than the first radix of the first number,
identify an integral part segment which has a number of digits that is less than the number of digits in the other integral part segments,
append additional digits to the beginning of the integral part segment which has less digits than the other integral part segments such that all integral part segments have the same number of digits,
identify a fractional part segment which has a number of digits that is less than the number of digits in the other fractional part segments, and
append additional digits to the end of the fractional part segment which has less digits than the other fractional part segments such that all fractional part segments have the same number of digits;
performing a numeric operation on the plurality of integral part segments and fractional part segments; and
outputting results of the numeric operation on the plurality of integral part segments and fractional part segments as a second number having the first radix.
Description This document relates generally to the field of computer arithmetic, and more specifically, to methods and systems for performing large-radix numeric operations. Since most modern digital computers are transistor based, binary numbers have been traditionally used for internal computer processing. The binary number system, also known as radix-2, consists of just two unique numbers, 0 and 1, which conveniently represent the “off” and “on” states of a transistor element. In contrast, humans generally use decimal number system, also know as radix-10, which consists of numbers 0 through 9 coinciding with 10 fingers of two hands. To interact with a computer, decimal-based input data is converted to binary for computer processing. Thus, for example, when a calculation involves integers, a decimal number is represented as powers of 2 (i.e., 2 Due to design limitations, most modern computers cannot effectively represent repeating binary fractions. In particular, a typical computer system recognizes several native data types, including integer, single-precision floating point, double-precision floating point and character. One of the differences between these data types is the amount of memory allocated by the system to each data type. On a typical 32-bit system, characters are often stored in 8 bits, a short data type is 16 bits, integer and single-precision floating point numbers are 32 bits, and double-precision floating point numbers are 64 bits. As a result, due to the limited memory provided by a typical computer system for representation of data, a repeating binary fraction may be truncated and rounded off to fit into the available memory. This can lead to rounding errors that cause results calculated in radix-10 and those calculated in radix-2 to be different. The differences can easily escalate when many of such rounded-off numbers are multiplied or added resulting in significant discrepancies between the decimal and binary representations. This can be problematic in many applications, especially those dealing with monetary and monetary exchange calculations. Some of these problems can be avoided if calculations are done by the computer in a radix-10 based number system. The two most popular approaches to the radix-10 computer arithmetic are large binary integers and small decimal digits techniques. The large binary integer solution requires writing software functions that allow calculation of large integers (e.g., 256 bit integers). Calculations can be done rapidly, but it can be very difficult to determine decimal point placement for addition and subtraction, because the number is in binary, but the decimal point needs to be placed between decimal digits. Therefore this approach is generally used for fixed point calculations (e.g., calculations where the decimal point is in a fixed location in the numbers to be processed). This approach ignores the decimal point in the calculation and simply implies it in the result. The only place where the decimal point is acknowledged is when a number needs to be displayed. This also requires that all calculations be done at the same precision in order to avoid the problem of aligning two binary numbers for a decimal operation, like addition. Another approach is the small decimal digit approach which generally uses one-half to one byte (8 bits) to store a decimal digit. Thus, each decimal digit (0-9) is encoded by a corresponding four-bit binary number, so that a sequence of decimal digits can then be represented by concatenating the four-bit binary numbers. This makes placing the decimal point easier, but the calculation is much slower because each decimal digit is handled separately. In addition, there is a significant loss of storage efficiency because four bits can store decimal numbers 0-15 but are used in this approach to store only numbers 0-9. Furthermore, similar to the large binary integer approach, implementation details for the small decimal digit method differ significantly from processor-to-processor. This makes creating a platform-independent solution difficult. In accordance with the teachings provided herein, methods and systems for performing large-radix computer arithmetic are disclosed. In one example, a method provides for one or more input decimal numbers (e.g., radix-10 numbers) to be segmented into one or more large-radix segments. The radix of each segment may be greater than the radix of a decimal number (i.e., 10). As an illustration, the radix of a segment may be a multiple of 10, such as 100, 1000, 10,000, 100,000, 1,000,000, etc. If the decimal number has a fractional part, the number may be segmented so that the decimal point is placed between two adjacent large-radix segments. Once the decimal number is segmented, various numeric operations may be performed on the large-radix segments of the decimal number. Such operations may include, but are not limited to, unary, arithmetic, logic, or character string conversion operations. Finally, the result of the numeric operation on the large-radix segments of the decimal number may be outputted in decimal form. As another example, a computer system for large-radix arithmetic may comprise a processor and a memory. The processor may be configured to segment a decimal input number into segments having a radix greater than the radix of the decimal number. If the decimal number has a fractional part, the processor is configured to identify the decimal point and segment the decimal number so that the decimal point is placed between two adjacent large-radix segments. Each large-radix segment may be represented by any data type supported by the computer system (e.g., integer, single-precision floating point, double-precision floating point and character data types). Furthermore, large-radix segments may be stored in the system memory in one or more data structures, such as an array, a linked list, etc. A processor may then perform one or more numeric operations on the large-radix segments. As described above, the operations may include unary, arithmetic, logic, character string conversion operations, etc. The result of the numeric operation may then be outputted as a decimal number. In another example, a system may be further configured to receive a second decimal number and segment it into one or more large-radix segments, having the same radix as the first decimal number. The large-radix segments of the second number may also be stored in a data structure, such as an array, a linked list, etc. The processor may then perform one or more numeric operations on the large-radix segments on the first and second decimal numbers. If one or both decimal numbers have a fractional part, the numeric operations of the large-radix segments of the first and second numbers are performed on the respective segments in the integral and fractional parts on the decimal numbers. Thus, for example, to perform large-radix addition, two segmented decimal numbers are aligned at the respective decimal points and added segment by segment, with a carry added (if needed) to the next segment pair. In the event the carry exceeds the available number of segments, an additional data element may be added to store the carry as a new large-radix segment. Finally, the result of the numeric operation may be outputted as a decimal number. In another example, a computer-usable medium having computer-readable program code embodied thereon for programming one or more disparate processor-based computing systems to perform numeric operations is disclosed. The program code may comprise instructions for accepting an input decimal number from a user and segmenting the input decimal number into large-radix segments, wherein the radix of a segment is greater than the radix of the decimal number. The program code may further comprise instructions for identifying presence of a decimal point, and segmenting the decimal number so that the decimal point is placed between two adjacent large-radix segments. The program code may further comprise instructions for performing one or more numeric operations on the large-radix segments of the decimal number and instructions for outputting the result of the numeric operations as a decimal number. The program code may further comprise instructions for storing the large-radix segments of the decimal number into one or more data structures, including an array, a linked list, etc. In yet another example, a method for implementing large-radix computer arithmetic is disclosed. First, a developer may determine a computing platform on which the large-radix arithmetic will be implemented. A computing platform may include at least a processor, a memory and an operating system. Depending on the hardware and software constraints of the computing platform, as well as the application requirements, a developer may select a radix for a large-radix segment. To select a radix, the developer may consider data types provided by the platform and cost of computation of one or more native operations on each data type. As an illustration, in a computing platform optimized for floating-point arithmetic, an operation performed on two floating-point numbers may be less costly, e.g., with respect to system time and resource consumption, than the same operation performed on two integer numbers. Based upon one or more of these considerations, instructions code for large-radix numeric operations may be written. Processor System memory System memory Finally, the input and output devices As shown in A system for large-radix arithmetic is described next with reference to The user input instructions The numeric input data may be in a variety of numeric formats. In one example, the numeric input data is in a decimal form. For convenience, the subsequent examples of the systems and methods for large-radix arithmetic will be described with reference to decimal input data format, unless noted otherwise. It should be understood, however, that user input instructions may be written to accept and to perform large-radix arithmetic on any other data format, such as binary, hexadecimal, character strings, etc. Furthermore, inputs and outputs disclosed herein may be with other than a user, such as with a computer program. The user input instructions The system for large-radix arithmetic in Thus, if the radix of the larger-radix segment is one thousand (1000), which corresponds to numbers 0 through 999, the above-referenced decimal number may be segmented into a plurality of three-digit segments as follows: 749 741 693 472 770 462 348. If the radix of the large-radix segment is one million (1,000,000), which correspond to numbers 0 through 999999, the above decimal number may be segmented into a plurality of six-digit segments as follows: 749 741693 472770 462348. To achieve uniformity, the most significant large-radix segment, 749, may be represented as 000749 without loss of precision, so that each large-radix segment comprises six decimal digits. If the input is a fractional number, such as 749741693472770462348.0261983465, the segmentation instructions Next, the segmentation instructions The segmentation instructions For example, most current computer systems use 64-bit double precision floating point data elements and only 32-bit integer type data elements. An integer data type uses all of the available 32 bits to store value of the number. A double precision floating point data type uses a part of the number of the allocated 64 bits to store the value of the number in a large-integer format with the remainder of the 64 bits being used to store the value of the exponent of the number. Because an integer data type uses all of its available 32 bits to store a value of the number, segments having a large radix can be stored as a 32 bit integer. As another example, a double precision floating point data type can potentially store segments with a much larger radix than the integer data type, however, because the double precision floating point data type uses only a fraction of the available 64 bits to store the value of the segment, the remainder of the bits used for the exponent are not used because each segment is a whole number with exponent of 1. Thus, an integer data type may be more memory efficient than the double precision data type. Once the input numbers are segmented by the segmentation instructions As shown in As an example, numeric operations may be performed on large-radix segments of the input number on a segment-by-segment basis. Thus for example, let the large radix value=1,000,000, let large-radix segment a=999991 and large-radix segment b=999992. Accordingly, a multiplication of a by b yields: 999991*999992=999983000072. In this example, a single precision floating point data type may be used to hold each large-radix segment and a double precision floating point data type may be used to hold the result. The result may then be split into two single-precision floating point data segments, with the least significant large-radix segment holding 000072 and the most significant large-radix segment holding 999983. The segments may then be stored in a results data structure. If the operands have more large-radix segments, the most significant large radix segment of the result, 999983, may be added as a carry to the product of other segments. Once the numeric operations have been performed on the input number(s), the process flow proceeds to the user output instructions Next in step Next in step Next in step Finally in step It should be understood, that similar to the other processing flows described herein, the steps and the order of the steps in the flowchart may be altered, modified and/or augmented and still achieve the desired outcome. An example method for implementing large-radix arithmetic is described next with reference to In step Next in step Once the developer has chosen the characteristics of the numbers, the developer may wish to design an appropriate data structure. Different programming languages provide different data structures. In addition, there are available template libraries of various data structures. Data structures can include arrays, dynamic arrays, linked lists, queues, etc. Alternatively, a developer may design a separate data structure to hold large-radix digits. In general, a large-radix data structure may contain a collection of large-radix segments, a sign indicator, and a decimal point location. The developer may also keep the current number of large-radix segments in use and an indicator to mark the number as invalid (e.g., for results of an operation that have no valid interpretation, such as dividing a number by zero). The developer may also use two or more data structures to separately store large-radix segments associated with integral and fractional parts of the number. In step In step At step Addition and subtraction operations may be similar if both operands have the same sign. When the signs differ, appropriate sign changes may be made and the opposing operation may be invoked. For example: −1+2 can be rewritten as 2−1. In this example of addition, a developer could align the decimal points of the two numbers. Under this method, decimal points could be allowed between large-radix segments. One approach is to determine which of the two operands have the most digits to the right of the decimal point. This operand's lowest order large-radix segment is copied into the result variable, until the location of the lowest order segment of the other operand is reached. At this point a sum (with carry) is computed for each large-radix segment pair. Below is an illustration of addition for an arbitrary number of digits using this method. Given two numbers: a=42335793867023.2415134590875645 and b=39756893578230459872.36049873 Let these numbers be segmented into large-radix segments as follows (radix=1,000,000 in this example): a=000042 335793 867023.241513 459087 564500 b=000039 756893 578230 459872.360498 730000 Note that this effectively breaks the two numbers down into a series of six digit segments centered around their respective radix points. Now a and b can be added (with carry) as follows:
An example flow chart diagram for implementing large-radix addition on two numbers is shown in The diagram uses the following functions: -
- MAX(x, y)—returns the greater of the two values x and y.
- NBDR(x)—returns the number of large-radix segments to the right of the decimal point. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBDR(x) would return y. - NBDL(x)—returns the number of large-radix segment to the left of the decimal point. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBDL(x) would return (z−y). - NBD(x)—returns the number of large-radix segments in x. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBD(x) would return z.
With reference to Below is an example of large-radix subtraction for two fractional numbers. Given two numbers: a=39756893578230459872.36049873 and b=42335793867023.2415134590875645 Let these numbers be segmented into large-radix segments as follows (radix=1000000 in this example): a=000039 756893 578230 459872.360498 730000 b=000042 335793 867023.241513 459087 564500 Numbers a and b may be subtracted as follows:
An exemplary flow chart diagram for implementing large-radix subtraction of two fractional numbers is shown in The diagram uses the following functions: -
- MAX(x, y)—returns the greater of the two values x and y.
- NBDR(x)—returns the number of large-radix segments to the right of the decimal point. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBDR(x) would return y. - NBDL(x)—returns the number of large-radix segments to the left of the decimal point. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBDL(x) would return (z−y). - NBD(x)—returns the number of large-radix segments in x. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBD(x) would return z.
With reference to Below is an example of large-radix multiplication of two fractional numbers. Given two numbers: a=578230459872.360493 and b=867023.24151. The number are segmented into a plurality large-radix segments (radix=1000000 in this example): a=578230 459872.360493 b=867023.241510 Numbers a and b may be multiplied as follows:
An example flow chart diagram for implementing large-radix multiplication of two fractional numbers is shown in The diagram uses the following functions: -
- NBDR(x)—returns the number of large-radix segments to the right of the decimal point. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBDR(x) would return y. - NBD(x)—returns the number of large-radix segments in x. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBD(x) would return z. - HD(x)—returns the high order large-radix segments in x. If x were composed of x
_{2}x_{1 }then HD(x) would return x_{2}. - LD(x)—returns the low order large-radix segments in x. If x were composed of x
_{2}x_{1 }then LD(x) would return x_{1}.
- NBDR(x)—returns the number of large-radix segments to the right of the decimal point. If x were x
With reference to In another example, large-radix multiplication can also be done by generating partial products and summing them together. This optimization technique can be seen in example C code shown in A consideration in the large-radix division is the placement of radix point. Placement of the radix point can be based on the difference between the segment count of the dividend and the divisor relative to their respective segment points. A divisor that is less than one will push the radix point to the right of its position in the dividend. In contrast, a divisor being greater than one will push the radix point to the left. Below is an example of large-radix division for two fractional numbers. Given two numbers: a=578230459872.360493 and b=867023.24151. Let these numbers be segmented into large-radix segments as follows (radix=1000000 in this example): a=578230 459872.360493 b=867023.241510 Now divide a by b (with the decimal point being ignored): (a) 578230 459872 360493/(b) 867023 241510 Partial Quotient 1: 666914 -
- 578230 459872 360493−(666914*867023 241510)
Remainder=521783 960353 Partial Quotient 2: 601810 -
- 521783 960353−(601810*867023 241510)
Remainder=703379.866900 This process is repeated until a remainder is equal to zero or until the desired precision is reached. The result of a division operation might be an infinite series of digits. Therefore there may be a maximum precision limit placed on the division operation. An example flow chart diagram for implementing large-radix division of two fractional numbers is shown in The diagram uses the following functions: -
- MSBD(x)—returns the most significant large-radix segment of x. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then MSBD(x) would return x_{z}. - NBD(x)—returns the number of large-radix segments in x. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBD(x) would return z. - MP—maximum number of large-radix segments to return in the result.
- NBDL(x)—returns the number of large-radix segments to the left of the decimal point. If x were x
_{z}x_{z−1 }. . . x_{y+1}·x_{y }. . . x_{2}x_{1 }then NBDL(x) would return (z−y). - DP(x)—location of the decimal point within x.
- [x]—floor, returns the largest whole number that is less than or equal to x.
- Add(x, y)—returns the sum of x and y. Rules of the addition are based on the rules of this system. (See large-radix addition example above).
- SubB(x, y, b)—returns the difference between x and y. Additional b is returned with the state of the borrow at the end of the subtraction. Rules of the addition are based on the rules of this system. (See large-radix subtraction example above).
- Mul(x, y)—returns the product of x and y. Rules of the addition are based on the rules of this system. (See large-radix multiplication example above).
- MSBD(x)—returns the most significant large-radix segment of x. If x were x
With reference to If at the decision step Yet another large-radix operation example could be a character string conversion. If the large-radix is a whole positive power of ten, no explicit radix conversion is required when numbers are moved to and from character strings. Most programming languages have facilities to convert basic numeric types to and from string types. These can be used to convert each large-radix segment. In a language like C, for example, the library “printf” function can be used to directly convert each large-radix segment into a string representation of that segment. Since the base is a whole positive power of ten these strings can be concatenated (as in the “strcat” library function) together with the decimal point into a complete representation of the number. Alternatively, lookup tables can be used to do large-radix segment conversions. Converting from a character string to a number can be done in a similar fashion, either by calling a library function native to the implementation language (e.g., “scanf” in C) or by doing a reverse table look up. An example method for large-radix character string conversion using a lookup table of -
- INT(x)=the closest whole number not greater than x
- MOD(x, y)=x−(INT(x/y)*y)
The number a can be converted to a character string by starting with the most significant large-radix segment and looking up each two digit “sub-number” inFIG. 11B . The lookup may be performed on all or part of the large-radix segment in order to generate the character string faster. A larger lookup table means that fewer sub-digits need to be computed therefore a faster conversion, but a greater memory cost may be necessary to store the table.
The above-described systems and methods for large-radix arithmetic may be implemented on various types of computer architectures, such as for example on a single general purpose computer or workstation, or on a networked system, or in a client-server configuration, or in an application service provider configuration. In multiple computer systems, data signals may be conveyed via networks (e.g., local area network, wide area network, internet, etc.), fiber optic medium, carrier waves, wireless networks, etc. for communication among multiple computers or computing devices. The systems' and methods' data (e.g., associations, mappings, etc.) may be stored and implemented in one or more different types of computer-implemented ways, such as different types of storage devices and programming constructs (e.g., data stores, RAM, ROM, Flash memory, flat files, databases, programming data structures, programming variables, IF-THEN (or similar type) statement constructs, etc.). It is noted that data structures describe formats for use in organizing and storing data in databases, programs, memory, or other computer-readable media for use by a computer program. The systems and methods may be provided on many different types of computer-readable media including computer storage mechanisms (e.g., CD-ROM, diskette, RAM, flash memory, computer's hard drive, etc.) that contain instructions for use in execution by a processor to perform the methods' operations and implement the systems described herein. The computer components, software modules, functions, data stores and data structures described herein may be connected directly or indirectly to each other in order to allow the flow of data needed for their operations. It is also noted that a module or processor includes but is not limited to a unit of code that performs a software operation, and can be implemented for example as a subroutine unit of code, or as a software function unit of code, or as an object (as in an object-oriented paradigm), or as an applet, or in a computer script language, or as another type of computer code. The software components and/or functionality may be located on a single computer or distributed across multiple computers depending upon the situation at hand. As another example of the wide scope of the systems and methods disclosed herein, a system and a method can be configured for the rapid calculations of decimal based floating point numbers in a platform-independent hardware environment, wherein a fixed or arbitrary number of digits can be calculated in a time efficient manner using the instructions available in all modern hardware, while retaining the decimal (base Patent Citations
Referenced by
Classifications
Legal Events
Rotate |