The reason 2's complement became the standard for representing negative 
numbers is just because of the characteristic you point out: that you 
can add _2+2 = 0 using the same hardware that would produce 6+2=8 (=0 to 
3-bit precision).

Early engineers tried many ways of representing numbers: first as 
decimal digits, but they got off that quickly; then as sign+magnitude 
and as 1's-complement (where a negative number just has all the bits 
complemented).  The trouble with those forms is that it is pretty 
important also to have a numeric type that is positive only, to the 
limit of the size of the machine word, and in those other forms you need 
different hardware implementation to add signed vs unsigned numbers.  So 
they died out.  But you can see the history: C is the first 
general-purpose language I know of that had bit-shift operations; 
earlier languages had to take account of machines that used other forms 
of number-representation.

Henry Rich

On 12/10/2011 10:02 PM, Kip Murray wrote:
> Let us add 1 1 0 and 0 1 0 in a simple-minded way working from right to
> left, and writing carries above the addition:
>
>    1 1 0<-- these are carries
>      1 1 0
>      0 1 0
>      -----
>    1 0 0 0
>
> If we keep only the right three bits in our answer we get 0 0 0 .  For
> this reason in two's-complement notation 1 1 0 represents _2 -- because
> when you "add" it to 0 1 0 you get 0 0 0 (because of keeping only three
> bits in the answer).  For the same reason 1 1 1 represents _1 in two's
> complement notation: when you "add" it to 0 0 1 you get 0 0 0 .
>
> Below hcinv finds the two's-compliment values of the three-bit numbers.
>
> On 12/10/2011 8:23 PM, Linda Alvord wrote:
>> I just finished posting my thoughts on this and found your function Henry.
>>
>>       hcinv =: ([: -/ [: #. (,: [: +: 1 {. ]))"1
>>      d
>> 1 1 0
>> 1 1 1
>> 0 0 0
>> 0 0 1
>> 0 1 0
>>
>>      hcinv d
>> _2 _1 0 1 2
>>
>> This shouldn't be  _2 _1 0 1 2   because  d  really is  6 7 0 1 2
>>
>>     ]c
>> _1 1  0
>>    0 0 _1
>>    0 0  0
>>    0 1 _1
>>    0 1  0
>>
>>      2 2 2#.c
>> _2 _1 0 1 2
>>
>> Base seems happy with negative numbers but #: is not so happy.
>>
>> Linda
>>
>> -----Original Message-----
>> From: programming-boun...@jsoftware.com
>> [mailto:programming-boun...@jsoftware.com] On Behalf Of Kip Murray
>> Sent: Saturday, December 10, 2011 7:48 PM
>> To: Programming forum
>> Subject: Re: [Jprogramming] How #: should have been designed
>>
>> Cool.  I think it is an improvement because it neatly avoids a case
>> statement.  Now I wonder if we could implement two's-complement addition
>> and multiplication with overflow, basing these on bitwise operations
>>
>>       0 + 0 is 0, 0 + 1 is 1 + 0 is 1, and 1 + 1 is 1 0
>>
>>       0 * 0 is 0 * 1 is 1 * 0 is 0, and 1*1 is 1
>>
>> That is, I do not want hc and hcinv to be used except to produce data
>> and check answers, and I want n-bit two's-complement answers for n-bit
>> two's-complement data so some of them will be wrong because of overflow.
>>
>> Here for Linda is Henry's hcinv expressed without conjunctions other
>> than " .
>>
>>       hcinv =: ([: -/ [: #. (,: [: +: 1 {. ]))"1
>>
>> On 12/10/2011 10:00 AM, Henry Rich wrote:
>>> Same idea, better implementation
>>>
>>>        hcinv =. -/@:#.@:(,: +:@(1&{.))"1
>>>
>>> Henry Rich
>>>
>>> On 12/10/2011 10:48 AM, Henry Rich wrote:
>>>> Maybe not an improvement, but this is how I would have done back in my
>>>> hardware-design days:
>>>>
>>>> hcinv =. -~/@:#.@:(~:/\)@:((,1)&,:)"1
>>>>
>>>> Quite a bit more elegant in wires than in J!
>>>>
>>>> Henry Rich
>>>>
>>>> On 12/10/2011 1:01 AM, Kip Murray wrote:
>>>>> Now we need an inverse for Raul's improved #: ("hash colon")
>>>>>
>>>>>           hc  NB. Raul's improved #:
>>>>>        {.@#:@(,: (2 * |))
>>>>>
>>>>>           hc i: 2
>>>>>        1 1 0
>>>>>        1 1 1
>>>>>        0 0 0
>>>>>        0 0 1
>>>>>        0 1 0
>>>>>
>>>>>           hcinv  NB. improvement sought
>>>>>        2&#.`(2&#.@}. - 2 ^<:@#)@.{."1
>>>>>
>>>>>           hcinv hc i: 2
>>>>>        _2 _1 0 1 2
>>>>>
>>>>> On 12/8/2011 2:41 PM, Raul Miller wrote:
>>>>> ...
>>>>> But this would work just as well, as a model:
>>>>>
>>>>>           {.@#:@(,:  2 * |)i:2
>>>>>        1 1 0
>>>>>        1 1 1
>>>>>        0 0 0
>>>>>        0 0 1
>>>>>        0 1 0
>>>>> ----------------------------------------------------------------------
>>>>> For information about J forums see http://www.jsoftware.com/forums.htm
>>>>>
>>>> ----------------------------------------------------------------------
>>>> For information about J forums see http://www.jsoftware.com/forums.htm
>>>>
>>> ----------------------------------------------------------------------
>>> For information about J forums see http://www.jsoftware.com/forums.htm
>> ----------------------------------------------------------------------
>> For information about J forums see http://www.jsoftware.com/forums.htm
>>
>> ----------------------------------------------------------------------
>> For information about J forums see http://www.jsoftware.com/forums.htm
> ----------------------------------------------------------------------
> For information about J forums see http://www.jsoftware.com/forums.htm
>
----------------------------------------------------------------------
For information about J forums see http://www.jsoftware.com/forums.htm

Reply via email to