Bitwise XOR?

Bitwise XOR?

[David N. Maez]

I'm new to Ada, and I'm wondering what the bitwise (not logical) Exclusive
Or function is?
Using Gnat, this fails to compile:

with Ada.Text_IO; use Ada.Text_IO;
procedure foobar is
  x : integer;
  y : integer;
begin
  x := 12;
  y := 23;
  x := x xor y;
  put_line(x'img);
end foobar;

Gnat complains:
foobar.adb:9:10: invalid operand types for operator "xor"
foobar.adb:9:10: left operand has type "Standard.integer"
foobar.adb:9:10: right operand has type "Standard.integer"

What am I missing?

Re: Bitwise XOR?

[sk]

"David N. Maez" <sellout@dharmadevil.com>:
 > ...

Try using modular types.

with Ada.Text_IO; use Ada.Text_IO;
procedure foobar is

     type Unsigned_32 is mod 2 ** 32;

     x,y : Unsigned_32;

begin
   x := 12;
   y := 23;
   x := x xor y;
   put_line(x'img);
end foobar;


-- 
-------------------------------------------------
-- Merge vertically for real address
--
--     s n p @ t . o
--      k i e k c c m
-------------------------------------------------

Re: Bitwise XOR?

[Adrian Knoth]

David N. Maez <sellout@dharmadevil.com> wrote:

>   x : integer;
>   y : integer;
>   x := x xor y;

> What am I missing?

There is no XOR defined for anything else than bits. You'll need
to mask the bits and recombine the result.

I did it some time ago, I'm not sure whether it is right, perhaps
it should be done on mod-datatypes.

   function "xor" (Left, Right : in Integer) return Integer is
      result : Integer := 0;
      leftrest : Integer := Left;
      rightrest : Integer := Right;
      boolleft, boolright : Boolean;

   begin
      for I in 0 .. Integer'Size - 1 loop
         if (leftrest mod 2 = 1) then
            boolleft := True;
         else
            boolleft := False;
         end if;

         leftrest := leftrest / 2;
         if (rightrest mod 2 = 1) then
            boolright := True;
         else
            boolright := False;
         end if;
         rightrest := rightrest / 2;

         if (boolleft xor boolright) then
            result := result + 2**(I);
         end if;
      end loop;

      return result;
   end "xor";


-- 
mail: adi@thur.de  	http://adi.thur.de	PGP: v2-key via keyserver

M�nner sind wie Jeans: blau und steif...

Re: Bitwise XOR?

[John McCabe]

On Wed, 01 Oct 2003 21:03:37 -0500, sk <noname@myob.com> wrote:

>"David N. Maez" <sellout@dharmadevil.com>:
> > ...
>
>Try using modular types.
>
>with Ada.Text_IO; use Ada.Text_IO;
>procedure foobar is
>
>     type Unsigned_32 is mod 2 ** 32;
>
>     x,y : Unsigned_32;
>
>begin
>   x := 12;
>   y := 23;
>   x := x xor y;
>   put_line(x'img);
>end foobar;

For the record....

http://www.adaic.org/standards/95lrm/html/RM-4-5-1.html#I2480


Best Regards
John McCabe

To reply by email replace 'nospam' with 'assen'

Re: Bitwise XOR?

[Marin David Condic]

In case you didn't notice the related posts, yes there are logical 
operators for things other than Booleans. You can do them on modular 
types. You can also do them on packed arrays of Booleans. Check the ARM 
- its pretty useful stuff if you're into bit-twiddling.

MDC

Adrian Knoth wrote:
> 
> There is no XOR defined for anything else than bits. You'll need
> to mask the bits and recombine the result.

-- 
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jsf.mil/NSFrames.htm

Send Replies To: m c o n d i c @ a c m . o r g

     "All reformers, however strict their social conscience,
      live in houses just as big as they can pay for."

          --Logan Pearsall Smith
======================================================================

Re: Bitwise XOR?

[Adrian Knoth]

Marin David Condic <nobody@noplace.com> wrote:

> In case you didn't notice the related posts, yes there are logical 
> operators for things other than Booleans. You can do them on modular 
> types. 

Thanks for pointer, I didn't know that.


-- 
mail: adi@thur.de  	http://adi.thur.de	PGP: v2-key via keyserver

Lieber Gott, schmei� Hirn auf Dein verlorenes Schaf Johannes Sackmann. Und 
wickel es vorher in Stahl ein.  (Robin S. Socha in de.comp.security.misc)

Re: Bitwise XOR?

[Jeffrey Carter]

Marin David Condic wrote:
> In case you didn't notice the related posts, yes there are logical 
> operators for things other than Booleans. You can do them on modular 
> types. You can also do them on packed arrays of Booleans. Check the ARM 
> - its pretty useful stuff if you're into bit-twiddling.

Logical operations are defined on one-dimensional arrays with a Boolean 
component type, packed or not.

-- 
Jeff Carter
"You cheesy lot of second-hand electric donkey-bottom biters."
Monty Python & the Holy Grail
14

Re: Bitwise XOR?

[Steve]

[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #1: Type: text/plain, Size: 1125 bytes --]

"Adrian Knoth" <adi@thur.de> wrote in message
news:slrnbnnohq.26h.adi@ppc201.mipool.uni-jena.de...
> David N. Maez <sellout@dharmadevil.com> wrote:
>
> >   x : integer;
> >   y : integer;
> >   x := x xor y;
>
> > What am I missing?
>
> There is no XOR defined for anything else than bits. You'll need
> to mask the bits and recombine the result.
>

Not true.

Ada 95 permits using XOR on modular types.
If you want to XOR between integers, convert the integer to a modular type,
do the XOR,
then convert the result back.  The following (tested) routine does exactly
this.

  function "xor"(Left,Right : in Integer) return Integer is
    pragma inline("xor");
    type Int_As_Mod is mod 2 ** Integer'size;
    function To_Mod is new Ada.Unchecked_Conversion( Integer, Int_As_Mod );
    function To_Int is new Ada.Unchecked_Conversion( Int_As_Mod, Integer );
  begin
    return To_Int( To_Mod(Left) XOR To_Mod(Right) );
  end "xor";

Steve
(The Duck)

[excessively complicated untested example deleted]
> -- 
> mail: adi@thur.de  http://adi.thur.de PGP: v2-key via keyserver
>
> M�nner sind wie Jeans: blau und steif...

RE: Bitwise XOR?

[Beard, Frank Randolph CIV]

You don't even need the Unchecked_Conversion.

The following should work:

  function "xor"(Left,Right : in Integer) return Integer is
    pragma inline("xor");
    type Int_As_Mod is mod 2 ** Integer'size;
  begin
    return Integer( Int_As_Mod(Left) XOR Int_As_Mod(Right) );
  end "xor";

Theoretically, Unchecked_Conversion should be faster I guess.
Is that why you chose it, or did you do some timing tests
that showed a noticeable difference?

Frank

-----Original Message-----
From: Steve

Ada 95 permits using XOR on modular types.
If you want to XOR between integers, convert the integer to a modular type,
do the XOR,
then convert the result back.  The following (tested) routine does exactly
this.

  function "xor"(Left,Right : in Integer) return Integer is
    pragma inline("xor");
    type Int_As_Mod is mod 2 ** Integer'size;
    function To_Mod is new Ada.Unchecked_Conversion( Integer, Int_As_Mod );
    function To_Int is new Ada.Unchecked_Conversion( Int_As_Mod, Integer );
  begin
    return To_Int( To_Mod(Left) XOR To_Mod(Right) );
  end "xor";

Steve
(The Duck)

Re: Bitwise XOR?

[Marin David Condic]

Note that *technically* speaking, I'm not "wrong" - I only observed that 
you *could* do the operations on packed arrays of boolean. I didn't say 
you *couldn't* do them on unpacked arrays. :-) Having soothed my ego, 
thanks for the correction. ;-)

MDC


Jeffrey Carter wrote:
> 
> Logical operations are defined on one-dimensional arrays with a Boolean 
> component type, packed or not.
> 


-- 
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jsf.mil/NSFrames.htm

Send Replies To: m c o n d i c @ a c m . o r g

     "All reformers, however strict their social conscience,
      live in houses just as big as they can pay for."

          --Logan Pearsall Smith
======================================================================

Re: Bitwise XOR?

[Jeffrey Carter]

Marin David Condic wrote:

> Note that *technically* speaking, I'm not "wrong" - I only observed that 
> you *could* do the operations on packed arrays of boolean. I didn't say 
> you *couldn't* do them on unpacked arrays. :-) Having soothed my ego, 
> thanks for the correction. ;-)
> 
> MDC
> 
> Jeffrey Carter wrote:
> 
>> Logical operations are defined on one-dimensional arrays with a 
>> Boolean component type, packed or not.

Now that your ego is soothed, should I point out that a Boolean type is 
type Boolean or any type derived from it?

-- 
Jeff Carter
"This school was here before you came,
and it'll be here before you go."
Horse Feathers
48

Re: Bitwise XOR?

[Marin David Condic]

Oh go ahead. Have a ball. :-)

MDC


Jeffrey Carter wrote:

> 
> Now that your ego is soothed, should I point out that a Boolean type is 
> type Boolean or any type derived from it?
> 


-- 
======================================================================
Marin David Condic
I work for: http://www.belcan.com/
My project is: http://www.jsf.mil/NSFrames.htm

Send Replies To: m c o n d i c @ a c m . o r g

     "All reformers, however strict their social conscience,
      live in houses just as big as they can pay for."

          --Logan Pearsall Smith
======================================================================

Re: Bitwise XOR?

[Steve]

The unchecked conversion must be used is to avoid the range check.  For
example, the following code causes a a range check exception:

declare
  a : Integer;
  b : Integer;
begin
  a := -1;
  b := 1;
  result := a xor b;
end;

Steve
(The Duck)

"Beard, Frank Randolph CIV" <frank.beard@navy.mil> wrote in message
news:mailman.28.1065177023.25614.comp.lang.ada@ada-france.org...
You don't even need the Unchecked_Conversion.

The following should work:

  function "xor"(Left,Right : in Integer) return Integer is
    pragma inline("xor");
    type Int_As_Mod is mod 2 ** Integer'size;
  begin
    return Integer( Int_As_Mod(Left) XOR Int_As_Mod(Right) );
  end "xor";

Theoretically, Unchecked_Conversion should be faster I guess.
Is that why you chose it, or did you do some timing tests
that showed a noticeable difference?

Frank

-----Original Message-----
From: Steve

Ada 95 permits using XOR on modular types.
If you want to XOR between integers, convert the integer to a modular type,
do the XOR,
then convert the result back.  The following (tested) routine does exactly
this.

  function "xor"(Left,Right : in Integer) return Integer is
    pragma inline("xor");
    type Int_As_Mod is mod 2 ** Integer'size;
    function To_Mod is new Ada.Unchecked_Conversion( Integer, Int_As_Mod );
    function To_Int is new Ada.Unchecked_Conversion( Int_As_Mod, Integer );
  begin
    return To_Int( To_Mod(Left) XOR To_Mod(Right) );
  end "xor";

Steve
(The Duck)

Re: Bitwise XOR?

[Robert I. Eachus]

Beard, Frank Randolph CIV wrote:
> You don't even need the Unchecked_Conversion.
> 
> The following should work:
> 
>   function "xor"(Left,Right : in Integer) return Integer is
>     pragma inline("xor");
>     type Int_As_Mod is mod 2 ** Integer'size;
>   begin
>     return Integer( Int_As_Mod(Left) XOR Int_As_Mod(Right) );
>   end "xor";
> 
> Theoretically, Unchecked_Conversion should be faster I guess.
> Is that why you chose it, or did you do some timing tests
> that showed a noticeable difference?

First, the Unchecked_Conversion is correct.  The above code will not do 
what you expect with negative numbers, it will raise an exception.  The 
Unchecked_Conversion will not only prevent the "unnecessary" check, but 
will also be faster.

-- 
                                                     Robert I. Eachus

"Quality is the Buddha. Quality is scientific reality. Quality is the 
goal of Art. It remains to work these concepts into a practical, 
down-to-earth context, and for this there is nothing more practical or 
down-to-earth than what I have been talking about all along...the repair 
of an old motorcycle."  -- from Zen and the Art of Motorcycle 
Maintenance by Robert Pirsig