[Solved] Why Do Computer Counts from Zero.
-
Link to the article For More detail explanation(PDF) Counting arrays from 0 simplifies the computation of the memory address of each element. If an array is stored at a given position in memory (it’s called the address) the position of each element can be computed as
element(n) = address + n * size_of_the_element
//If you consider the first element the first, the computation becomeselement(n) = address + (n-1) * size_of_the_element
//Not a huge difference but it adds an unnecessary subtraction for each access. -
Link to the article For More detail explanation(PDF) Counting arrays from 0 simplifies the computation of the memory address of each element. If an array is stored at a given position in memory (it’s called the address) the position of each element can be computed as
element(n) = address + n * size_of_the_element
//If you consider the first element the first, the computation becomeselement(n) = address + (n-1) * size_of_the_element
//Not a huge difference but it adds an unnecessary subtraction for each access.kburman6 wrote:
Not a huge difference but it adds an unnecessary subtraction for each access.
And because unnecessary calcs are slowing down the computers' speed it was just logical to do it as simple as possible. Developer's course at my school, lesson 1 (or two, however; It was at the very beginning when they explained it to us).
cheers Marco Bertschi
Software Developer Twitter | Facebook | Articles
You have absolutely no idea how glad I am that I have no idea at all. - OriginalGriff
-
kburman6 wrote:
Not a huge difference but it adds an unnecessary subtraction for each access.
And because unnecessary calcs are slowing down the computers' speed it was just logical to do it as simple as possible. Developer's course at my school, lesson 1 (or two, however; It was at the very beginning when they explained it to us).
cheers Marco Bertschi
Software Developer Twitter | Facebook | Articles
You have absolutely no idea how glad I am that I have no idea at all. - OriginalGriff
Marco Bertschi wrote:
lesson 1 0
FTFY!
The quick red ProgramFOX jumps right over the
Lazy<Dog>. My latest article: Understand how bitwise operators work (C# and VB.NET examples) My group: C# Programmers Group -
kburman6 wrote:
Not a huge difference but it adds an unnecessary subtraction for each access.
And because unnecessary calcs are slowing down the computers' speed it was just logical to do it as simple as possible. Developer's course at my school, lesson 1 (or two, however; It was at the very beginning when they explained it to us).
cheers Marco Bertschi
Software Developer Twitter | Facebook | Articles
You have absolutely no idea how glad I am that I have no idea at all. - OriginalGriff
But for lesser mortals like me, who did Mechanical engineering and still ended up here, this is news. Besides, the first book I ever read about computers was to learn C++ programming. At that time, I had no clue that the black screen where I type code is console. I had to literally ask someone to open that black screen for me so I can code. I was probably wrong with my approach but I am still better than lots of those urgentzz codezz plzzz types I guess.
"Bastards encourage idiots to use Oracle Forms, Web Forms, Access and a number of other dinky web publishing tolls.", Mycroft Holmes[^]
-
kburman6 wrote:
Not a huge difference but it adds an unnecessary subtraction for each access.
And because unnecessary calcs are slowing down the computers' speed it was just logical to do it as simple as possible. Developer's course at my school, lesson 1 (or two, however; It was at the very beginning when they explained it to us).
cheers Marco Bertschi
Software Developer Twitter | Facebook | Articles
You have absolutely no idea how glad I am that I have no idea at all. - OriginalGriff
-
But for lesser mortals like me, who did Mechanical engineering and still ended up here, this is news. Besides, the first book I ever read about computers was to learn C++ programming. At that time, I had no clue that the black screen where I type code is console. I had to literally ask someone to open that black screen for me so I can code. I was probably wrong with my approach but I am still better than lots of those urgentzz codezz plzzz types I guess.
"Bastards encourage idiots to use Oracle Forms, Web Forms, Access and a number of other dinky web publishing tolls.", Mycroft Holmes[^]
From you article Adding Post-commit Hook to SVN Source Control It seems like you are much better than other. :laugh:
-
But for lesser mortals like me, who did Mechanical engineering and still ended up here, this is news. Besides, the first book I ever read about computers was to learn C++ programming. At that time, I had no clue that the black screen where I type code is console. I had to literally ask someone to open that black screen for me so I can code. I was probably wrong with my approach but I am still better than lots of those urgentzz codezz plzzz types I guess.
"Bastards encourage idiots to use Oracle Forms, Web Forms, Access and a number of other dinky web publishing tolls.", Mycroft Holmes[^]
d@nish wrote:
I was probably wrong with my approach but I am still better than lots of those urgentzz codezz plzzz types I guess.
You learnt coding, diddn't you? From that point of view your approach wasn't that wrong :-D . Furthermore I understand if this is news for auto-didacts. And I am not surprised if anyone says that this is news for him, had to recall it myself first too.
cheers Marco Bertschi
Software Developer Twitter | Facebook | Articles
You have absolutely no idea how glad I am that I have no idea at all. - OriginalGriff
-
Exactly. And everything which is pointless leads to time-consume which is to be avoided.
cheers Marco Bertschi
Software Developer Twitter | Facebook | Articles
You have absolutely no idea how glad I am that I have no idea at all. - OriginalGriff
-
Exactly. And everything which is pointless leads to time-consume which is to be avoided.
cheers Marco Bertschi
Software Developer Twitter | Facebook | Articles
You have absolutely no idea how glad I am that I have no idea at all. - OriginalGriff
-
Oh yes. Little tiny wasted instructions add up fast when you do them as often as array accesses. And remember, when this was decided, even HUGE computers ran at much, much, lower speeds - an IBM 360/195 could execute 16,000,000 instructions per second (at best), compared to the around 6,000,000,000 that your PC is (probably) capable of executing - it's difficult to be sure, due to multiple cores, pipelines, and caches, all of which were a lot smaller or nonexistent in those days. And remember, a 360/195 cost about £3,000,000 back in 1982, when beer was £0.30 per pint...so you didn't want to waste anything! :laugh:
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Link to the article For More detail explanation(PDF) Counting arrays from 0 simplifies the computation of the memory address of each element. If an array is stored at a given position in memory (it’s called the address) the position of each element can be computed as
element(n) = address + n * size_of_the_element
//If you consider the first element the first, the computation becomeselement(n) = address + (n-1) * size_of_the_element
//Not a huge difference but it adds an unnecessary subtraction for each access.That may have made sense in the 1960's, but not really anymore. A simple addition and possibly a shift takes very time relative to all the other processing happening in a computer.
-
Link to the article For More detail explanation(PDF) Counting arrays from 0 simplifies the computation of the memory address of each element. If an array is stored at a given position in memory (it’s called the address) the position of each element can be computed as
element(n) = address + n * size_of_the_element
//If you consider the first element the first, the computation becomeselement(n) = address + (n-1) * size_of_the_element
//Not a huge difference but it adds an unnecessary subtraction for each access.I thought it was to save electrons.:~
“Education is not the piling on of learning, information, data, facts, skills, or abilities - that's training or instruction - but is rather making visible what is hidden as a seed”
“One of the greatest problems of our time is that many are schooled but few are educated”Sir Thomas More (1478 – 1535)
-
I thought it was to save electrons.:~
“Education is not the piling on of learning, information, data, facts, skills, or abilities - that's training or instruction - but is rather making visible what is hidden as a seed”
“One of the greatest problems of our time is that many are schooled but few are educated”Sir Thomas More (1478 – 1535)
-
Link to the article For More detail explanation(PDF) Counting arrays from 0 simplifies the computation of the memory address of each element. If an array is stored at a given position in memory (it’s called the address) the position of each element can be computed as
element(n) = address + n * size_of_the_element
//If you consider the first element the first, the computation becomeselement(n) = address + (n-1) * size_of_the_element
//Not a huge difference but it adds an unnecessary subtraction for each access.Actually, it doesn't simplify the calculation of the address. It just aids the ability to interchangeably address the whole array and the address of its first element (e.g. in C,
&arrayand&array[0]both give the same address). In languages like FORTRAN (from 1957 to current day) which start indices from 1, the formula iselement(n) = (address_of_array - size_of_the_element) + n * size_of_the_element
which is just as simple as starting from 0 as
(address_of_array - size_of_the_element)is a compile time constant value. Considering the millions of errors over the decades that starting from zero has perpetuated (e.g. forgetting to add one to the bounds when declaring the array or getting the end point wrong in loops or wasting space by deliberately skipping element 0), doing the compile time calculation would have been a small price to pay. -
Oh yes. Little tiny wasted instructions add up fast when you do them as often as array accesses. And remember, when this was decided, even HUGE computers ran at much, much, lower speeds - an IBM 360/195 could execute 16,000,000 instructions per second (at best), compared to the around 6,000,000,000 that your PC is (probably) capable of executing - it's difficult to be sure, due to multiple cores, pipelines, and caches, all of which were a lot smaller or nonexistent in those days. And remember, a 360/195 cost about £3,000,000 back in 1982, when beer was £0.30 per pint...so you didn't want to waste anything! :laugh:
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
-
Actually, it doesn't simplify the calculation of the address. It just aids the ability to interchangeably address the whole array and the address of its first element (e.g. in C,
&arrayand&array[0]both give the same address). In languages like FORTRAN (from 1957 to current day) which start indices from 1, the formula iselement(n) = (address_of_array - size_of_the_element) + n * size_of_the_element
which is just as simple as starting from 0 as
(address_of_array - size_of_the_element)is a compile time constant value. Considering the millions of errors over the decades that starting from zero has perpetuated (e.g. forgetting to add one to the bounds when declaring the array or getting the end point wrong in loops or wasting space by deliberately skipping element 0), doing the compile time calculation would have been a small price to pay.jsc42 wrote:
element(n) = (address_of_array - size_of_the_element) + n * size_of_the_element
which is just as simple as starting from 0 as
(address_of_array - size_of_the_element)is a compile time constant value.(address_of_array - size_of_the_element) is not a compile time constant value in any but the simplest of cases, i.e. where the array is at a fixed memory location every time the program is run, which is almost never.
-
That may have made sense in the 1960's, but not really anymore. A simple addition and possibly a shift takes very time relative to all the other processing happening in a computer.
You don't know what else the computer is doing so don't assume that there are plenty of cycles. If every app wastes 10% of the "extra" cycles it doesn't take long to bog the whole thing down.
-
Oh yes. Little tiny wasted instructions add up fast when you do them as often as array accesses. And remember, when this was decided, even HUGE computers ran at much, much, lower speeds - an IBM 360/195 could execute 16,000,000 instructions per second (at best), compared to the around 6,000,000,000 that your PC is (probably) capable of executing - it's difficult to be sure, due to multiple cores, pipelines, and caches, all of which were a lot smaller or nonexistent in those days. And remember, a 360/195 cost about £3,000,000 back in 1982, when beer was £0.30 per pint...so you didn't want to waste anything! :laugh:
The universe is composed of electrons, neutrons, protons and......morons. (ThePhantomUpvoter)
OriginalGriff wrote:
wasted instructions add up fast
Which is why I detest animated widgets. X|
-
jsc42 wrote:
element(n) = (address_of_array - size_of_the_element) + n * size_of_the_element
which is just as simple as starting from 0 as
(address_of_array - size_of_the_element)is a compile time constant value.(address_of_array - size_of_the_element) is not a compile time constant value in any but the simplest of cases, i.e. where the array is at a fixed memory location every time the program is run, which is almost never.
You are correct! What I meant (and I admit that the language that I used was far from rigorous) was that the relative offset is unvarying. If, for example, the offset of the start of the memory allocated for the array is 100 from a location (relative addressing / stack frame relative / absolute / whatever) and each element takes up 4 address locations (e.g. bytes), then all that the compiler does for 1-based indices is to use 96 + n * 4 (because 100 - 4 = 96) instead of 100 +(n - 1) * 4 in all of its address calculations for the array; this is as simple as using 100 + n * 4 for 0-based indices. This can be extended for arrays with specifiable lower bounds e.g. in this example if lwb is the lower bound, the 0-based index offset would be 100 + (n - lwb) * 4 [or more optimally (100 - lwb * 4) + n * 4] or for 1-based index offset would be (100 - (lwb + 1) * 4) + n * 4 = (96 - lwb * 4) + n * 4.
-
Link to the article For More detail explanation(PDF) Counting arrays from 0 simplifies the computation of the memory address of each element. If an array is stored at a given position in memory (it’s called the address) the position of each element can be computed as
element(n) = address + n * size_of_the_element
//If you consider the first element the first, the computation becomeselement(n) = address + (n-1) * size_of_the_element
//Not a huge difference but it adds an unnecessary subtraction for each access.
