You do not have permission to edit this page, for the following reasons:

This IP address has been blocked from editing Wikipedia.
This does not affect your ability to read Wikipedia pages.
Most people who see this message have done nothing wrong. Some kinds of blocks restrict editing from specific service providers or telecom companies in response to recent abuse or vandalism, and can sometimes affect other users who are unrelated to that abuse. Review the information below for assistance if you do not believe that you have done anything wrong.

The IP address or range 44.199.0.0/16 has been blocked (disabled) by ‪Blablubbs‬ for the following reason(s):

The IP address that you are currently using has been blocked because it is believed to be a web host provider or colocation provider. To prevent abuse, web hosts and colocation providers may be blocked from editing Wikipedia.
You will not be able to edit Wikipedia using a web host or colocation provider because it hides your IP address, much like a proxy or VPN.
We recommend that you attempt to use another connection to edit. For example, if you use a proxy or VPN to connect to the internet, turn it off when editing Wikipedia. If you edit using a mobile connection, try using a Wi-Fi connection, and vice versa. If you are using a corporate internet connection, switch to a different Wi-Fi network. If you have a Wikipedia account, please log in.
If you do not have any other way to edit Wikipedia, you will need to request an IP block exemption.

How to appeal if you are confident that your connection does not use a colocation provider's IP address:
If you are confident that you are not using a web host, you may appeal this block by adding the following text on your talk page: ((unblock|reason=Caught by a colocation web host block but this host or IP is not a web host. My IP address is _______. Place any further information here. ~~~~)). You must fill in the blank with your IP address for this block to be investigated. Your IP address can be determined here. Alternatively, if you wish to keep your IP address private you can use the unblock ticket request system. There are several reasons you might be editing using the IP address of a web host or colocation provider (such as if you are using VPN software or a business network); please use this method of appeal only if you think your IP address is in fact not a web host or colocation provider.

Administrators: The IP block exemption user right should only be applied to allow users to edit using web host in exceptional circumstances, and requests should usually be directed to the functionaries team via email. If you intend to give the IPBE user right, a CheckUser needs to take a look at the account. This can be requested most easily at SPI Quick Checkuser Requests. Unblocking an IP or IP range with this template is highly discouraged without at least contacting the blocking administrator.

This block will expire on 12:56, 12 May 2024.

Even when blocked, you will usually still be able to edit your user talk page, as well as email administrators and other editors.

For information on how to proceed, please read the FAQ for blocked users and the guideline on block appeals. The guide to appealing blocks may also be helpful.

Other useful links: Blocking policy · Help:I have been blocked
Your IP address is in a range that has been blocked on all Wikimedia Foundation wikis. The block was made by ‪AntiCompositeNumber‬. The reason given is Open proxy/Webhost: Visit the FAQ if you are affected .
- Start of block: 13:55, 18 August 2022
- Expiry of block: 13:55, 18 May 2025
Your current IP address is 44.199.189.47. The blocked range is 44.199.0.0/16. Please include all above details in any queries you make. If you believe you were blocked by mistake, you can find additional information and instructions in the No open proxies global policy. Otherwise, to discuss the block please post a request for review on Meta-Wiki. You could also send an email to the stewards VRT queue at stewards@wikimedia.org including all above details.

You can view and copy the source of this page:

((refimprove|date=July 2007))

In [[computer science]], a '''scale factor''' is a [[number]] used as a multiplier to represent a number on a different [[order of magnitude|scale]], functioning similarly to an [[exponent]] in [[mathematics]]. A scale factor is used when a real-world set of numbers needs to be represented on a different scale in order to fit a specific [[Computer numbering formats|number format]]. Although using a scale factor extends the range of representable values, it also decreases the [[Precision (computer science)|precision]], resulting in [[rounding error]] for certain calculations. 

==Uses==
Certain number formats may be chosen for an application for convenience in programming, or because of certain advantages offered by the hardware for that number format. For instance, early processors did not natively support [[floating-point arithmetic]] for representing fractional values, so integers were used to store representations of the real world values by applying a scale factor to the real value. Similarly, because hardware arithmetic has a fixed width (commonly 16, 32, or 64 [[bit]]s, depending on the [[data type]]), scale factors allow representation of larger numbers (by manually multiplying or dividing by the specified scale factor), though at the expense of precision.((sfn|Linz|Wang|2003|pp=12–13)) By necessity, this was done in [[software]], since the hardware did not support fractional value. Scale factors are also used in floating-point numbers, and most commonly are [[powers of two]]. For example, the [[double-precision floating-point format|double-precision format]] sets aside 11 bits for the scaling factor (a [[binary number|binary]] exponent) and 53 bits for the [[significand]], allowing various degrees of precision for representing different ranges of numbers, and expanding the range of representable numbers beyond what could be represented using 64 explicit bits (though at the cost of precision).((sfn|Linz|Wang|2003|pp=14–15))

