History MediaNotes / PowersOfTwoMinusOne

Computers also have a limit to the maximum size a variable can be. It's not a hard limit, but using bigger numbers slows down computation considerably. Whenever you hear about the "number of bits" of a video game console (e.g., the UsefulNotes/NintendoEntertainmentSystem being "8-bit"), that's what they're referring to. The NES has an 8-bit data bus; it can only move 8 bits of data around at a time. If it has to move any more, it has to do it in more than one cycle. In technical terms, this is called "word size."

* '''12 bits''' can hold a value as high as 4095. Some NES games like ''VideoGame/FinalFantasyI'' used hacks to get values this large.

* '''128 bits''' can hold a value as high as 340.2 undecillion (or 3.4×10[[superscript:38]]). Computers usually do not have 128-bit general-purpose registers, but the [[UsefulNotes/PlayStation3 PS3]]'s Cell, the UsefulNotes/Xbox360's CPU, and modern x64 [=CPUs=] (used both in [[UsefulNotes/IBMPersonalComputer [=PCs=]]] and [[UsefulNotes/AppleMacintosh Macs]]) do have 128-bit vector registers (holding 4 32-bit values). These are used for [[VectorUnit vector math]].

** That's a part of the reasoning for the whole concept of "magic numbers" in engineering. When you are making something you need to decide on some properties (like plank size or ceiling height, for example) anyway, so why not use the ones that someone [[FollowTheLeader has already used before]]? And then it happens that the similar sizes allow for compatibility and interoperability, it becomes a self-reinforcing convention, and we all end up with 2×4's[[note]]Which, it should be noted, are [[NonIndicativeName actually 1½×3½]]. Aren't standards fun?[[/note]]. The same logic applies to the programming too.

* '''64 bits''' can hold a value as high as 18.4 quintillion (or 1.84×10[[superscript:19]]). The UsefulNotes/{{Nintendo 64}}, UsefulNotes/GameCube[[note]]Although with some 32-bit components[[/note]], Sony UsefulNotes/PlayStation2, and modern desktop [=PCs=] are all 64-bit, with 64-bit operating systems becoming rather commonplace in 2010 (at least, on new computers).

Computers also have a limit to the maximum size a variable can be. It's not a hard limit, but using bigger numbers slows down computation considerably. Whenever you hear about the "number of bits" of a video game console (e.g., the NintendoEntertainmentSystem being "8-bit"), that's what they're referring to. The NES has an 8-bit data bus; it can only move 8 bits of data around at a time. If it has to move any more, it has to do it in more than one cycle. In technical terms, this is called "word size."

* Floating point. This works like scientific notation; one bit is used to store the sign, some number of bits (called the mantissa) are used to store the number to the right of the decimal point, and the remaining bits (called the exponent) are, predictably, used to store the power of 2 to multiply by. (We use 2 instead of 10 because, again, computers work in binary.) It should be noted that this is a gross oversimplification.

* '''128 bits''' can hold a value as high as 340.2 undecillion (or 3.4×10[[superscript:38]]). Computers usually do not have 128-bit general-purpose registers, but the [[UsefulNotes/PlayStation3 PS3]]'s Cell, the [[UsefulNotes/Xbox360]]'s CPU, and modern x64 [=CPUs=] (used both in [[UsefulNotes/IBMPersonalComputer [=PCs=]]] and [[UsefulNotes/AppleMacintosh Macs]]) do have 128-bit vector registers (holding 4 32-bit values). These are used for [[VectorUnit vector math]].

* '''128 bits''' can hold a value as high as 340.2 undecillion (or 3.4×10[[superscript:38]]). Computers usually do not have 128-bit general-purpose registers, but the [[UsefulNotes/PlayStation3 PS3]]'s Cell, the X-Box 360's CPU, and modern x64 [=CPUs=] (used both in [[UsefulNotes/IBMPersonalComputer [=PCs=]]] and [[UsefulNotes/AppleMacintosh Macs]]) do have 128-bit vector registers (holding 4 32-bit values). These are used for [[VectorUnit vector math]].

