Information Representation - Revision history

Rice: /* Byte and Endianess */

2024-05-22T15:15:41Z

Byte and Endianess

← Older revision		Revision as of 15:15, 22 May 2024
Line 9:		Line 9:

	== Byte and Endianess ==		== Byte and Endianess ==
	Most modern day computers are ~~'''~~byte-addressable~~'''~~. The byte is the lowest unit of data that has an address and can be accessed at once.		Most modern day computers are [[byte-addressable memory]]. The byte is the lowest unit of data that has an address and can be accessed at once.

	Since we are storing multiple bytes of a word across memory, the order in which we store them, '''endianess''', needs to be specified.		Since we are storing multiple bytes of a word across memory, the order in which we store them, '''endianess''', needs to be specified.

Rice: /* Signed Integers */

2024-05-09T19:45:00Z

Signed Integers

← Older revision		Revision as of 19:45, 9 May 2024
Line 26:		Line 26:
	The first method to represent signed integers with bits is '''signed magnitude'''. Under this system, the first bit (''sign bit'') is used as a negative sign; If it is 0, then the number is positive, otherwise it is negative.		The first method to represent signed integers with bits is '''signed magnitude'''. Under this system, the first bit (''sign bit'') is used as a negative sign; If it is 0, then the number is positive, otherwise it is negative.

	The second method is ~~called '''2's complement''', and it is more widely used due to several advantages covered later.~~		The second method is [[two's complement]].

	~~In this system, think of the first bit in the bit pattern as negative. For example, 101 would be 4 + 1 = 5 as an unsigned number, but -4 + 1 = -3 as a signed number represented by 2's complement.~~

	~~The advantage of using 2~~'s complement ~~over signed magnitude is twofold:~~

	* Normal binary arithmetic can be applied.
	* There is no negative zero

	~~To negate signed numbers, flip all bits and add 1~~. ~~This comes from math: <math>-2 = -4 + ((4 - 1) - 2) + 1</math>~~

	= Floating Point =		= Floating Point =

Admin: /* Arrays */

2024-04-02T22:09:39Z

Arrays

← Older revision		Revision as of 22:09, 2 April 2024
Line 55:		Line 55:
	</sh>		</sh>

	Notably, this is also a major reason why array indices start at 0.		Notably, this is also a major reason why array indices start at 0 in most programming languages.

			= Struct =
			A '''struct''' boils down to an array that can have different types of values, each taking up different sizes.

	[[Category:Computer Architecture]]		[[Category:Computer Architecture]]

Admin: /* Arrays */

2024-04-02T22:06:59Z

Arrays

← Older revision		Revision as of 22:06, 2 April 2024
Line 49:		Line 49:
	The simplest structured group of values is an '''array''', in which multiple values of the same type is stored consecutively in a block of memory. We then keep track of the address of the first element in the array and the size of each element so that we can find the n-th element easily.		The simplest structured group of values is an '''array''', in which multiple values of the same type is stored consecutively in a block of memory. We then keep track of the address of the first element in the array and the size of each element so that we can find the n-th element easily.

	For example, consider an array of 10 32-bit integers ''arr''. To access the 6th element, I ~~take~~ the address		For example, consider an array of 10 32-bit integers <c>arr</c>. To access the 6th element, I can simply move 5 integer sizes after the first element to get the address I want:

			<sh>
			(&arr + 5sizeof(int))
			</sh>

			Notably, this is also a major reason why array indices start at 0.

	[[Category:Computer Architecture]]		[[Category:Computer Architecture]]

Admin: /* Floating Point */

2024-04-02T21:59:27Z

Floating Point

← Older revision		Revision as of 21:59, 2 April 2024
Line 50:		Line 50:

	For example, consider an array of 10 32-bit integers ''arr''. To access the 6th element, I take the address		For example, consider an array of 10 32-bit integers ''arr''. To access the 6th element, I take the address

	[[Category:Computer Architecture]]		[[Category:Computer Architecture]]

Admin: /* Arrays */

2024-04-02T21:45:34Z

Arrays

← Older revision		Revision as of 21:45, 2 April 2024
Line 47:		Line 47:

	= Arrays =		= Arrays =
			The simplest structured group of values is an '''array''', in which multiple values of the same type is stored consecutively in a block of memory. We then keep track of the address of the first element in the array and the size of each element so that we can find the n-th element easily.

			For example, consider an array of 10 32-bit integers ''arr''. To access the 6th element, I take the address
	[[Category:Computer Architecture]]		[[Category:Computer Architecture]]

Admin: /* Byte and Endianess */

2024-04-02T21:38:34Z

Byte and Endianess

← Older revision		Revision as of 21:38, 2 April 2024
Line 36:		Line 36:

	To negate signed numbers, flip all bits and add 1. This comes from math: <math>-2 = -4 + ((4 - 1) - 2) + 1</math>		To negate signed numbers, flip all bits and add 1. This comes from math: <math>-2 = -4 + ((4 - 1) - 2) + 1</math>

			= Floating Point =
			To store decimal values, the '''floating point''' representation is used. Similar to scientific notation, it uses a series of bits called the '''mantissa''' to store significant binary digits, and another series of bits called the '''exponent''' to store the order of magnitude of the number. The final calculation is something like

			<math>1.m\times2^{e}</math>

			To handle negative numbers, the first bit is used as a sign bit.

			To handle negative exponents, all exponents are subtracted by a constant to center the range of exponents on 0. For example, when 8 bits is used to represent the exponent (as is usually the case), the range of possible values is 0 to 255, so 127 is subtracted from the exponent so that the actual range is -127 to 128.

	= Arrays =		= Arrays =
	[[Category:Computer Architecture]]		[[Category:Computer Architecture]]

Admin: /* Signed Integers */

2024-04-02T21:32:02Z

Signed Integers

@@ Line 1: / Line 1: @@
 Inside a computer, everything is bits. The topic of '''information representation''' discusses how different information inside a computer program actually looks like in the background.
 = Signed Integers =
@@ Line 16: / Line 36: @@
 To negate signed numbers, flip all bits and add 1. This comes from math: <math>-2 = -4 + ((4 - 1) - 2) + 1</math>
 [[Category:Computer Architecture]]

Admin at 20:33, 2 April 2024

2024-04-02T20:33:06Z

← Older revision		Revision as of 20:33, 2 April 2024
Line 1:		Line 1:
	Inside a computer, everything is bits. The topic of '''information representation''' discusses how different information inside a computer program actually looks like in the background.		Inside a computer, everything is bits. The topic of '''information representation''' discusses how different information inside a computer program actually looks like in the background.

	~~'''2's complement''' is~~ a ~~method~~ of ~~representing integers in computer science~~.		= Signed Integers =
			While a series of bits naturally represent a binary number, negative numbers are a bit more complicated.

	~~To calculate the value of a number represented by 2~~'~~s complement~~, ~~just think of~~ the first bit ~~in the~~ bit ~~pattern~~ as negative~~. For example~~, ~~101 would be 4 + 1 = 5 as an unsigned~~ number, ~~but -4 + 1 = -3 as a signed number represented by 2's complement~~.		The first method to represent signed integers with bits is '''signed magnitude'''. Under this system, the first bit (''sign bit'') is used as a negative sign; If it is 0, then the number is positive, otherwise it is negative.

	The ~~advantage of using~~ 2's complement ~~over signed magnitude~~ is ~~twofold:~~		The second method is called '''2's complement''', and it is more widely used due to several advantages covered later.

	* Easier arithmetic operations		In this system, think of the first bit in the bit pattern as negative. For example, 101 would be 4 + 1 = 5 as an unsigned number, but -4 + 1 = -3 as a signed number represented by 2's complement.
	* Greater range of ~~values (since there is no~~ -0)

			The advantage of using 2's complement over signed magnitude is twofold:

	* ~~To '''negate''' signed numbers, flip all bits and add 1~~. ~~This comes from math: <math>-2 = -4 + ((4 - 1) - 2) + 1</math>~~		* Normal binary arithmetic can be applied.
			* There is no negative zero

			To negate signed numbers, flip all bits and add 1. This comes from math: <math>-2 = -4 + ((4 - 1) - 2) + 1</math>
	[[Category:Computer Architecture]]		[[Category:Computer Architecture]]

Admin at 20:23, 2 April 2024

2024-04-02T20:23:24Z

← Older revision		Revision as of 20:23, 2 April 2024
Line 1:		Line 1:
	Inside a computer, everything is bits. The topic of '''information representation''' discusses how different information inside a computer program actually looks like in the background.		Inside a computer, everything is bits. The topic of '''information representation''' discusses how different information inside a computer program actually looks like in the background.

			'''2's complement''' is a method of representing integers in computer science.

			To calculate the value of a number represented by 2's complement, just think of the first bit in the bit pattern as negative. For example, 101 would be 4 + 1 = 5 as an unsigned number, but -4 + 1 = -3 as a signed number represented by 2's complement.

			The advantage of using 2's complement over signed magnitude is twofold:

			* Easier arithmetic operations
			* Greater range of values (since there is no -0)


			* To '''negate''' signed numbers, flip all bits and add 1. This comes from math: <math>-2 = -4 + ((4 - 1) - 2) + 1</math>

	[[Category:Computer Architecture]]		[[Category:Computer Architecture]]