-atof- function , example from section 4.2 K&R2

[arnuld]

This is the example from section 4.2, page 71 of K&R2:
double atof( char s[] )
{
int i, sign;
double val, power;
for( i = 0; isspace( s[i] ); ++i )
{
/* skipe the leading whitespace */
}

sign = ( (s[i] == '-') ? -1 : 1 );

if( s[i] == '+'|| s[i] == '-' )
{
++i;
/* skip the leading sign, of any */
}

for( val = 0.0; isdigit( s[i] ); ++i )
{
val = (10.0 * val) + (s[i] - '0');

/* s[i] - '0' (zero in quotes)
* always gives "int i" as output
*/
}

if( s[i] == '.' )
{
++i;
/* skip the dot(.) of a floating point */
}

for( power = 1.0; isdigit( s[i] ); ++i )
{
val = (10.0 * val) + (s[i] - '0');
power *= 10.0;
}

return sign * val / power;
}
I can't really think of that kind of clever-tricks shown here. checking
for leading space and dot (.) are fine,they are very general things and
easily come to my mind but look at how cleverly the K&R created the
expressions like (val = 10.0 * val) and (power *= 10.0). these loops
using variables "val" and "power" are pretty much the work of people with
high IQs. After some work I can understand them but I can not create them
at very 1st place, I dont have that kind of thinking.

These tricks never came to my mind. Is this what we call programming ? if
yes, it is pretty much harder to come to my mind, may be never. I just do
not think this way.

[danzona]

On Fri, 04 Apr 2008 12:42:14 +0530, arnuld <lo*****@shooti ng.com>
wrote:

>This is the example from section 4.2, page 71 of K&R2:

<snip>

for( val = 0.0; isdigit( s[i] ); ++i )
{
val = (10.0 * val) + (s[i] - '0');

/* s[i] - '0' (zero in quotes)
* always gives "int i" as output
*/
}

<snip>

>I can't really think of that kind of clever-tricks shown here...

These tricks never came to my mind. Is this what we call programming ?

Programming is an iterative process. How many iterations you want to
make is up to you to some extent but may also be impacted by
performance or memory requirements.

I've singled out one section of the code you posted since the comment
you added shows that you see what is happening.

The purpose of this section is to determine the integer portion of the
string (after all leading white space has been skipped).

A person taking their first stab at this part of the code might write:

val = 0.0;
while(isdigit(s[i]))
{
val *= 10.0;
val += s[i] - '0';
i++;
}

Some people might stop here because the code is clear and does what it
is supposed to. However, there is a school of thought that the best
way to write maintainable code is to have the code be as tight as
possible. Code will be better understood by the next person if each
line does one straightforward thing. (This can be problematic because
code that is too tight might also be too cryptic - a good programmer
strikes the proper balance.)

This code can be easily tightened up to:
val = 0.0;
while(isdigit(s[i]))
val = val * 10.0 + s[i++] - '0';

Again, some might stop here. But look at what the code does: we have
an initialization, a test for exit, a process, and an increment. That
is the definition of the for loop. Which leads to the code in K&R.

[Richard Heathfield]

CBFalconer said:

<snip>

>
Also consider how much clearer the whole routine becomes when the
extra vertical clutter is removed:

Consider how much clutter you have left, both vertical and horizontal!

Before:

double atof(char s[]) {
int i, sign;
double val, power;

for (i = 0; isspace(s[i]); ++i) continue; /* skip whitespace */

sign = ((s[i] == '-') ? -1 : 1);
if (s[i] == '+' || s[i] == '-') ++i; /* skip any leading sign */

for (val = 0.0; isdigit(s[i]); ++i)
val = (10.0 * val) + (s[i] - '0'); /* evaluate */

if (s[i] == '.') ++i; /* skip the dot (.) of a floating point */

for (power = 1.0; isdigit(s[i]); ++i) {
val = (10.0 * val) + (s[i] - '0'); /* eval post decimal */
power *= 10.0;
}
return sign * val / power;
}

After (and tested, btw):

double atof(char*s){in t i=0,n=0;double v=0,p=
1;while(isspace (*s))++s;if(*s) {n=(*s!='-')*2-
1;(*s=='+'||*s= ='-')&&++s;while(i sdigit(*s))v
=(10.0*v)+(*s++-'0');if(*s=='.' )while(isdigit
(*++s))(v=10.*v +*s-'0'),p*=10;}ret urn n*v/p;}

(this is one of my fetishes)

Then presumably you are now doubly thrilled.

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[Dann Corbit]

"arnuld" <lo*****@shooti ng.comwrote in message
news:pa******** *************** **********@shoo ting.com...

This is the example from section 4.2, page 71 of K&R2:

[snip of tweaked exercise]