Note that in addition to the above, most recent processors have additional "vector" processors for dealing with multiple calculations in parallel; these have so far been up to 256 bits wide. Also floating point calculations are often done at different sizes.

* '''32 bits''' can hold a value as high as 4,294,967,295. The UsefulNotes/SegaSaturn and [[UsefulNotes/SegaDreamcast Dreamcast]], Sony UsefulNotes/{{PlayStation}}, Microsoft UsefulNotes/{{XBox}} and the UsefulNotes/{{Wii}} are all 32-bit. So are desktop [=PCs=] made from 1987 to 2007. Most smartphones are 32-bit, with 64-bit phones starting to trickle out in 2013 and 2014.
* '''64 bits''' can hold a value as high as 18.4 quintillion (or 1.84×10[[superscript:19]]). The UsefulNotes/{{Nintendo64}}, UsefulNotes/GameCube[[note]]Although with some 32-bit components[[/note]], Sony UsefulNotes/PlayStation2, and modern desktop [=PCs=] are all 64-bit, with 64-bit operating systems becoming rather commonplace in 2010 (at least, on new computers).
* '''128 bits''' can hold a value as high as 340.2 undecillion (or 3.4×10[[superscript:38]]). Computers usually do not have 128-bit general-purpose registers, but the [[UsefulNotes/PlayStationThree PS3]]'s Cell, the X-Box 360's CPU, and modern x64 [=CPUs=] (used both in [[UsefulNotes/IBMPersonalComputer [=PCs=]]] and [[UsefulNotes/AppleMacintosh Macs]]) do have 128-bit vector registers (holding 4 32-bit values). These are used for [[VectorUnit vector math]].

* As a {{Cap}}. Programming for older systems is really ''really'' hard; these systems were relatively good at graphics processing, but very bad at calculations, so every CPU cycle saved was a big deal.[[note]]UsefulNotes/{{Atari 2600}} was hit the hardest: it had ''no'' UsefulNotes/VideoRAM, so programmers had to create the picture by timely manipulation of the graphic output registers, but as it also had no interrupt lines in the {{CPU}}, this was possible only by the careful timing of the program itself and inserting graphical output commands into the correct places.[[/note]] If you cap a value to the actual limit of your variable, you can enforce the cap with a "did previous instruction overflow" test, which is usually faster than a "is X greater than Y" test (the latter often involves hidden subtraction, even on newer processors).

** That's a part of the reasoning for the whole concept of "magic numbers" in engineering. When you are making something you need to decide on some properties (like plank size or ceiling height, for example) anyway, so why not use the ones that someone [[FollowTheLeader has already used before]]? And then it happens that the similar sizes allow for compatibility and interoperability, it becomes a self-reinforcing convention, and we all end up with 2×4's[[note]]Which, it should be noted, are [[MindScrew actually 1½×3½]]. Aren't standards fun?[[/note]]. The same logic applies to the programming too.

* '''32 bits''' can hold a value as high as 4,294,967,295. The UsefulNotes/SegaSaturn and UsefulNotes/{{Dreamcast}}, Sony UsefulNotes/{{PlayStation}}, Microsoft UsefulNotes/{{XBox}} and the UsefulNotes/{{Wii}} are all 32-bit. So are desktop [=PCs=] made from 1987 to 2007. Most smartphones are 32-bit, with 64-bit phones starting to trickle out in 2013 and 2014.

----

However, that's not the end of the story. All of those values assume that the variable is unsigned, meaning it can't hold a negative number. Signed numbers essentially throw away one bit in order to be able to store both positive ''and'' negative numbers. Zero is taken to be the first "positive" number, whereas negative numbers start at -1, which makes the negative limit higher (absolutely speaking). This effectively reduces by half the maximum number that the value can hold for the sake of representing negative numbers. Here are some revised tables:

* '''64 bits''' can hold a value as high as 18.4 quintillion (or 1.84×10[[superscript:19]]). The UsefulNotes/{{Nintendo64}}, UsefulNotes/GameCube[[note]]Although with some 32-bit components[[/note]], Sony [[UsefulNotes/PlayStationTwo PlayStation 2]], and modern desktop [=PCs=] are all 64-bit, with 64-bit operating systems becoming rather commonplace in 2010 (at least, on new computers).

* '''64 bits''' can hold a value as high as 18.4 quintillion (or 1.84×10[[superscript:19]]). The UsefulNotes/Nintendo64, UsefulNotes/GameCube[[note]]Although with some 32-bit components[[/note]], Sony [[UsefulNotes/PlayStationTwo PlayStation 2]], and modern desktop [=PCs=] are all 64-bit, with 64-bit operating systems becoming rather commonplace in 2010 (at least, on new computers).

* '''64 bits''' can hold a value as high as 18.4 quintillion (or 1.84×10[[superscript:19]]). The [[UsefulNotes/Nintendo64 Nintendo 64]], UsefulNotes/GameCube[[note]]Although with some 32-bit components[[/note]], Sony [[UsefulNotes/PlayStationTwo PlayStation 2]], and modern desktop [=PCs=] are all 64-bit, with 64-bit operating systems becoming rather commonplace in 2010 (at least, on new computers).

* '''64 bits''' can hold a value as high as 18.4 quintillion (or 1.84×10[[superscript:19]]). The [[UsefulNotes/NintendoSixtyFour Nintendo 64]], UsefulNotes/GameCube[[note]]Although with some 32-bit components[[/note]], Sony [[UsefulNotes/PlayStationTwo PlayStation 2]], and modern desktop [=PCs=] are all 64-bit, with 64-bit operating systems becoming rather commonplace in 2010 (at least, on new computers).

* As a {{Cap}}. Programming for older systems is really ''really'' hard; these systems were relatively good at graphics processing, but very bad at calculations, so every CPU cycle saved was a big deal.[[note]]UsefulNotes/{{Atari 2600}} was hit the hardest: it had ''no'' {{VRAM}}, so programmers had to create the picture by timely manipulation of the graphic output registers, but as it also had no interrupt lines in the {{CPU}}, this was possible only by the careful timing of the program itself and inserting graphical output commands into the correct places.[[/note]] If you cap a value to the actual limit of your variable, you can enforce the cap with a "did previous instruction overflow" test, which is usually faster than a "is X greater than Y" test (the latter often involves hidden subtraction, even on newer processors).

** That's a part of the reasoning for the whole concept of "magic numbers" in engineering. When you are making something you need to decide on some properties (like plank size or ceiling height, for example) anyway, so why not use the ones that someone [[FollowTheLeader has already used before]]? And then it happens that the similar sizes allow for compatibility and interoperability, it becomes a self-reinforcing convention, and we all end up with 2-by-4-s[[note]]Which, it should be noted, are actually 1½×3½. Aren't standards fun?[[/note]]. The same logic applies to the programming too.

** That's a part of the reasoning for the whole concept of "magic numbers" in engineering. When you are making something you need to decide on some properties (like plank size or ceiling height, for example) anyway, so why not use the ones that someone [[FollowTheLeader has already used before]]? And then it happens that the similar sizes allow for compatibility and interoperability, it becomes a self-reinforcing convention, and we all end up with 2-by-4-s. The same logic applies to the programming too.

* '''12 bits''' can hold a value as high as 4095. Some NES games like ''Franchise/FinalFantasy'' used hacks to get values this large.

* '''12 bits''' can hold a value as high as 4095. Some NES games like ''Videogame/FinalFantasy'' used hacks to get values this large.

Video games are nothing more than computer programs, and they're limited by the systems they run on. One particularly strict limitation is the fact that computers can't handle numbers of arbitrary size with any kind of efficiency. Since efficiency is normally pretty important for video games, this places some hard limits on the range of values they can work with. Since computers work in binary, that size has to be a certain number of bits (binary digits - a zero or a one). Numbers stored in a computer's memory are called ''variables''.