As an example of where precision is lost, a 16-bit [[signedness|unsigned]] [[integer]] (''uint16'') can only hold a value as large as 65,535<sub>10</sub>. If unsigned 16-bit integers are used to represent values from 0 to 131,070<sub>10</sub>, then a scale factor of ((frac|1|2)) would be introduced, such that the scaled values [[bijection|correspond exactly]] to the real-world [[even integer]]s. As a consequence, for example, the number 3 cannot be represented, because a stored ''1'' represents a real-world 2, and a stored ''2'' represents a real-world 4; there are not enough bits available to avoid this error in this representation.

==Operations on scaled values==
Once the scaled representation of a real value is stored, the scaling can often be ignored until the value needs to come back into the "real world". For instance, [[addition|adding]] two scaled values is just as valid as unscaling the values, adding the real values, and then scaling the result, and the former is much easier and faster. In either approach, though, the two added numbers must be scaled the same.((sfn|Yates|2013|p=6)) For other operations, the scaling is very important.

Multiplication, for instance, needs to take into account that both numbers are scaled. As an example, consider two real world values ''A'' and ''B''. The real world [[multiplication]] of these real world values is:
<pre>A * B = P
</pre>
If they are instead represented with a scale factor of ''Z'', and these scaled representations are subsequently multiplied, the result is the following:
<pre>AZ * BZ = Q
</pre>
''AZ'' is the scaled real world value of ''A'', or simply the [[product (mathematics)|product]] of ''A * Z'', and likewise, ''BZ'' is the scaled representation of ''B''. After the scaled multiplication, the answer is not written ''PZ'', because the value stored in ''PZ'' is ''not'' the answer. This can be seen by rearranging the statement, where each line in the following is equivalent:
<pre>AZ * BZ = Q
A * Z * B * Z = Q
(A * B) * Z * Z = Q
P * Z * Z = Q
PZ * Z = Q
</pre>
In line 4, ''P'' substitutes ''A * B''. It follows that the result of ''AZ * BZ'' (which is ''Q'') is ''not'' ''PZ'', but rather ''PZ * Z''. If ''PZ'' were the answer, it could be stored directly since it has the scale factor built in, as is the case with addition and [[subtraction]]. For multiplication, however, the product of two scaled values has an extra scaling built in. As long as this is taken into account, there is still no need to convert ''AZ'' and ''BZ'' into ''A'' and ''B'' before performing the operation; the result must be divided by ''Z'' before storing it back. After this, ''PZ'' will be stored as the result of the multiplication, which is indeed the scaled representation of the result of ''A * B'' (the desired answer) rather than the result of ''AZ * BZ'' (which is still scaled).

==Common scaling scenarios==
===Fractional values scaled to integers===
As previously described, many older processors (and possibly some current ones) do not natively support fractional arithmetic. In this case, [[fractional value]]s can be scaled into integers by multiplying them by ten to the power of whatever [[decimal]] precision is desired. In other words, to preserve ''n'' digits to the right of the [[decimal point]], it is necessary to multiply the entire number by [[power of 10|10<sup>''n''</sup>]]. In computers, which perform calculations in binary, the real number is multiplied by 2<sup>''m''</sup> to preserve ''m'' digits to the right of the [[binary point]]; alternatively, one can [[bit shift]] the value ''m'' places to the left. For example, in the following set of real world fractional values, all have three digits to the right of the decimal point:
<pre>15.400, 0.133, 4.650, 1.000, 8.001
</pre>
To save all of that information (in other words, not lose any [[Precision (computer science)|precision]]), these numbers must be multiplied by 10<sup>''3''</sup> (1,000), giving integer values of:
<pre>15400, 133, 4650, 1000, 8001
</pre>
Because of the value of the scaled numbers, they cannot be stored in 8bit integers; they will require at least 14 unsigned bits, or, more realistically, 16.

===Integer values to fractions===
Certain processors, particularly [[Digital signal processor|DSPs]] common in the [[embedded system]] industry, have built in support for the [[fixed-point arithmetic]], such as [[Q (number format)|Q]] and [[IQ (number format)|IQ]] formats.

