Kids can do math better than x86 cpu's.

[Skybuck]

Especially a problem with 260 and a 290 digits. 75,400 single digit
multiplies. At one every two seconds (time for the multiply plus
some time for the carry), that's 42 hours straight and that's not
counting the adds. Good luck getting a kid in today's video game
generation to do any task that takes more than ten minutes.
The odds of there being no mistakes is vanishingly small. I'd say the
odds of absolute peace in the middle east for the next two centuries
is higher.

By the way, the answer is:
875279949449928687171082381195645449709812282235188534611991220487369\
750660866053304942879984231537943067897694712601511924963938379101922\
647017996467693753500201567049250263137918035932076754718727578460674\
626632963053682953542462596305825701489258055255205143723480139275624\
009749763785363546996951941944685372601254940771920912104622418969407\
723724820905001415363123084056285866891887451657302837214191356534169\
032664600101693678003589068377972327249782374353699650791261530178195\
228611902447640024153616963547499862263386141535774330150101189965

My intel compatible processor had no problem at all. I didn't even have
to install any new tools on my linux box. The lowly 'dc' desk calculator
app did it just fine.- Hide quoted text -

Very nice,

Now let's see if your software can multiply the following large
number:

"
DHDFHDFHGDFH#$%^&#^$^#^$&^&(&*)&*()&*_*)(+_(+*()_&*)(O%^&@#
$TWERTWERTETYTIYTOUYPUIPYULHKLK"LOP{P|
{}OIP{PUIOIRTYJKGHJLGHKHLUY:IO:UI"&O(&*(&*(&#^@$^%@%!#$!!%#$^
%@YRYWTEQTWWEYYTITYTIPGHKJGHLHGJLFSDASGZBZXBZXBVMBN<KHKGHKYTIRTUDFWEVT
$YB@$%B^#$&%N$N*%*M(WAWCQCWEHSRY#$^@%
$^&&3546b346bv546bv2mn348sdyb789s6g96q01987509176-8176=2624765987werhguietuiower78t78346634yERDFNCVMBBMVB<>M<?
MNRTU$*&*(^&)^&)(#^@$^@&%
$^*^JDjhebykljhrigouhsdiuhghivohw4ntvwv4ynb6y72768yn4tdyfofhgojbh8ohg897q1y91t78953478538049y-7btbhvsiouhgsbungauyb3nguib*(_*(+*|
PO|
POwepuyweuiytiouweyitouweyiotweuirtwerty7834673748096780934ytwuebDFHNFTUMY^&<LIOP>LKMTHHBv2u6280977880917580923746809759hywhyertyb,sdgDFJGHJ^R&I
%^(%U#Y@Q%Y#^%&*^&(YTwewRYEBRUNTUBW#^@#$^%$&#$&#@$%@!%!^$&(UBEBERNJ$$
%^*
"

*

"HE&$%^*^%&*(@^1254178265897236480937409yweHERUNTUIMIMOO>{"?P{"}P|{|
P{}|P{}RUYTURTUYRTUYRTUWTQWETWRTUOUPO&*3896734802589754234%$&^&(*(_()
+@#%!
wertyquioytqwuioytuioqweytuioeripoyuporturtu[\rt[ywtqiouqweipougsjkldhgjklshjkglahsdklghxcnxbnmsdrilweh78o2489623784962897359817809175378496092&&
$&*^&(&*()&!@$!@%WERWERYRTYUTYIUIP}|}|
ERSDFASDGsdfasdjklhggasfjkgasdgasjkgasdjhgasdasdfFADFASFASDFKGHLHJLDFE
$RY&%$^*^%*&*)*)+_)^&%$^@#%!@#%!%@@#$^&^*^
%ERHUTRTIURTHSAASDFFAASDFASDFASDFASDFSDGSDHGDFJKJ&%$*^%&*%^&(^&*)()*_%
$&@#%!
@5123745238468912368596189ytuwerguyhbhxdhntwej5n6246778496872368796586&
%$*%^*^&*^%&*@!@#$!@#%*(&*()TOPP{|
IUERTWEGSDHDFHSDGASDghbvuvu24t3n84567ybn87yt78bgw76t67178652896570934sdjfghjsdfgvCNCVMNCVMBDERU&3628378263965238746578126781527534^
$%&*^&()*(&_*)+(*&#@$#!qruioytuyqweuitoqwyiouytuioytup\o\y[o]\ty]opy
\usd'flkjhs;lkjg;ljsdgklshdklhgsdhgsd;g;sdj;hgjsd;fh;sdk;fhsw34623684928768wutqguiqywuio128097587230952346#
$&#$&%$WERHERYTTNGMB<NB?CX?>X?B<C?
VB<XCVN>mvsjldhgjlkhgklajshiuoweritouweyirytwi8127365623689567346-547865&(^&_(*)
(UIO{P{|TWERHDGHe5
"
Ignoring the "" signs.

These two texts represent one large decimal number. Each ASCII
character fills one byte.

Can you multiple these two large numbers together and show me the
large decimal result ?

Bye,
Skybuck.

 

[Skybuck]

Kids don't do math with multipliers.

Kids do math with lookup table for the digits (last digit is X=10)

Usually called math tables I guess:

1*1 = 1
1*2 = 2
1*3 = 3
1*4 = 4
1*5 = 5
1*6 = 6
1*7 = 7
1*8 = 8
1*9 = 9
1*X = 10

2*1 = 1
2*2 = 3
2*3 = 6
2*4 = 8
2*5 = 10
2*6 = 12
2*7 = 14
2*8 = 16
2*9 = 18
2*X = 20

3*1 = 3
3*2 = 6
3*3 = 9
3*4 = 12
3*5 = 15
3*6 = 18
3*7 = 21
3*8 = 24
3*9 = 27
3*X = 30

4*1 = 4
4*2 = 8
4*3 = 12
4*4 = 16
4*5 = 20
4*6 = 24
4*7 = 28
4*8 = 32
4*9 = 36
4*X = 40

5*1 = 5
5*2 = 10
5*3 = 15
5*4 = 20
5*5 = 25
5*6 = 30
5*7 = 35
5*8 = 40
5*9 = 45
5*X = 50

6*1 = 6
6*2 = 12
6*3 = 18
6*4 = 24
6*5 = 30
6*6 = 36
6*7 = 42
6*8 = 48
6*9 = 54
6*X = 60

7*1 = 7
7*2 = 14
7*3 = 21
7*4 = 28
7*5 = 35
7*6 = 42
7*7 = 49
7*8 = 56
7*9 = 63
7*X = 70

8*1 = 8
8*2 = 16
8*3 = 24
8*4 = 32
8*5 = 40
8*6 = 48
8*7 = 56
8*8 = 64
8*9 = 72
8*X = 80

9*1 = 9
9*2 = 18
9*3 = 27
9*4 = 36
9*5 = 45
9*6 = 54
9*7 = 63
9*8 = 72
9*9 = 81
9*X = 90

X*1 = 10
X*2 = 20
X*3 = 30
X*4 = 40
X*5 = 50
X*6 = 60
X*7 = 70
X*8 = 80
X*9 = 90
X*X = X0

That should do it

Try coming up with an algorithm that uses math tables only

That's what cpu does:

Math tables:

0 * 0 = 0
1 * 0 = 1
0 * 1 = 1
1 * 1 = 1 (and carry ?? <- digit missing should have been X ? )

Bye,
Skybuck.

 

[Ken Smith]

what if x,y,and z, are 100 to 200 times wider than the widest register?

The person writing the program codes a loop to do it. If the contents of
the loop are doing a common thing like a multiword add, the compiler will
have a optimized code fragment to do the job. Depending on the options
specified for the compile, the loop may get unrolled.

 

[krw]

Kids don't do math with multipliers.

Kids do math with lookup table for the digits (last digit is X=10)

Usually called math tables I guess:

You're missing the 0* table.

1*1 = 1
1*2 = 2
1*3 = 3
1*4 = 4
1*5 = 5
1*6 = 6
1*7 = 7
1*8 = 8
1*9 = 9

You're missing 0*1.

1*X = 10

Whatever this means...

X*1 = 10
X*2 = 20
X*3 = 30
X*4 = 40
X*5 = 50
X*6 = 60
X*7 = 70
X*8 = 80
X*9 = 90
X*X = X0

Whatever this means...

That should do it

Except you didn't do it.

Try coming up with an algorithm that uses math tables only

Easy, table lookup with a few obvious rules. You do know that not
all computers ever made had an add instruction. The IBM 1620 didn't
have an add instruction, rather used lookup tables, just as a child
does.

That's what cpu does:

Easy enough.

Math tables:

0 * 0 = 0
1 * 0 = 1

One times zero is 1?

0 * 1 = 1

Zero times one is 1?

1 * 1 = 1 (and carry ?? <- digit missing should have been X ? )

One times one is three? Your math is sure strange sky!

 

[krw]

Very nice,

Now let's see if your software can multiply the following large
number:

Define your number.

 

[[email protected]]

Especially a problem with 260 and a 290 digits. 75,400 single digit
multiplies. At one every two seconds (time for the multiply plus
some time for the carry), that's 42 hours straight and that's not
counting the adds. Good luck getting a kid in today's video game
generation to do any task that takes more than ten minutes.
The odds of there being no mistakes is vanishingly small. I'd say the
odds of absolute peace in the middle east for the next two centuries
is higher.

By the way, the answer is:
875279949449928687171082381195645449709812282235188534611991220487369\
750660866053304942879984231537943067897694712601511924963938379101922\
647017996467693753500201567049250263137918035932076754718727578460674\
626632963053682953542462596305825701489258055255205143723480139275624\
009749763785363546996951941944685372601254940771920912104622418969407\
723724820905001415363123084056285866891887451657302837214191356534169\
032664600101693678003589068377972327249782374353699650791261530178195\
228611902447640024153616963547499862263386141535774330150101189965

My intel compatible processor had no problem at all. I didn't even have
to install any new tools on my linux box. The lowly 'dc' desk calculator
app did it just fine.

Very nice,

Now let's see if your software can multiply the following large
number:

"
DHDFHDFHGDFH#$%^&#^$^#^$&^&(&*)&*()&*_*)(+_(+*()_&*)(O%^&@#
$TWERTWERTETYTIYTOUYPUIPYULHKLK"LOP{P|
{}OIP{PUIOIRTYJKGHJLGHKHLUY:IO:UI"&O(&*(&*(&#^@$^%@%!#$!!%#$^
%@YRYWTEQTWWEYYTITYTIPGHKJGHLHGJLFSDASGZBZXBZXBVMBN<KHKGHKYTIRTUDFWEVT
$YB@$%B^#$&%N$N*%*M(WAWCQCWEHSRY#$^@%
$^&&3546b346bv546bv2mn348sdyb789s6g96q01987509176-8176=2624765987werhguietuiower78t78346634yERDFNCVMBBMVB<>M<?
MNRTU$*&*(^&)^&)(#^@$^@&%
$^*^JDjhebykljhrigouhsdiuhghivohw4ntvwv4ynb6y72768yn4tdyfofhgojbh8ohg897q1y91t78953478538049y-7btbhvsiouhgsbungauyb3nguib*(_*(+*|
PO|
POwepuyweuiytiouweyitouweyiotweuirtwerty7834673748096780934ytwuebDFHNFTUMY^&<LIOP>LKMTHHBv2u6280977880917580923746809759hywhyertyb,sdgDFJGHJ^R&I
%^(%U#Y@Q%Y#^%&*^&(YTwewRYEBRUNTUBW#^@#$^%$&#$&#@$%@!%!^$&(UBEBERNJ$$
%^*
"

*

"HE&$%^*^%&*(@^1254178265897236480937409yweHERUNTUIMIMOO>{"?P{"}P|{|
P{}|P{}RUYTURTUYRTUYRTUWTQWETWRTUOUPO&*3896734802589754234%$&^&(*(_()
+@#%!
wertyquioytqwuioytuioqweytuioeripoyuporturtu[\rt[ywtqiouqweipougsjkldhgjklshjkglahsdklghxcnxbnmsdrilweh78o2489623784962897359817809175378496092&&
$&*^&(&*()&!@$!@%WERWERYRTYUTYIUIP}|}|
ERSDFASDGsdfasdjklhggasfjkgasdgasjkgasdjhgasdasdfFADFASFASDFKGHLHJLDFE
$RY&%$^*^%*&*)*)+_)^&%$^@#%!@#%!%@@#$^&^*^
%ERHUTRTIURTHSAASDFFAASDFASDFASDFASDFSDGSDHGDFJKJ&%$*^%&*%^&(^&*)()*_%
$&@#%!
@5123745238468912368596189ytuwerguyhbhxdhntwej5n6246778496872368796586&
%$*%^*^&*^%&*@!@#$!@#%*(&*()TOPP{|
IUERTWEGSDHDFHSDGASDghbvuvu24t3n84567ybn87yt78bgw76t67178652896570934sdjfghjsdfgvCNCVMNCVMBDERU&3628378263965238746578126781527534^
$%&*^&()*(&_*)+(*&#@$#!qruioytuyqweuitoqwyiouytuioytup\o\y[o]\ty]opy
\usd'flkjhs;lkjg;ljsdgklshdklhgsdhgsd;g;sdj;hgjsd;fh;sdk;fhsw34623684928768wutqguiqywuio128097587230952346#
$&#$&%$WERHERYTTNGMB<NB?CX?>X?B<C?
VB<XCVN>mvsjldhgjlkhgklajshiuoweritouweyirytwi8127365623689567346-547865&(^&_(*)
(UIO{P{|TWERHDGHe5
"
Ignoring the "" signs.

These two texts represent one large decimal number. Each ASCII
character fills one byte.

Can you multiple these two large numbers together and show me the
large decimal result ?

Bye,
Skybuck.

Yes, almost certainly, since the problem
is fundamentally the same as your previous
one, only this time, the numbers are
represented using base 128 numerals (or
maybe base 256 numerals depending on
whether or not you've encoded the numbers
using 7-bit or 8-bit ASCII) rather than
base 10 numerals.
Therefore, at worse, all that has to be
done is to tell the software how to
perform such a base conversion between
the representation you've chosen and the
one that it normally expects.

However, it seems reasonable to ask why
anyone would want to bother doing such
a thing.
What would it show to you that hasn't
already been shown?
What do you think it shows others that
hasn't already been shown?
Can *YOU* even check the result of the
calculation without resorting to a
computer?
And if you can't, aren't you basically
showing that your argument is at the
least very, very weak?
I know of very few adults let alone
kids who know how to deal with numbers
represented in bases other than 10 so
ISTM that your latest example does
nothing to support what you wrote in
your OP or anything else you've written
lately concerning the "need" for big
number hardware.

 

[Terje Mathisen]

Try coming up with an algorithm that uses math tables only

That's what cpu does:

Math tables:

0 * 0 = 0
1 * 0 = 1
0 * 1 = 1
1 * 1 = 1 (and carry ?? <- digit missing should have been X ? )

Let's save that table and quote it each time Mr Sky tries to start
another stupid thread.

That should be easier than trying to correct him each and every time he
makes a mistake.

Terje

 

[AZ Nomad]

Define your number.

Good question. It looks to me like skybuck hasn't been limiting his
usenet sessions to times when he isn't stinking drunk.

Multiplying numbers in any base isn't a big deal to anybody older than about
seven or for any CPU made in the last fifty years. Take a first semester CS
class and it'll be obvious how easy the algorithms are. Pick any base, I don't
care. However, if you're getting out the special characters than you've
obviously gone past base 36. (0-9,'A'..Z) What have we? Base 192? Gonna get
into the ASCII control codes too for base 256? Who the **** cares? It's the
same algorithm and trivial easy to accomplish.

 

[Skybuck Flying]

Kids don't do math with multipliers.

Kids do math with lookup table for the digits (last digit is X=10)

Usually called math tables I guess:

1*1 = 1
1*2 = 2
1*3 = 3
1*4 = 4
1*5 = 5
1*6 = 6
1*7 = 7
1*8 = 8
1*9 = 9
1*X = 10

2*1 = 1
2*2 = 3
2*3 = 6
2*4 = 8
2*5 = 10
2*6 = 12
2*7 = 14
2*8 = 16
2*9 = 18
2*X = 20

3*1 = 3
3*2 = 6
3*3 = 9
3*4 = 12
3*5 = 15
3*6 = 18
3*7 = 21
3*8 = 24
3*9 = 27
3*X = 30

4*1 = 4
4*2 = 8
4*3 = 12
4*4 = 16
4*5 = 20
4*6 = 24
4*7 = 28
4*8 = 32
4*9 = 36
4*X = 40

5*1 = 5
5*2 = 10
5*3 = 15
5*4 = 20
5*5 = 25
5*6 = 30
5*7 = 35
5*8 = 40
5*9 = 45
5*X = 50

6*1 = 6
6*2 = 12
6*3 = 18
6*4 = 24
6*5 = 30
6*6 = 36
6*7 = 42
6*8 = 48
6*9 = 54
6*X = 60

7*1 = 7
7*2 = 14
7*3 = 21
7*4 = 28
7*5 = 35
7*6 = 42
7*7 = 49
7*8 = 56
7*9 = 63
7*X = 70

8*1 = 8
8*2 = 16
8*3 = 24
8*4 = 32
8*5 = 40
8*6 = 48
8*7 = 56
8*8 = 64
8*9 = 72
8*X = 80

9*1 = 9
9*2 = 18
9*3 = 27
9*4 = 36
9*5 = 45
9*6 = 54
9*7 = 63
9*8 = 72
9*9 = 81
9*X = 90

X*1 = 10
X*2 = 20
X*3 = 30
X*4 = 40
X*5 = 50
X*6 = 60
X*7 = 70
X*8 = 80
X*9 = 90
X*X = X0

That should do it

Try coming up with an algorithm that uses math tables only

That's what cpu does:

Math tables:

0 * 0 = 0
1 * 0 = 1
0 * 1 = 1
1 * 1 = 1 (and carry ?? <- digit missing should have been X ? )

Oopsie lol I must have been thinking about the addition tables or so



Bye,
Skybuck.

 

[Skybuck Flying]

Especially a problem with 260 and a 290 digits. 75,400 single digit
multiplies. At one every two seconds (time for the multiply plus
some time for the carry), that's 42 hours straight and that's not
counting the adds. Good luck getting a kid in today's video game
generation to do any task that takes more than ten minutes.
The odds of there being no mistakes is vanishingly small. I'd say the
odds of absolute peace in the middle east for the next two centuries
is higher.

By the way, the answer is:
875279949449928687171082381195645449709812282235188534611991220487369\
750660866053304942879984231537943067897694712601511924963938379101922\
647017996467693753500201567049250263137918035932076754718727578460674\
626632963053682953542462596305825701489258055255205143723480139275624\
009749763785363546996951941944685372601254940771920912104622418969407\
723724820905001415363123084056285866891887451657302837214191356534169\
032664600101693678003589068377972327249782374353699650791261530178195\
228611902447640024153616963547499862263386141535774330150101189965

My intel compatible processor had no problem at all. I didn't even have
to install any new tools on my linux box. The lowly 'dc' desk
calculator
app did it just fine.

Very nice,

Now let's see if your software can multiply the following large
number:

"
DHDFHDFHGDFH#$%^&#^$^#^$&^&(&*)&*()&*_*)(+_(+*()_&*)(O%^&@#
$TWERTWERTETYTIYTOUYPUIPYULHKLK"LOP{P|
{}OIP{PUIOIRTYJKGHJLGHKHLUY:IO:UI"&O(&*(&*(&#^@$^%@%!#$!!%#$^
%@YRYWTEQTWWEYYTITYTIPGHKJGHLHGJLFSDASGZBZXBZXBVMBN<KHKGHKYTIRTUDFWEVT
$YB@$%B^#$&%N$N*%*M(WAWCQCWEHSRY#$^@%
$^&&3546b346bv546bv2mn348sdyb789s6g96q01987509176-8176=2624765987werhguietuiower78t78346634yERDFNCVMBBMVB<>M<?
MNRTU$*&*(^&)^&)(#^@$^@&%
$^*^JDjhebykljhrigouhsdiuhghivohw4ntvwv4ynb6y72768yn4tdyfofhgojbh8ohg897q1y91t78953478538049y-7btbhvsiouhgsbungauyb3nguib*(_*(+*|
PO|
POwepuyweuiytiouweyitouweyiotweuirtwerty7834673748096780934ytwuebDFHNFTUMY^&<LIOP>LKMTHHBv2u6280977880917580923746809759hywhyertyb,sdgDFJGHJ^R&I
%^(%U#Y@Q%Y#^%&*^&(YTwewRYEBRUNTUBW#^@#$^%$&#$&#@$%@!%!^$&(UBEBERNJ$$
%^*
"

*

"HE&$%^*^%&*(@^1254178265897236480937409yweHERUNTUIMIMOO>{"?P{"}P|{|
P{}|P{}RUYTURTUYRTUYRTUWTQWETWRTUOUPO&*3896734802589754234%$&^&(*(_()
+@#%!
wertyquioytqwuioytuioqweytuioeripoyuporturtu[\rt[ywtqiouqweipougsjkldhgjklshjkglahsdklghxcnxbnmsdrilweh78o2489623784962897359817809175378496092&&
$&*^&(&*()&!@$!@%WERWERYRTYUTYIUIP}|}|
ERSDFASDGsdfasdjklhggasfjkgasdgasjkgasdjhgasdasdfFADFASFASDFKGHLHJLDFE
$RY&%$^*^%*&*)*)+_)^&%$^@#%!@#%!%@@#$^&^*^
%ERHUTRTIURTHSAASDFFAASDFASDFASDFASDFSDGSDHGDFJKJ&%$*^%&*%^&(^&*)()*_%
$&@#%!
@5123745238468912368596189ytuwerguyhbhxdhntwej5n6246778496872368796586&
%$*%^*^&*^%&*@!@#$!@#%*(&*()TOPP{|
IUERTWEGSDHDFHSDGASDghbvuvu24t3n84567ybn87yt78bgw76t67178652896570934sdjfghjsdfgvCNCVMNCVMBDERU&3628378263965238746578126781527534^
$%&*^&()*(&_*)+(*&#@$#!qruioytuyqweuitoqwyiouytuioytup\o\y[o]\ty]opy
\usd'flkjhs;lkjg;ljsdgklshdklhgsdhgsd;g;sdj;hgjsd;fh;sdk;fhsw34623684928768wutqguiqywuio128097587230952346#
$&#$&%$WERHERYTTNGMB<NB?CX?>X?B<C?
VB<XCVN>mvsjldhgjlkhgklajshiuoweritouweyirytwi8127365623689567346-547865&(^&_(*)
(UIO{P{|TWERHDGHe5
"
Ignoring the "" signs.

These two texts represent one large decimal number. Each ASCII
character fills one byte.

Can you multiple these two large numbers together and show me the
large decimal result ?

Bye,
Skybuck.

Quote:

"
Yes, almost certainly, since the problem
is fundamentally the same as your previous
one, only this time, the numbers are
represented using base 128 numerals (or
maybe base 256 numerals depending on
whether or not you've encoded the numbers
using 7-bit or 8-bit ASCII) rather than
base 10 numerals.
Therefore, at worse, all that has to be
done is to tell the software how to
perform such a base conversion between
the representation you've chosen and the
one that it normally expects.

However, it seems reasonable to ask why
anyone would want to bother doing such
a thing.
What would it show to you that hasn't
already been shown?
What do you think it shows others that
hasn't already been shown?
Can *YOU* even check the result of the
calculation without resorting to a
computer?
And if you can't, aren't you basically
showing that your argument is at the
least very, very weak?
I know of very few adults let alone
kids who know how to deal with numbers
represented in bases other than 10 so
ISTM that your latest example does
nothing to support what you wrote in
your OP or anything else you've written
lately concerning the "need" for big
number hardware.
"

The c64 had base 3 number system, I understood that as 15 year old kid,
making multi color giana sister sprites

How to print 10 bytes as a decimal number ?

Bye,
Skybuck.

 

[Skybuck Flying]

1 * 1 = 1 (and carry ?? <- digit missing should have been X ? )

One times one is three? Your math is sure strange sky!

Well look at it this way:

10 * 10 = 100

Isn't that strange ?

Bye,
Skybuck.

 

[Nicholas King]

Let's save that table and quote it each time Mr Sky tries to start
another stupid thread.

That should be easier than trying to correct him each and every time he
makes a mistake.

Terje

We could just kill file him as I've been tempted to do many times.

Nicholas

 

[Skybuck Flying]

You're missing the 0* table.

Good point =D

You're missing 0*1.


Whatever this means...

How would you multiply 10 ?

As a single digit ?

With a lookup table ?

Or with the multiplication formula/algorithm ?

Bye,
Skybuck.

 

[Skybuck Flying]

Let's save that table and quote it each time Mr Sky tries to start another
stupid thread.

It's not that stupid:

When multiplieing 10 * 10 = 100 the 1 seems to move.

Why wouldn't that happen at binary level ?!?

In fact it probably happens as well when the numbers are finally added
together.

Bye,
Skybuck.

 

[Skybuck Flying]

[Please do not mail me a copy of your followup]

"Ken Hagan" <[email protected]> spake the secret code

This is nonsensical. You wouldn't implement such methods purely in
hardware since, unless you've got a way of adding transistors at run-time,
you'd be constrained in the size of number you could deal with.

There's nothing that says the hardware has to process all the bits of
an arbitrary precision number in parallel.

Precisely, it can do it in serial a digit at a time.

It can process them in chunks. Of course, you might argue that this is
just what the
software is doing and you'd be right, but it would still be an
implementation in hardware.

Intel are bad teachers.

How would you feel if intel thought your kids to do math their way ?

In other words: only able to multiply a few fixed digits <- yak !

Intel made bad cpu's and now we stuck with them =D

We programmers got screwed big time..

We writing *fixed-limited-based-shit*

Bye,
Skybuck.

 

[Skybuck Flying]

[ snip ]

Just one calculation:

11125422312367237234783454709540408340698340698340683049860398460349869374865786132123164361327957396523468273591287591237459238759237592375975923759283759823759237592375927398572398572394754164361436142634164243232123118202390593740572308652389562397652865

*

78673862876823144124298762947639845862359836963459364589364598376598365892376523978653876432231342132112121265121236721371278157834253482374584582348236583483458723054095409854709850985470985705968705968705968754096875409875409870457854097845069854097856098348572357862352364528761431654126541

Try calculating that in your spreadsheet or x86/x64 processor.

The processor can't do it without help of software/algorithms but your
neighbor's kids can all by themselfes !

Conclusion: processor is missing the basics of math, kids do have the
basics
of math.

But is that a fair comparison? The kid had to be taught some
algorithm for doing long division, no? Isn't that in some sense
analogous to software for arbitrary-precision arithmetic on a
processor that doesn't directly support it?

Following this path of reasoning that makes Intel bad teachers !

They claim their cpu does math <- fixed precision yak !

I claim kids do math better <- arbitary precision AHH nice =D

Bye,
Skybuck.

 

[Skybuck Flying]

Hey dopey, kids can't do it without an algorithm either....

They do it better than intel's algorithm which is implemented in their
hardware <- fixed precision yak !

Kids <- arbitary precision ! ah nice ! =D

Bye,
Skybuck.

 

[krw]

Well look at it this way:

10 * 10 = 100

In binary too.

Isn't that strange ?

No.

 

[krw]

Good point =D


How would you multiply 10 ?

Multiply by one and shift the result left one digit.

As a single digit ?

10 is not a single digit. Duh!

With a lookup table ?

See above.

Or with the multiplication formula/algorithm ?

The same way I'd do any other multi-precision arithmetic.

 

[Skybuck Flying]

Try it some time. I guarantee the kid will tell you to **** off.

Try telling them it's the ammount of money they can win or candy lol.

I will *bet* you they will do it =D

Bye,
Skybuck.