Computers also have a limit to the maximum size a variable can be. It's not a hard limit, but using bigger numbers slows down computation considerably. Whenever you hear about the "number of bits" of a video game console (i.e. the NintendoEntertainmentSystem being "8-bit"), that's what they're referring to. The NES has an 8-bit data bus; it can only move 8 bits of data around at a time. If it has to move any more, it has to do it in more than one cycle. In technical terms, this is called "word size."

In newer video games, many things - say, the number of items in the player's HyperspaceArsenal - are {{cap}}ped at reasonable limits because the variable actually used to store that value has a decidedly ''un''reasonable limit. However, in older days, it was common to let the computer itself cap these values, because the limits were a lot lower - an 8-bit computer such as the NES has a "limit" of 255.

* '''16 bits''' can hold a value as high as 65,535. The UsefulNotes/SuperNintendoEntertainmentSystem and UsefulNotes/SegaGenesis were 16-bit, as were [=PCs=] in the mid 1980s, and a few Japanese gaming computers.
* '''32 bits''' can hold a value as high as 4,294,967,295. The UsefulNotes/SegaSaturn and UsefulNotes/{{Dreamcast}}, Sony UsefulNotes/{{PlayStation}}, Microsoft UsefulNotes/{{XBox}} and the UsefulNotes/{{Wii}} are all 32-bit. So are desktop [=PCs=] from 1987 to 2007. Most smartphones are 32-bit, with 64-bit phones starting to trickle out in 2013 and 2014.

* '''128 bits''' can hold a value as high as 340.2 undecillion (or 3.4×10[[superscript:38]]). Computers usually do not have 128-bit general-purpose registers, but the [[UsefulNotes/PlayStationThree PS3]]'s Cell, the X-Box 360's CPU and modern x64 [=CPUs=] (used both in [[UsefulNotes/IBMPersonalComputer [=PCs=]]] and [[UsefulNotes/AppleMacintosh Macs]]) do have 128-bit vector registers (holding 4 32-bit values). These are used for [[VectorUnit vector math]].

So what happens if you try to store a number bigger than that? Say you were trying to add one to a 16-bit variable that's already set to 65,535. It would "wrap" - adding one to 65,535 would give you zero. Adding two would give you one. And so on, and so forth. The same goes the other way - subtracting one from zero gives you 65,535. When this happens, it's called "carry" if expected or "overflow" if not. This is the source of many GoodBadBugs; most of them are a case of programmer oversight, since the "overflow" flag in the CPU is triggered whenever this happens. Also see {{Cap}}.

However, that's not the end of the story. All of those values assume that the variable is unsigned, meaning it can't hold a negative number. Signed numbers essentially throw away one bit in order to be able to store both positive ''and'' negative numbers. Zero is taken to be the first "positive" number, while negative numbers start at -1, which makes the negative limit higher (absolutely speaking). This effectively reduces by half the maximum number that the value can hold for the sake of representing negative numbers. Here are some revised tables:

* '''8 bits''' can hold a value as high as 255. The {{Atari 2600}} and [[UsefulNotes/{{Atari 7800}} 7800]], NintendoEntertainmentSystem, SegaMasterSystem, and early home computers were all 8-bit.
* '''12 bits''' can hold a value as high as 4095. Some NES games like ''FinalFantasy'' used hacks to get values this large.
* '''16 bits''' can hold a value as high as 65,535. The SuperNintendoEntertainmentSystem and SegaGenesis were 16-bit, as were [=PCs=] in the mid 1980s, and a few Japanese gaming computers.
* '''32 bits''' can hold a value as high as 4,294,967,295. The SegaSaturn and {{Dreamcast}}, Sony {{PlayStation}}, Microsoft {{XBox}} and the {{Wii}} are all 32-bit. So are desktop [=PCs=] from 1987 to 2007. Most smartphones are 32-bit, with 64-bit phones starting to trickle out in 2013 and 2014.
* '''64 bits''' can hold a value as high as 18.4 quintillion (or 1.84×10[[superscript:19]]). The [[NintendoSixtyFour Nintendo 64]], GameCube[[note]]Although with some 32-bit components[[/note]], Sony [[PlayStationTwo PlayStation 2]], and modern desktop [=PCs=] are all 64-bit, with 64-bit operating systems becoming rather commonplace in 2010 (at least, on new computers).
* '''128 bits''' can hold a value as high as 340.2 undecillion (or 3.4×10[[superscript:38]]). Computers usually do not have 128-bit general-purpose registers, but the [[PlayStationThree PS3]]'s Cell, the X-Box 360's CPU and modern x64 [=CPUs=] (used both in [[IBMPersonalComputer [=PCs=]]] and [[AppleMacintosh Macs]]) do have 128-bit vector registers (holding 4 32-bit values). These are used for [[VectorUnit vector math]].