Since the fractional part of a number takes up some bits in the field, the range of values possible in a fixed9point value is less than the same number of bits would provide to an integer.((sfn|Yates|2013|pp=4–5)) For instance, in an 8 bit field, an unsigned integer can store values from <nowiki>[0, 255]</nowiki>, but an unsigned fixed-point with 5 bits allocated to the fractional part only has 3 bits left over for the integer value, and so can only store integer values from <nowiki>[0, 7]</nowiki>. (The number of distinct values that the two fields can store is the same, 2<sup>8</sup> = 256, because the fixed-point field can also store 32 fractional values for each integer value.) It is therefore common that a scaling factor is used to store real world values that may be larger than the maximum value of the fixed-point format.

As an example, when using an unsigned 8-bit fixed-point format (which has 4 integer bits and 4 fractional bits), the highest representable integer value is 15, and the highest representable mixed value is 15.9375 (0xF.F or 1111.1111<sub>b</sub>). If the desired real world values are in the range [0,160], they must be scaled to fit within this fixed-point representation. A scale factor of ((frac|1|10)) ''cannot'' be used here, because scaling 160 by ((frac|1|10)) gives 16, which is greater than the greatest value that can be stored in this fixed-point format. However, ((frac|1|11)) will work as a scale factor, because the maximum scaled value, ((frac|160|11))&nbsp;= 14.((overline|54)), fits within this range. Given this set:
<pre>154, 101, 54, 3, 0, 160
</pre>
Scaling these with the scale factor ((frac|1|11)) gives the following values:
<pre>154/11&nbsp;= 14
101/11&nbsp;= 9.1818...
54/11&nbsp;= 4.9090...
3/11&nbsp;= 0.2727...
0/11&nbsp;= 0
160/11&nbsp;= 14.5454...
</pre>
Many of these values have been truncated because they contain [[repeating decimal]]s, which follows from the chosen scale factor (elevenths do not terminate in decimal). When storing these in our fixed-point format, some precision will be lost (in contrast to the exact values of the original integers). This is also a problem because an 8-bit format can store 256 different values, but the numbers in this set are from a range with only 161 possible values (0 through 160). As it turns out, the problem was the scale factor, ((frac|1|11)), which introduced unnecessary precision requirements and [[rounding error]] (when approximating a real value with the nearest representable value).((sfn|Linz|Wang|2003|p=18)) To avoid or resolve this problem, one must choose a better scale factor.

===Choosing a scale factor===
The example above illustrates how certain scale factors can cause unnecessary precision loss or rounding error, highlighting the importance of choosing the right scale factor. Using the scale factor of ((frac|1|11)) and converting to binary representations, the following values are obtained:
<pre>154/11&nbsp;= 14&nbsp;= 1110.0
101/11&nbsp;= 9.1818...&nbsp;= 1001.00101110...
54/11&nbsp;= 4.9090...&nbsp;= 100.111010...
3/11&nbsp;= 0.2727...&nbsp;= 0.010010...
0/11&nbsp;= 0&nbsp;= 0.0
160/11&nbsp;= 14.5454...&nbsp;= 1110.10010...
</pre>

Several of the binary fractions require more than the four fractional bits provided by the set fixed-point format. (This is in part because elevenths do not terminate in binary either.) To fit them into the fields (4 integer and 4 fractional bits), it is possible to truncate the remaining bits, giving the following stored representations:
<pre>1110.0000
1001.0010
0100.1110
0000.0100
0000.0000
1110.1001
</pre>
Or in decimal:
<pre>14.0
9.125
4.875
0.25
0.0
14.5625
</pre>
When they are called back into the real world, they are divided by the scale factor, ((frac|1|11)). This is the [[inverse function|inverse]] of the original scaling, giving the following "real world" values:
<pre>154.0
100.375
53.625
2.75
0
160.1875
</pre>
These values are not equivalent to the originals (before scaling down and fitting into this 8-bit representation). Most noticeably, they are not all integers anymore, immediately indicating that an error was introduced in the storage, due to a poor choice of scaling factor.

====Choosing a better scale factor====
Most [[data set]]s will not have a perfect scale factor; most likely, there will be some error introduced by the scaling process. However, it may be possible to choose a better scale factor. The ideal scale factor may not be the smallest, but rather one that preserves as much precision as possible.