I can't really think of that kind of clever-tricks shown here. checking
for leading space and dot (.) are fine,they are very general things and
easily come to my mind but look at how cleverly the K&R created the
expressions like (val = 10.0 * val) and (power *= 10.0). these loops
using variables "val" and "power" are pretty much the work of people with
high IQs. After some work I can understand them but I can not create them
at very 1st place, I dont have that kind of thinking.

You don't have to be a genius of any sort to think of this sort of thing.
Each subsequent digit is ten times larger than the one that preceded it. We
learned that in grade school.

These tricks never came to my mind. Is this what we call programming ? if
yes, it is pretty much harder to come to my mind, may be never. I just do
not think this way.

If you should happen to write down using pencil and paper the steps you go
through to recognize the value of a number, then these same steps will work
when you make the computer do them. You are making this problem much harder
than it really is. If you put the book out of sight and write your own
version, you will find it is remarkably similar to theirs.

My answer to this exercise is on Richard Heathfield's site.

--
Posted via a free Usenet account from http://www.teranews.com

[Richard Heathfield]

Dann Corbit said:

"arnuld" <lo*****@shooti ng.comwrote in message
news:pa******** *************** **********@shoo ting.com...

>This is the example from section 4.2, page 71 of K&R2:

[snip of tweaked exercise]

>I can't really think of that kind of clever-tricks shown here. checking
for leading space and dot (.) are fine,they are very general things and
easily come to my mind but look at how cleverly the K&R created the
expressions like (val = 10.0 * val) and (power *= 10.0). these loops
using variables "val" and "power" are pretty much the work of people
with
high IQs. After some work I can understand them but I can not create
them at very 1st place, I dont have that kind of thinking.

You don't have to be a genius of any sort to think of this sort of thing.
Each subsequent digit is ten times larger than the one that preceded it.
We learned that in grade school.

>These tricks never came to my mind. Is this what we call programming ?
if yes, it is pretty much harder to come to my mind, may be never. I
just do not think this way.

If you should happen to write down using pencil and paper the steps you
go through to recognize the value of a number, then these same steps will
work
when you make the computer do them. You are making this problem much
harder
than it really is. If you put the book out of sight and write your own
version, you will find it is remarkably similar to theirs.

My answer to this exercise is on Richard Heathfield's site.

Well, it was. It's on a site that I once used, but no longer have write
access to (and haven't had for some years!). When I closed that account, I
shipped everything over to Flash Gordon's clc-wiki site, which can be
found here: http://clc-wiki.net/wiki/

Your solution is at this URL:

<http://clc-wiki.net/wiki/K%26R2_solution s%3AChapter_4%3 AExercise_2>

--
Richard Heathfield <http://www.cpax.org.uk >
Email: -http://www. +rjh@
Google users: <http://www.cpax.org.uk/prg/writings/googly.php>
"Usenet is a strange place" - dmr 29 July 1999

[CBFalconer]

da*****@excite. com wrote:

>

.... snip ...

>
This code can be easily tightened up to:
val = 0.0;
while(isdigit(s[i]))
val = val * 10.0 + s[i++] - '0';

Again, some might stop here. But look at what the code does:
we have an initialization, a test for exit, a process, and an
increment. That is the definition of the for loop. Which leads
to the code in K&R.

And that tightening can lead to an error. The term "s[i++] - '0'"
should be firmly wrapped in a set of parenthesis. Otherwise errors
can occur when the magnitude of val suddenly exceeds a magic
threshold, and the subtraction of '0' does not work correctly.

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home .att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[Joachim Schmitz]

Richard Heathfield wrote:

CBFalconer said:

<snip>

>>
Also consider how much clearer the whole routine becomes when the
extra vertical clutter is removed:

Consider how much clutter you have left, both vertical and horizontal!

Before:

>double atof(char s[]) {
int i, sign;
double val, power;

for (i = 0; isspace(s[i]); ++i) continue; /* skip whitespace */

sign = ((s[i] == '-') ? -1 : 1);
if (s[i] == '+' || s[i] == '-') ++i; /* skip any leading sign */

for (val = 0.0; isdigit(s[i]); ++i)
val = (10.0 * val) + (s[i] - '0'); /* evaluate */

if (s[i] == '.') ++i; /* skip the dot (.) of a floating point */

for (power = 1.0; isdigit(s[i]); ++i) {
val = (10.0 * val) + (s[i] - '0'); /* eval post decimal */
power *= 10.0;
}
return sign * val / power;
}

After (and tested, btw):

double atof(char*s){in t i=0,n=0;double v=0,p=
1;while(isspace (*s))++s;if(*s) {n=(*s!='-')*2-
1;(*s=='+'||*s= ='-')&&++s;while(i sdigit(*s))v
=(10.0*v)+(*s++-'0');if(*s=='.' )while(isdigit
(*++s))(v=10.*v +*s-'0'),p*=10;}ret urn n*v/p;}

>(this is one of my fetishes)

Then presumably you are now doubly thrilled.

Well, Chuck's version is more readable than your _and_ more readable that
the OP's

Bye, Jojo