* As a {{Cap}}. Programming for older systems is really ''really'' hard; these systems were relatively good at graphics processing, but very bad at calculations, so every CPU cycle saved was a big deal.[[note]]{{Atari 2600}} was hit the hardest: it had ''no'' {{VRAM}}, so programmers had to create the picture by timely manipulation of the graphic output registers, but as it also had no interrupt lines in the {{CPU}}, this was possible only by the careful timing of the program itself and inserting graphical output commands into the correct places.[[/note]] If you cap a value to the actual limit of your variable, you can enforce the cap with a "did previous instruction overflow" test, which is usually faster than a "is X greater than Y" test (the latter often involves hidden subtraction, even on newer processors).

* '''8 bits''' can hold a value as high as 255. The {{Atari 2600}} and [[{{Atari 7800}} 7800]], NintendoEntertainmentSystem, SegaMasterSystem, and early home computers were all 8-bit.

* '''32 bits''' can hold a value as high as 4,294,967,295. The SegaSaturn and {{Dreamcast}}, Sony {{PlayStation}}, Microsoft {{XBox}} and the {{Wii}} are all 32-bit. So are desktop [=PCs=] from 1987 to 2007.

So what happens if you try to store a number bigger than that? Say you were trying to add one to a 16-bit variable that's already set to 65,535. It would "wrap" - adding one to 65,535 would give you zero. Adding two would give you one. And so on, and so forth. The same goes the other way - subtracting one from zero gives you 65,535. When this happens, it's called "carry" if expected or "overflow" if not. This is the source of many GoodBadBugs; most of them are a case of programmer oversight, since the "overflow" flag in the CPU is triggered whenever this happens. Also see {{Cap}}. Programmers can handle numbers larger than the register size, but this causes the arithmetic operations to take longer, so this is usually avoided. This is how older 8-bit systems handled numbers larger than 255.

So what happens if you try to store a number bigger than that? Say you were trying to add one to a 16-bit variable that's already set to 65,535. It would "wrap" - adding one to 65,535 would give you zero. Adding two would give you one. And so on, and so forth. The same goes the other way - subtracting one from zero gives you 65,535. When this happens, it's called "carry" if expected or "overflow" if not. This is the source of many GoodBadBugs; most of them are a case of programmer oversight, since the "overflow" flag in the CPU is triggered whenever this happens. Also see {{Cap}}.

* As a {{Cap}}. Programming for older systems is really ''really'' hard; these systems were relatively good at graphics processing, but very bad at calculations, so every CPU cycle saved was a big deal.[[hottip:*:{{Atari 2600}} was hit the hardest: it had ''no'' {{VRAM}}, so programmers had to create the picture by timely manipulation of the graphic output registers, but as it also had no interrupt lines in the {{CPU}}, this was possible only by the careful timing of the program itself and inserting graphical output commands into the correct places.]] If you cap a value to the actual limit of your variable, you can enforce the cap with a "did previous instruction overflow" test, which is usually faster than a "is X greater than Y" test (the latter often involves hidden subtraction, even on newer processors).