Dividing a number by a power of two is the same as shifting all the bits to the right once for each power of two. (This is the binary equivalent to shifting all decimal digits to the left or right when, respectively, multiplying or dividing by powers of ten.) The pattern of bits does not change, it just moves the number of places equal to the binary exponent (for instance, 3 places to the right when dividing by 8&nbsp;=&nbsp;2<sup>3</sup>). On the other hand, when dividing by a number that is not an integer power of two in binary, the bit pattern changes. This is likely to produce a bit pattern with more bits to the right of the binary point, artificially introducing required precision. This is especially true when the fractional part has a denominator that is not a power of two, as all fractions not [[reciprocal (mathematics)|reciprocals]] of powers of two recur in binary.<ref name=binfrac/> Therefore, it is almost always preferable to use a scale factor that is a power of two. It may still be possible to lose bits that get shifted right off the end of the field as a result of truncation, but this avoids introducing ''new'' bits that will be imprecise (due to rounding error) or truncated.<ref name=binfrac>((cite web |url=https://floating-point-gui.de/formats/binary/ |title=Binary Fractions |publisher=Floating-point-gui.de |accessdate=6 July 2020))</ref>

As an illustration the use of powers of two in the scale factor, a scale factor of ((frac|1|16)) can be applied to the above data set. The binary values for the original data set are given below:
<pre>154 = 1001 1010
101 = 0110 0101
54 =  0011 0110
3 =   0000 0011
0 =   0000 0000
160 = 1010 0000
</pre>
Being integers between 0 and 255, these all can be represented precisely with 8 bits. Scaling these by ((frac|1|16)) is the same as dividing by 16, which is the same as shifting the bits 4 places to the right. In this case, scaling is done by inserting a binary point between the first 4 bits and last 4 bits of each number. That happens to equal the predetermined format of this representation. Consequently, since all these numbers do not require more than 8 bits to represent them as integers, no more than 8 bits are required to scale them down and store them in a fixed-point format.

==See also==
* [[Logarithm]]
* [[Scaling (geometry)]]
* [[Scientific notation]]

==References==
((reflist))

* ((cite web |url=http://www.digitalsignallabs.com/fp.pdf |title=Fixed-Point Arithmetic: An Introduction |last=Yates |first=R. |date=2013 |publisher=Digital Signal Labs |url-status=live |archivedate=12 September 2015 |archiveurl=https://web.archive.org/web/20150912013429/http://www.digitalsignallabs.com/fp.pdf ))
* ((cite book |last1=Linz |first1=P. |last2=Wang |first2=R. L. C. |title=Exploring Numerical Methods: An Introduction to Scientific Computing Using MATLAB |date=2003 |publisher=[[Jones and Bartlett Publishers]] |isbn=0-7637-1499-2 ))

((DEFAULTSORT:Scale Factor (Computer Science)))
[[Category:Theory of computation]]

Pages transcluded onto the current version of this page (help):

Scale factor (computer science) (edit)
Template:Ambox (view source) (template editor protected)
Template:Cite book (view source) (protected)
Template:Cite web (view source) (protected)
Template:Find sources mainspace (view source) (template editor protected)
Template:Frac (view source) (template editor protected)
Template:Fraction (view source) (template editor protected)
Template:Fraction/styles.css (view source) (template editor protected)
Template:Main other (view source) (protected)
Template:More citations needed (view source) (template editor protected)
Template:Overline (view source) (template editor protected)
Template:Refimprove (view source) (template editor protected)
Template:Reflist (view source) (protected)
Template:Reflist/styles.css (view source) (protected)
Template:Sfn (view source) (template editor protected)
Module:Arguments (view source) (protected)
Module:Category handler (view source) (protected)
Module:Category handler/blacklist (view source) (protected)
Module:Category handler/config (view source) (protected)
Module:Category handler/data (view source) (protected)
Module:Category handler/shared (view source) (protected)
Module:Check for unknown parameters (view source) (protected)
Module:Citation/CS1 (view source) (protected)
Module:Citation/CS1/COinS (view source) (protected)
Module:Citation/CS1/Configuration (view source) (protected)
Module:Citation/CS1/Date validation (view source) (protected)
Module:Citation/CS1/Identifiers (view source) (protected)
Module:Citation/CS1/Utilities (view source) (protected)
Module:Citation/CS1/Whitelist (view source) (protected)
Module:Citation/CS1/styles.css (view source) (protected)
Module:Find sources (view source) (template editor protected)
Module:Find sources/config (view source) (template editor protected)
Module:Find sources/links (view source) (template editor protected)
Module:Find sources/templates/Find sources mainspace (view source) (template editor protected)
Module:Footnotes (view source) (template editor protected)
Module:Footnotes/anchor id list (view source) (template editor protected)
Module:Footnotes/anchor id list/data (view source) (template editor protected)
Module:Footnotes/whitelist (view source) (template editor protected)
Module:Message box (view source) (protected)
Module:Message box/ambox.css (view source) (protected)
Module:Message box/configuration (view source) (protected)
Module:Namespace detect/config (view source) (protected)
Module:Namespace detect/data (view source) (protected)
Module:Unsubst (view source) (protected)
Module:Yesno (view source) (protected)

Return to Scale factor (computer science).

Retrieved from "https://en.wikipedia.org/wiki/Scale_factor_(computer_science)"