Logical operations

Logical operations
You are encouraged to solve this task according to the task description, using any language you may know.

Basic Data Operation
This is a basic data operation. It represents a fundamental action on a basic data type.

You may see other such operations in the Basic Data Operations category, or:

Integer Operations
Arithmetic | Comparison

Boolean Operations
Bitwise | Logical

String Operations
Concatenation | Interpolation | Matching

Memory Operations
Pointers & references | Addresses

Write a function that takes two logical (boolean) values, and outputs the result of "and" and "or" on both arguments as well as "not" on the first arguments. If the programming language doesn't provide a separate type for logical values, use the type most commonly used for that purpose.

If the language supports additional logical operations on booleans such as XOR, list them as well.

ACL2

(defun logical-ops (a b)
   (progn$ (cw "(and a b) = ~x0~%" (and a b))
           (cw "(or a b)  = ~x0~%" (or a b))
           (cw "(not a) =   ~x0~%" (not a))))

Ada

I have also included logical xor because it is defined for Ada boolean types. All the operators below work equally well on arrays of boolean types. In fact, a packed array of boolean is an array of bits, providing a direct link between logical and bitwise operations.

procedure Print_Logic(A : Boolean; B : Boolean) is
begin
   Put_Line("A and B is " & Boolean'Image(A and B));
   Put_Line("A or B  is " & Boolean'Image(A or B));
   Put_Line("A xor B is " & Boolean'Image(A xor B));
   Put_Line("not A   is " & Boolean'Image(not A));
end Print_Logic;

Agda

module AndOrNot where
 
open import Data.Bool
open import Data.Product
 
test : Bool → Bool → Bool × Bool × Bool
test x y = x ∧ y , x ∨ y , not x

e.g.

test true false ⇒ false , true , false

Aikido

 
function logic(a,b) {
  println("a AND b: " + (a && b))
  println("a OR b: " + (a || b))
  println("NOT a: " + (!a))
}
 

Aime

void
out(integer a, integer b)
{
    o_integer(a && b);
    o_byte('\n');
    o_integer(a || b);
    o_byte('\n');
    o_integer(!a);
    o_byte('\n');
}

ALGOL 68

PROC print_logic = (BOOL a, b)VOID:
(
# for a 6-7 bit/byte compiler #
  printf(($"a and b is "gl$, a AND b);
  printf(($"a or b is "gl$, a OR b);
  printf(($"not a is "gl$, NOT a);
  printf(($"a equivalent to b is "gl$, a EQ b);
  printf(($"a not equivalent to b is "gl$, a NE b);
 
# Alternatively ASCII # 
  printf(($"a and b is "gl$, a & b); 
  printf(($"a and b is "gl$, a /\ b);  <!-- http://web.archive.org/web/20021207211127/http://www.bobbemer.com/BRACES.HTM -->
  printf(($"a or b is "gl$, a \/ b);
  printf(($"a equivalent to b "gl$, a = b);
  printf(($"a not equivalent to b "gl$, a /= b);
 
¢ for a European 8 bit/byte charcter set eg. ALCOR or GOST ¢
  printf(($"a and b is "gl$, a ∧ b);
  printf(($"a or b is "gl$, a ∨ b);
  printf(($"not a is "gl$, ¬ a)
  printf(($"a not equivalent to b is "gl$, a ≠ b)
)

AutoHotkey

a = 1
b = 0
msgbox % "a and b is " . (a && b)
msgbox % "a or b is " . (a || b)
msgbox % "not a is " . (!a)

AWK

$ awk '{print "and:"($1&&$2),"or:"($1||$2),"not:"!$1}'
0 0
and:0 or:0 not:1
0 1
and:0 or:1 not:1
1 0
and:0 or:1 not:0
1 1
and:1 or:1 not:0

BASIC

Works with: QuickBasic version 4.5

SUB logic (a%, b%) 'no booleans in BASIC...these are integers. 1 for true 0 for false.
  PRINT a AND b
  PRINT a OR b
  PRINT NOT a
END SUB

BASIC256

a = true
b = false
print a and b
print a or b
print a xor b
print not a

BBC BASIC

      PROClogic(FALSE, FALSE)
      PROClogic(FALSE, TRUE)
      PROClogic(TRUE, FALSE)
      PROClogic(TRUE, TRUE)
      END
 
      DEF PROClogic(a%, b%)
      LOCAL @% : @% = 2 : REM Column width
      PRINT a% " AND " b% " = " a% AND b% TAB(20);
      PRINT a% " OR "  b% " = " a% OR b%  TAB(40);
      PRINT a% " EOR " b% " = " a% EOR b% TAB(60);
      PRINT " NOT " a% " = " NOT a%
      ENDPROC

Output:

 0 AND  0 =  0       0 OR  0 =  0        0 EOR  0 =  0       NOT  0 = -1
 0 AND -1 =  0       0 OR -1 = -1        0 EOR -1 = -1       NOT  0 = -1
-1 AND  0 =  0      -1 OR  0 = -1       -1 EOR  0 = -1       NOT -1 =  0
-1 AND -1 = -1      -1 OR -1 = -1       -1 EOR -1 =  0       NOT -1 =  0

Brat

logic = { a, b |
  p "a and b: #{ a && b }"
  p "a or b: #{ a || b }"
  p "not a: #{ not a }"
}

C

void print_logic(int a, int b)
{
  printf("a and b is %d\n", a && b);
  printf("a or b is %d\n", a || b);
  printf("not a is %d\n", !a);
}

C++

void print_logic(bool a, bool b)
{
  std::cout << std::boolalpha; // so that bools are written as "true" and "false"
  std::cout << "a and b is " << (a && b) << "\n";
  std::cout << "a or b is " << (a || b) << "\n";
  std::cout << "not a is " << (!a) << "\n";
}

C#

using System;
 
namespace LogicalOperations
{
    class Program
    {
        static void Main(string[] args)
        {
            bool a = true, b = false;
            Console.WriteLine("a and b is {0}", a && b);
            Console.WriteLine("a or b is {0}", a || b);
            Console.WriteLine("Not a is {0}", !a);
            Console.WriteLine("a exclusive-or b is {0}", a ^ b);
        }
    }
}

Clojure

 
(defn logical [a b] 
  (prn (str "a and b is " (and a b)))
  (prn (str "a or b is " (or a b)))
  (prn (str "not a is "  (not a))))
 
(logical true false)
 

ColdFusion

<cffunction name = "logic" hint = "Performs basic logical operations">
  <cfargument name = "a" required = "yes" type = "boolean" />
  <cfargument name = "a" required = "yes" type = "boolean" />
  <cfoutput>
    'A' AND 'B' is #a AND b#< br />
    'A' OR  'B' is #a OR  b#< br />
    NOT 'A'     is #!a#
  </cfoutput>
</cffunction>

Common Lisp

(defun logic (a b)
  (print "a and b is") (write (and a b))
  (print "a or b is" ) (write (or a b))
  (print "not a is"  ) (write (not a)))

D

import std.stdio;
 
void logic(T, U)(T lhs, U rhs) {
    writefln("'%s' is of type '%s', '%s' is of type '%s';", 
             lhs, typeid(typeof(lhs)), rhs,typeid(typeof(rhs)));
    writefln("\t'%s' AND '%s' is %s, ", lhs, rhs, lhs && rhs);
    writefln("\t'%s' OR '%s' is %s, ", lhs, rhs, lhs || rhs);
    writefln("\tNOT '%s' is %s.\n", lhs, !lhs);
}
 
class C { int value; } 
 
void main() {
    bool theTruth = true;
    bool theLie = false;
    real zeroReal = 0.0L;
    real NaN; // D initializes floating point values to NaN
    int zeroInt  = 0;
    real[] nullArr = null;
    string emptyStr = "";
    string nullStr = null;
    C someC = new C;
    C nullC = null;
 
    // Note: Struct is value type in D, but composite
    //  so no default bool equivalent.
 
    logic(theTruth, theLie); 
    logic(zeroReal, NaN);  
    logic(zeroInt, nullArr); 
    logic(nullStr, emptyStr);  
    logic(someC, nullC);  
}

Output:

'true' is of type 'bool', 'false' is of type 'bool';
    'true' AND 'false' is false, 
    'true' OR 'false' is true, 
    NOT 'true' is false.

'0' is of type 'real', 'nan' is of type 'real';
    '0' AND 'nan' is false, 
    '0' OR 'nan' is true, 
    NOT '0' is true.

'0' is of type 'int', '[]' is of type 'real[]';
    '0' AND '[]' is false, 
    '0' OR '[]' is false, 
    NOT '0' is true.

'' is of type 'immutable(char)[]', '' is of type 'immutable(char)[]';
    '' AND '' is false, 
    '' OR '' is true, 
    NOT '' is true.

'logical_operations.C' is of type 'logical_operations.C', 'null' is of type 'logical_operations.C';
    'logical_operations.C' AND 'null' is false, 
    'logical_operations.C' OR 'null' is true, 
    NOT 'logical_operations.C' is false.

Delphi

program LogicalOperations;
 
{$APPTYPE CONSOLE}
 
const
  a = True;
  b = False;
begin
  Write('a = ');
  Writeln(a);
  Write('b = ');
  Writeln(b);
  Writeln;
 
  Write('a AND b: ');
  Writeln(a AND b);
 
  Write('a OR b: ');
  Writeln(a OR b);
 
  Write('NOT a: ');
  Writeln(NOT a);
 
  Write('a XOR b: ');
  Writeln(a XOR b);
end.

Output:

a = TRUE
b = FALSE

a AND b: FALSE
a OR b: TRUE
NOT a: FALSE
a XOR b: TRUE

DWScript

var a := True;
var b := False;
 
Print('a = ');
PrintLn(a);
Print('b = ');
PrintLn(b);
 
Print('a AND b: ');
PrintLn(a AND b);
 
Print('a OR b: ');
PrintLn(a OR b);
 
Print('NOT a: ');
PrintLn(NOT a);
 
Print('a XOR b: ');
PrintLn(a XOR b);

Output:

a = True
b = False
a AND b: False
a OR b: True
NOT a: False
a XOR b: True

E

def logicalOperations(a :boolean, b :boolean) {
    return ["and" => a & b,
            "or"  => a | b,
            "not" => !a,
            "xor" => a ^ b]
}

Each of these is a method on boolean objects; the above is precisely equivalent to:

def logicalOperations(a :boolean, b :boolean) {
    return ["and" => a.and(b),
            "or"  => a.or(b),
            "not" => a.not(),
            "xor" => a.xor(b)]
}

If the :boolean guards were removed, these operations would also work on other types, such as sets (& is union and | is intersection; not is not supported).

Efene

compare_bool = fn (A, B) {
    io.format("~p and ~p = ~p~n", [A, B, A and B])
    io.format("~p or ~p = ~p~n", [A, B, A or B])
    io.format("not ~p = ~p~n", [A, not A])
    io.format("~p xor ~p = ~p~n", [A, B, A xor B])
    io.format("~n")
}
 
@public 
run = fn () {
    compare_bool(true, true)
    compare_bool(true, false)
    compare_bool(false, true)
    compare_bool(false, false)
}
 

Erlang

1> true and false.
false
2> false or true.
true
3> true xor false.
true
4> not false.
true
5> not (true and true).
false

Euphoria

procedure print_logic(integer a, integer b)
    printf(1,"a and b is %d\n", a and b)
    printf(1,"a or b is %d\n", a or b)
    printf(1,"a xor b is %d\n", a xor b)
    printf(1,"not a is %d\n", not a)
end procedure

Factor

: logical-operators ( a b -- )
    {
        [ "xor is: " write xor . ]
        [ "and is: " write and . ]
        [ "or is:  " write or . ]
        [ "not is: " write drop not . ]
    } 2cleave ;

FALSE

FALSE uses zero/non-zero for testing False and True. Comparison operators return -1 for True and 0 for False, which work with bitwise operators for logical operations.

1 3=~["unequal, "]?
1 1= 1_=["true is -1, "]?
0~["false is 0, "]?
'm$'a>'z@>&["a < m < z"]?

Fantom

 
class Main
{
  static Void doOps (Bool arg1, Bool arg2)
  {
    echo ("$arg1 and $arg2 = ${arg1.and(arg2)}")
    echo ("$arg1 or $arg2 = ${arg1.or(arg2)}")
    echo ("not $arg1 = ${arg1.not}")
    echo ("$arg1 xor $arg2 = ${arg1.xor(arg2)}")
  }
 
  public static Void main ()
  {
    [true,false].each |Bool arg1|
    {
      [true,false].each |Bool arg2|
      {
        doOps (arg1, arg2)
      }
    }
  }
}
 

Forth

Forth can use bitwise operators if the boolean values are well formed: TRUE (-1) and FALSE (0). 0<> converts an ill-formed flag (zero/non-zero) to a well-formed flag (false/true).

: .bool ( ? -- ) if ." true" else ." false" then ;
: logic ( a b -- ) 0<> swap 0<> swap
 cr ." a = " over .bool ."   b = " dup .bool
 cr ." a and b = " 2dup and .bool
 cr ." a  or b = " over  or .bool
 cr ." not a = " 0= .bool ;

Fortran

In ANSI FORTRAN 66 or later, use LOGICAL data type:

       SUBROUTINE PRNLOG(A, B)
       LOGICAL A, B
       PRINT *, 'a and b is ', A .AND. B
       PRINT *, 'a or b is ', A .OR. B
       PRINT *, 'not a is ', .NOT. A
 
C       You did not ask, but the following logical operators are also standard
C       since ANSI FORTRAN 66 
C       =======================================================================
 
C       This yields the same results as .EQ., but has lower operator precedence
C       and only works with LOGICAL operands:
       PRINT *, 'a equivalent to b is ', A .EQV. B
 
C       This yields the same results as .NE., but has lower operator precedence
C       and only works with LOGICAL operands (this operation is also commonly
C       called "exclusive or"):
       PRINT *, 'a not equivalent to b is ', A .NEQV. B
       END

GAP

Logical := function(a, b)
    return [ a or b, a and b, not a ];
end;
 
Logical(true, true);
# [ true, true, false ]
 
Logical(true, false);
# [ true, false, false ]
 
Logical(false, true);
# [ true, false, true ]
 
Logical(false, false);
# [ false, false, true ]

gecho

3 4 and

3&&4

1 2 or

1||2

Go

func printLogic(a, b bool) {
    fmt.Println("a and b is", a && b)
    fmt.Println("a or b is", a || b)
    fmt.Println("not a is", !a)
}

Other operators that work on type bool are == and !=. == corresponds to the logical operation of equivalence.  != corresponds to exclusive or.

Groovy

def logical = { a, b ->
    println """
a AND b   = ${a} && ${b}   = ${a & b}
a OR b    = ${a} || ${b}   = ${a | b}
NOT a     = ! ${a}         = ${! a}
a XOR b   = ${a} != ${b}   = ${a != b}
a EQV b   = ${a} == ${b}   = ${a == b}
"""
}

Program:

logical(true, true)
logical(true, false)
logical(false, false)
logical(false, true)

Output:

a AND b   = true && true   = true
a OR b    = true || true   = true
NOT a     = ! true         = false
a XOR b   = true != true   = false
a EQV b   = true == true   = true


a AND b   = true && false   = false
a OR b    = true || false   = true
NOT a     = ! true         = false
a XOR b   = true != false   = true
a EQV b   = true == false   = false


a AND b   = false && false   = false
a OR b    = false || false   = false
NOT a     = ! false         = true
a XOR b   = false != false   = false
a EQV b   = false == false   = true


a AND b   = false && true   = false
a OR b    = false || true   = true
NOT a     = ! false         = true
a XOR b   = false != true   = true
a EQV b   = false == true   = false

Haskell

Instead of a function and printing, which is unidiomatic for Haskell, here are the operations in the same style as in Bitwise operations:

a = False
b = True
 
a_and_b = a && b
a_or_b  = a || b
not_a   = not a

HicEst

No logical variables. Nonzero is true, zero is false in logical expressions:

  x     = value1 /= 0
  y     = value2 /= 0
  NOTx  = x == 0
  xANDy = x * y
  xORy  = x + y  /= 0
  EOR   = x /= y 

Io

printLogic := method(a,b,
  writeln("a and b is ", a and b)
  writeln("a or b is ", a or b)
  writeln("not a is ", a not) 
)

Icon and Unicon

Icon/Unicon do not have a native logical or Boolean type; nor do they use Boolean values for flow control. Instead for flow control they use the concept of success (a result is returned) or failure (a signal). For more on this see see Short Circuit Evaluation. Because there is almost no need for Boolean values the concept is somewhat alien.

One likely situation where Boolean values could be encountered is working with an external array of bits/flags. This example attempts to show a solution that would work in such a scenario. Some characteristics would include:

• the ability to work with an entire array of bits
• the ability to test an individual bit for true/false
• need to be careful with automatic type conversions

Of course other characteristics and functionality might be desirable, examples include:

• shifting (based on ishift)
• rotation
• conversion to a (large) integer
• setting a specific bit in the array

Those are left as an exercise for the reader.

There are a couple of choices for implementation. Briefly:

• use of &null and a non-null - this creates problems for negation as not &null can be any or all values
• use of large integers as bit arrays - only signed integers are supported and this complicates preserving array length
• use of strings - a bit wasteful of space

This implementation uses strings as packed arrays of bits. This facilitates easy reading and writing from external sources. While string length is variable it is controlled and doesn't change under negation. The built-in integer bit operations (ior, ixor, iand, ishift) can be utilized under the covers.

invocable all
 
procedure main()                      #: sample demonstrating boolean function use
 
limit := 4
char2 := char(2)||char(0)
every (i := char(1 to limit)|char2) do {
   write(iop := "bnot","( ",image(i)," ) = ",image(iop(i)))
   every k := 3 | 10 do {
     write("bistrue(",image(i),",",k,") - ", if bistrue(i,k) then "returns" else "fails")
     write("bisfalse(",image(i),",",k,") - ", if bisfalse(i,k) then "returns" else "fails")
     }
   every (j := char(1 to limit)) & (iop := "bor"|"band"|"bxor") do 
      write(iop,"( ",image(i),", ",image(j)," ) = ",image(iop(i,j)))
   }
end
 
 
procedure bisfalse(b,p)                #: test if bit p (numbered right to left from 1) is false; return b or fails
return boolean_testbit(0,b,p)
end
 
procedure bistrue(b,p)                 #: test if bit p is true; return b or fails
return boolean_testbit(1,b,p)
end
 
procedure bnot(b)                      #: logical compliment of b (not is a reserved word)
static cs,sc
initial sc := reverse(cs := string(&cset))
if type(b) ~== "string" then runerr(103,b)
return map(b,cs,sc)                    # en-mass inversion through remapping ordered cset
end
 
procedure bor(b1,b2)                   #: logical or
return boolean_op(ior,b1,b2)
end
 
procedure band(b1,b2)                  #: logical or
return boolean_op(iand,b1,b2)
end
 
procedure bxor(b1,b2)                  #: logical or
return boolean_op(ixor,b1,b2)
end
 
procedure boolean_testbit(v,b,p)       #: (internal) test if bit p is true/false; return b or fail
if not 0 <= integer(p) = p then runerr(101,p)
if type(b) ~== "string" then runerr(103,b)
if v = ishift(ord(b[-p/8-1]), -(p%8)+1) then return b
end
 
procedure boolean_op(iop,b1,b2)        #: boolean helper 
local b3,i
static z
initial z := char(0)
if type(b1) ~== "string" then runerr(103,b1)
if type(b2) ~== "string" then runerr(103,b2)
b3 := ""
every i := -1 to -max(*b1,*b2) by -1 do 
   b3 :=  char(iop(ord(b1[i]|z),ord(b2[i]|z))) || b3
return b3
end

Partial Sample Output

...
bnot( "\x03" ) = "\xfc"
...
bor( "\x03", "\x01" ) = "\x03"
band( "\x03", "\x01" ) = "\x01"
bxor( "\x03", "\x01" ) = "\x02"
...
bnot( "\x02\x00" ) = "\xfd\xff"
bistrue("\x02\x00",3) - fails
bisfalse("\x02\x00",3) - returns
bistrue("\x02\x00",10) - returns
bisfalse("\x02\x00",10) - fails
bor( "\x02\x00", "\x01" ) = "\x02\x01"
band( "\x02\x00", "\x01" ) = "\x00\x00"
bxor( "\x02\x00", "\x01" ) = "\x02\x01"
...

J

J uses 0 for logical false and 1 for logical true.

   aon=: *.`+.`(-.@[)`:0

Given boolean arguments, *. is logical and, +. is logical or, and -.is logical not.

Additional primary logical operators include *: (not-and), +: (not-or), ~: (exclusive-or) and <: (logical implication).

 
   a=: 0 0 1 1   NB. Work on vectors to show all possible
   b=: 0 1 0 1   NB. 2-bit combos at once.
   a aon b
0 0 0 1
0 1 1 1
1 1 0 0

Java

public static void logic(boolean a, boolean b){
  System.out.println("a AND b: " + (a && b));
  System.out.println("a OR b: " + (a || b));
  System.out.println("NOT a: " + (!a));
}

Additionally, ^ is used for XOR and == is used for "equal to" (a.k.a. bidirectional implication).

JavaScript

function logic(a,b) {
  print("a AND b: " + (a && b));
  print("a OR b: " + (a || b));
  print("NOT a: " + (!a));
}

Liberty BASIC

There is no truly Boolean type. 0 = false, nonzero = true. A true value is ANY value not zero, but is usually considered to be either "1" or "-1".

 
False =0
True  =not( False)
 
print " True ="; True, "False ="; False, "NB True here shown as -1"
print
 
print " a   b    AND  OR   XOR"
a =0: b =0: print " "; a; "   "; b; "     "; a and b; "    "; a or  b; "    "; a xor b
a =0: b =1: print " "; a; "   "; b; "     "; a and b; "    "; a or  b; "    "; a xor b
a =1: b =0: print " "; a; "   "; b; "     "; a and b; "    "; a or  b; "    "; a xor b
a =1: b =1: print " "; a; "   "; b; "     "; a and b; "    "; a or  b; "    "; a xor b
 
end
 

True =-1     False =0      NB True here shown as -1
.
a   b    AND  OR   XOR
0   0     0    0    0
0   1     0    1    1
1   0     0    1    1
1   1     1    1    0

Logo

The boolean literals are used as words ("true and "false) when used in a program.

to logic :a :b
  (print [a AND b =] and :a :b)
  (print [a OR b =] or :a :b)
  (print [NOT a =] not :a)
end

AND and OR may have arity greater than two if used in parentheses (and :a :b :c).

Lua

 
function logic(a,b)
  return a and b, a or b, not a
end
 

M4

define(`logical',
   `and($1,$2)=eval($1&&$2)  or($1,$2)=eval($1||$2)  not($1)=eval(!$1)')
logical(1,0)

Output:

and(1,0)=0  or(1,0)=1  not(1)=0

Mathematica

And[a,b,...]
Or[a,b,...]
Not[a]

And can also be given using the infix operator &&, Or can also be used using the infix operator ||. Not[a] can also be written as !a. Furthermore Mathematica supports:

Xor[a, b,...]
Nand[a, b,...]
Nor[a, b,...]
Xnor[a, b,...]

Note that the functions are not restricted to 2 arguments; any number of arguments are allowed (except for the function Not). All these functions can also be used with infix operators, the characters for that are: \[Xor], \[Nand], \[Nor], and \[Xnor]. Or by typing [escape] [name boolean operator] [escape].

Maxima

f(a, b) := [not a, a or b, a and b];
 
/* to use multiple arguments, use any of these */
a and b and c and d;
a or b or c or d;
"and"(a, b, c, d);
"or"(a, b, c, d);
apply("and", [a, b, c, d]);
apply("or", [a, b, c, d]);

MAXScript

fn printLogic a b =
(
    format "a and b is %\n" (a and b)
    format "a or b is %\n" (a or b)
    format "not a is %\n" (not a)
)

Metafont

def tf(expr a) = if a: "true" else: "false" fi enddef;
def test(expr a, b) =
  for o = "and", "or":
    message tf(a) & " " & o & " " & tf(b);
    show a scantokens(o) b;
  endfor
  message "not " & tf(a);
  show not a enddef;

test(true, true);
test(false, false);
test(true, false);
test(false, true);
end

Modula-3

MODULE Logical EXPORTS Main;
 
FROM IO IMPORT Put;
FROM Fmt IMPORT Bool;
 
PROCEDURE Test(a, b: BOOLEAN) =
  BEGIN
    Put("a AND b is " & Bool(a AND b) & "\n");
    Put("a OR b is " & Bool(a OR b) & "\n");
    Put("NOT a is " & Bool(NOT a) & "\n");
  END Test;
 
BEGIN
  Test(TRUE, FALSE);
END Logical.

MUMPS

 
LOGIC(A,B)
 WRITE !,A," AND ",B," IS ",A&B
 WRITE !,A," OR  ",B," IS ",A!B
 WRITE !,"NOT ",A," AND ",B," IS ",'(A)&B
 WRITE !,"NOT ",A," OR ",B," IS ",'(A)!B
 

Nemerle

using System;
using System.Console;
 
module Logical
{
    WriteLogical(a : bool, b : bool) : void
    {
        WriteLine("{0} and {1} is {2}", a, b, a && b);
        WriteLine("{0} or {1} is {2}", a, b, a || b);
        WriteLine("not {0} is {1}", a, !a);
    }
 
    Main() : void {WriteLogical(true, false)}
}

Or, if you prefer keywords to operators import the Nemerle.English namespace to use and, or, and not.

NetRexx

/* NetRexx */
options replace format comments java crossref symbols binary
 
runSample(arg)
return
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method logicalOperation(xL = boolean, xR = boolean) public static
  say showBool(xL) 'AND' showBool(xR) '=' showBool(xL &  xR) -- AND
  say showBool(xL) 'OR ' showBool(xR) '=' showBool(xL |  xR) -- OR
  say showBool(xL) 'XOR' showBool(xR) '=' showBool(xL && xR) -- XOR
  say '     '      'NOT' showBool(xL) '=' showBool(\xL)      -- NOT
  say
  return
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method showBool(bb = boolean) public static
  if bb then bt = 'true '
  else       bt = 'false'
  return bt
 
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
method runSample(arg) private static
  TRUE_  = (1 == 1)
  FALSE_ = \TRUE_ 
  lpairs = [ -
    [TRUE_,  TRUE_ ], -
    [TRUE_,  FALSE_], -
    [FALSE_, TRUE_ ], -
    [FALSE_, FALSE_]  -
  ]
  loop lx = 0 to lpairs.length - 1
    lpair = lpairs[lx]
    --say showBool(lpair[0]) showBool(lpair[1])
    logicalOperation(lpair[0], lpair[1])
    end lx
  return
 

Output:

true  AND true  = true 
true  OR  true  = true 
true  XOR true  = false
      NOT true  = false

true  AND false = false
true  OR  false = true 
true  XOR false = true 
      NOT true  = false

false AND true  = false
false OR  true  = true 
false XOR true  = true 
      NOT false = true 

false AND false = false
false OR  false = false
false XOR false = false
      NOT false = true

NewLISP

 
(define (logic a b)
		(print "a and b is: " (and a b) "\n a or b is: " (or a b))
		(print "\n not a is: " (not a))) 
 
 

Objeck

 
bundle Default {
  class Logic {
    function : Main(args : String[]) ~ Nil {
      a := true;
      b := false;
      IO.Console->GetInstance()->Print("a and b is: ")->PrintLine(a & b);
      IO.Console->GetInstance()->Print("a or b is: ")->PrintLine(a | b);
      IO.Console->GetInstance()->Print("not a is: ")->PrintLine(a <> true);
    }
  }
}
 

OCaml

let print_logic a b =
  Printf.printf "a and b is %B\n" (a && b);
  Printf.printf "a or b is %B\n" (a || b);
  Printf.printf "not a is %B\n" (not a)

Octave

function test(a, b)
  s1 = num2str(a);
  s2 = num2str(b);
  disp(strcat(s1, " and ", s2, " = ", num2str(a&&b)));
  disp(strcat(s1, " or ", s2, " = ", num2str(a||b)));
  disp(strcat("not ", s1, " = ", num2str(!a)));
endfunction
 
% constant true is 1, false is 0
test(true, true);
test(false, false);
test(true, false);
test(false, true);

OpenEdge/Progress

The logical data type can have three values: true, false or unknown (represented by question mark).

FUNCTION testLogical RETURNS CHAR (
   i_l1 AS LOGICAL,
   i_l2 AS LOGICAL
):
 
   RETURN 
      SUBSTITUTE( '&1 and &2:  &3', i_l1, i_l2, i_l1 AND i_l2 ) + '~n' +
      SUBSTITUTE( '&1 or &2:  &3', i_l1, i_l2, i_l1 OR i_l2 )  + '~n' +
      SUBSTITUTE( 'not &1:  &2', i_l1, NOT i_l1 )
      .
 
END FUNCTION.

MESSAGE 
   testLogical( FALSE, FALSE ) SKIP(1)
   testLogical( FALSE, TRUE ) SKIP(1)
   testLogical( TRUE, FALSE ) SKIP(1)
   testLogical( TRUE, TRUE ) SKIP(2)
 
   testLogical( ?, ? ) SKIP(1)
   testLogical( ?, FALSE ) SKIP(1)
   testLogical( ?, TRUE ) SKIP(1)
VIEW-AS ALERT-BOX.

Output

---------------------------
Message (Press HELP to view stack trace)
---------------------------
no and no:  no
no or no:  no
not no:  yes 

no and yes:  no
no or yes:  yes
not no:  yes 

yes and no:  no
yes or no:  yes
not yes:  no 

yes and yes:  yes
yes or yes:  yes
not yes:  no 


? and ?:  ?
? or ?:  ?
not ?:  ? 

? and no:  no
? or no:  ?
not ?:  ? 

? and yes:  ?
? or yes:  yes
not ?:  ? 

---------------------------
OK   Help   
---------------------------

Oz

proc {PrintLogic A B}
   %% using not short-circuiting standard library functions
   {Show {And A B}}
   {Show {Or A B}}
   {Show {Not A}}
 
   %% using short-circuiting keywords
   {Show A andthen B}
   {Show A orelse B}
end

PARI/GP

Note that the forms bitand(), bitor(), bitneg(), and bitxor() also exist. These apply the operator to each bit and do not short-circuit, unlike the below.

logic(a,b)={
  print(a&b); \\ && is the same
  print(a|b); \\ || is the same
  print(!a);
};

Pascal

procedure printlogic(a, b: boolean);
 begin
  writeln('a and b is ', a and b);
  writeln('a or b is ', a or b);
  writeln('not a is', not a);
 end;

Perl

sub show_bool
{
        return shift() ? 'true' : 'false', "\n";
}
 
sub test_logic
{
        my ($a, $b) = @_;
        print "a and b is ", show_bool $a && $b;
        print "a or b is ", show_bool $a || $b;
        print "not a is ", show_bool !$a;
        print "a xor b is ", show_bool($a xor $b);
}

There are also and, or, and not operators. These are just like &&, ||, and ! (respectively) except for their precedences, which are much lower.

Perl 6

Perl 6 has an abundance of logical operators for various purposes.

sub logic($a,$b) {
    say "$a && $b is ", $a && $b;     # short-circuiting
    say "$a || $b is ", $a || $b;     # short-circuiting
    say "$a ^^ $b is ", $a ^^ $b;
    say "!$a is ",     !$a;
 
    say "$a ?& $b is ", $a ?& $b;     # non-short-circuiting
    say "$a ?| $b is ", $a ?| $b;     # non-short-circuiting
    say "$a ?^ $b is ", $a ?^ $b;     # non-short-circuiting
 
    say "$a +& $b is ", $a +& $b;     # numeric bitwise
    say "$a +| $b is ", $a +| $b;     # numeric bitwise
    say "$a +^ $b is ", $a +^ $b;     # numeric bitwise
 
    say "$a ~& $b is ", $a ~& $b;     # buffer bitwise
    say "$a ~| $b is ", $a ~| $b;     # buffer bitwise
    say "$a ~^ $b is ", $a ~| $b;     # buffer bitwise
 
    say "$a & $b is ", $a & $b;       # junctional/autothreading
    say "$a | $b is ", $a | $b;       # junctional/autothreading
    say "$a ^ $b is ", $a ^ $b;       # junctional/autothreading
 
    say "$a and $b is ", ($a and $b); # loose short-circuiting
    say "$a or $b is ",  ($a or $b);  # loose short-circuiting
    say "$a xor $b is ", ($a xor $b);
    say "not $a is ",    (not $a);
}
 
logic(3,10);

Output:

3 && 10 is 10
3 || 10 is 3
3 ^^ 10 is 
!3 is 0
3 ?& 10 is 1
3 ?| 10 is 1
3 ?^ 10 is 0
3 +& 10 is 2
3 +| 10 is 11
3 +^ 10 is 9
3 ~& 10 is 1
3 ~| 10 is 30
3 ~^ 10 is 30
3 & 10 is all(3, 10)
3 | 10 is any(3, 10)
3 ^ 10 is one(3, 10)
3 and 10 is 10
3 or 10 is 3
3 xor 10 is 
not 3 is 0

PHP

function print_logic($a, $b)
{
    echo "a and b is ", $a && $b ? 'True' : 'False', "\n";
    echo "a or b is ", $a || $b ? 'True' : 'False', "\n";
    echo "not a is ", ! $a ? 'True' : 'False', "\n";
}

PicoLisp

(de logic (A B)
   (prin "A AND B is ")
   (println (and A B))
   (prin "A OR B is ")
   (println (or A B))
   (prin "A XOR B is ")
   (println (xor A B))
   (prin "NOT A is ")
   (println (not A)) )

PL/I

 
logical_ops: procedure (t, u);
   declare (t, u) bit (1);
 
   put skip list (t & u);
   put skip list (t | u); /* logical or   */
   put skip list (^t);    /* logical not  */
   put skip list (t ^ u); /* exclusive or */
end logical_ops;
 

Pop11

define print_logic(a, b);
    printf(a and b, 'a and b is %p\n');
    printf(a or b, 'a or b is %p\n');
    printf(not(a), 'not a is %p\n');
enddefine;

Example usage is:

print_logic(true, false);

PostScript

 
/logical{
/a exch def
/b exch def
a b and =
a b or =
a not =
}def
 

PowerShell

function Test-Boolean ([bool] $a, [bool] $b) {
    Write-Host "A and B:   " ($a -and $b)
    Write-Host "A or B:    " ($a -or $b)
    Write-Host "not A:     " (-not $a)
    Write-Host "not A:     " (!$a)
    Write-Host "A xor B:   " ($a -xor $b)
}

PureBasic

Procedure LogicDebug(a,b)
  Debug a And b
  Debug a Or b
  Debug Not a
  Debug a XOr b
EndProcedure

Python

def logic(a, b):
        print 'a and b:', a and b
        print 'a or b:' , a or b
        print 'not a:'  , not a

Note: Any normal object can be treated as a Boolean in Python. Numeric objects which evaluate to any non-zero value are "True" otherwise they are false. Non-empty strings, lists, tuples and other sequences are "True" otherwise they are false. The pre-defined None object is also treated as "False." In Python 2.3 pre-defined objects named True and False were added to the language; prior to that it was a common convention to include a line: False, True = 0, 1 to use these as names. Custom classes which implement __nonzero__ or __len__ or some other special methods can be implicitly evaluated as Booleans based on those results.

R

logic <- function(a, b) {
  print(a && b)
  print(a || b)
  print(! a)
}
 
logic(TRUE, TRUE)
logic(TRUE, FALSE)
logic(FALSE, FALSE)

Racket

#lang racket
 
(define (logic a b)
  (displayln (format "a and b equals ~a" (and a b)))
  (displayln (format "a or b equals ~a" (or a b)))
  (displayln (format "not a equals ~a" (not a)))
  (displayln (format "a nand b equals ~a" (nand a b)))
  (displayln (format "a nor b equals ~a" (nor a b)))
  (displayln (format "a implies b equals ~a" (implies a b)))
  (displayln (format "a xor b equals ~a" (xor a b))))

Rascal

import IO;
 
public void logic(bool a, bool b){
	println("a and b, is <a && b>");
	println("a or b, is <a || b>");
	println("a equivalent to b, is <a <==> b>");
	println("a implies b, is <a ==> b>");
	println("not a", <!a>");
}

Output:

rascal>logic(false, false);
 
a and b, is false
a or b, is false
a equivalent to b, is true
a implies b, is true
not a, true
ok

REBOL

logics: func [a [logic!] b [logic!]] [
    print ['and tab a and b]
    print ['or  tab a or  b]
    print ['not tab   not a]
    print ['xor tab a xor b]
 
    print ['and~ tab and~ a b]
    print ['or~  tab or~  a b]
    print ['xor~ tab xor~ a b]
 
    print ['any tab any [a b]]
    print ['all tab all [a b]]
]

Example:

>> logics true false
and      false
or       true
not      false
xor      true
and~     false
or~      true
xor~     true
any      true
all      none

Retro

: .bool ( f- ) [ "true" ] [ "false" ] if puts cr ;
: logic ( ab- )
 "\na = "  puts over .bool "b = " puts dup .bool
 "\na and b = " puts 2dup and .bool
 "\na  or b = " puts over  or .bool
 "\nnot a = " puts not .bool ;

REXX

The REXX language's boolean values are well formed: 1 (true), and 0 (false).

Any other values will raise a REXX syntax condition (error).

/*REXX program to show some binary  (AKA  bit  or logical)  operations. */
x=1;   y=0
    /*═════════════════════════════════════════════════echo   X,Y values*/
call TT 'name', "value"
call TT 'x'   ,    x
call TT 'y'   ,    y
    /*═════════════════════════════════════════════════negate X,Y values*/
call TT 'name', "negated"
call TT 'x'   ,   \x                 /*some REXXes support the  ¬  char.*/
call TT 'y'   ,   \y
    /*═════════════════════════════════════════════════AND    X,Y values*/
call TT 'value','value',"AND";   do    x=0 to 1
                                    do y=0 to 1;  call TT x,y, x & y;  end
                                 end
    /*═════════════════════════════════════════════════OR     X,Y values*/
call TT 'value','value',"OR";    do    x=0 to 1
                                    do y=0 to 1;  call TT x,y, x | y;  end
                                 end
    /*═════════════════════════════════════════════════XOR    X,Y values*/
call TT 'value','value',"XOR";   do   x=0 for 2
                                   do y=0 for 2;  call TT x,y, x && y; end
                                 end
exit                                   /*stick a fork in it, we're done.*/
/*──────────────────────────────────TT subroutine───────────────────────*/
TT: parse arg a.1,a.2,a.3,a.4;  hdr=length(a.1)\==1; if hdr then say;  w=7
         do TT=0 to hdr;    _=
               do k=1 for arg();     _=_ center(a.k,w);     end   /*k*/
         say _
         a.=copies('─',w)
         end   /*TT*/
return

output

  name    value
 ─────── ───────
    x       1
    y       0

  name   negated
 ─────── ───────
    x       0
    y       1

  value   value    AND
 ─────── ─────── ───────
    0       0       0
    0       1       0
    1       0       0
    1       1       1

  value   value    OR
 ─────── ─────── ───────
    0       0       0
    0       1       1
    1       0       1
    1       1       1

  value   value    XOR
 ─────── ─────── ───────
    0       0       0
    0       1       1
    1       0       1
    1       1       0

RLaB

RLaB allows for standard logic operations. and/or/not are synonymous with &&/||/!. In the case when the argument is a real number (default type of argument) the default statement in the absence of if command is is the argument non-zero. Therefore

 
>> x = 5
5
>> y = 0
0
>> !x
0
>> !y
1
>> x && y
0
 

However, if arguments to the functions are of the type integer then the functions operate bit-wise.

 
>> x = int(5)
5
>> y = int(0)
0
>> !x
-6
>> !y
-1
>> x && y
0
 

Ruby

def logic(a, b)
        print 'a and b: ', a && b, "\n"
        print 'a or b: ' , a || b, "\n"
        print 'not a: '  , !a    , "\n"
end

and/or/not are synonymous with &&/||/! albeit with lower precedence.

Scala

In vanilla Scala:

def logical(a: Boolean, b: Boolean): Unit = {
  println("and: " + (a && b))
  println("or:  " + (a || b))
  println("not: " + !a)
}
 
logical(true, false)

With Scalaz:

def logical(a: Boolean, b: Boolean): IO[Unit] = for {
  _ <- putStrLn("and: " ++ (a && b).shows)
  _ <- putStrLn("or:  " ++ (a || b).shows)
  _ <- putStrLn("not: " ++ (!a).shows)
} yield ()
 
logical(true, false).unsafePerformIO

Scheme

(define (logic a b)
  (display "a and b is ")
  (display (and a b))
  (newline)
  (display "a or b is ")
  (display (or a b))
  (newline)
  (display "not a is ")
  (display (not a))
  (newline))

Seed7

const proc: writeLogic (in boolean: a, in boolean: b) is func
  begin
    writeln("a and b is " <& a and b);
    writeln("a or b is " <& a or b);
    writeln("not a is " <& not a);
  end func;

Slate

Some lines in this example are too long (more than 80 characters). Please fix the code if it's possible and remove this message.

{#/\. #\/. #not} do: [ |:func|
  func arity = 1 ifTrue: [inform: 'True ' ; (func as: String) ; ' = ' ; (func sendTo: {True}) printString.
                          inform: 'False ' ; (func as: String) ; ' = ' ; (func sendTo: {False}) printString.].
 
  func arity = 2 
    ifTrue: [{{True. True}. {True. False}. {False. True}. {False. False}} do:
              [ |:each| inform: each first printString ; (func as: String) ; each second printString ; ' = ' ; (func sendTo: each) printString]]
 
].

Output:

True/\True = True
True/\False = False
False/\True = False
False/\False = False
True\/True = True
True\/False = True
False\/True = True
False\/False = False
True not = False
False not = True

Smalltalk

Works with: GNU Smalltalk

Works with: Smalltalk/X

|test|
test := [ :a :b |
  ('%1 %2 %3 = %4' % { a. 'and'. b. (a & b) }) displayNl.
  ('%1 %2 %3 = %4' % { a. 'or'. b. (a | b) }) displayNl.
  ('%1 %2 = %3' % {'not'. a. (a not) }) displayNl
].
 
test value: true value: true.
test value: false value: false.
test value: true value: false.
test value: false value: true.

Works with: Smalltalk/X

a implies: b
a xor: b

Standard ML

fun print_logic (a, b) = (
  print ("a and b is " ^ Bool.toString (a andalso b) ^ "\n");
  print ("a or b is " ^ Bool.toString (a orelse b) ^ "\n");
  print ("not a is " ^ Bool.toString (not a) ^ "\n")
)

Tcl

proc logic {a b} {
    puts "a and b: [expr {$a && $b}]"
    puts "a or b:  [expr {$a || $b}]"
    puts "not a:   [expr {!$a}]"
}

Toka

This is an adaption of the code from the Forth example. Toka provides TRUE/FALSE flags that are the same as the well-formed flags in Forth.

[ 0 <> [ ." true" ] [ ." false"] ifTrueFalse ] is .bool
[ ( a b -- )
  cr ." a = " over .bool ."   b = " dup .bool
  cr ." a and b = " 2dup and .bool
  cr ." a  or b = " over  or .bool
  cr ." not a = " 0 = .bool
] is logic

V

Using stack shuffles.

[mylogic
  [get2 [dup] dip swap [dup] dip].
   get2 and puts
   get2 or puts
   swap not puts
   pop
 ].

Using view.

[mylogic
   [get2 [a b : a b a b] view].
   get2 and puts
   get2 or puts
   swap not puts
   pop
 ].

Using internal defines

[mylogic [a b] let
  a b and puts
  a b or puts
  a not puts
].

Visual Basic .NET

Function Test(ByVal a As Boolean, ByVal b As Boolean)
    Console.WriteLine("And " & a And b)
    Console.WriteLine("Or " & a Or b)
    Console.WriteLine("Not " & Not a)
    Console.WriteLine("Xor " & a Xor b)
    Console.WriteLine("And, short-circuited " & a AndAlso b)
    Console.WriteLine("Or, short-circuited " & a OrElse b)
End Function

XPL0

Logical operations and bitwise operations are the same. The command word 'false' = 0 and 'true' = -1. These values are produced by comparison operations, such as A>=B. Any integer not equal to zero is considered true. Real numbers cannot be used as booleans. Symbols can be used instead: & = and, ! = or, ~ = not, | = xor. Note that not 1, which is true, is $FFFFFFFE, which is also true. Despite this, it's simple and convenient to combine logical and bitwise operations.

include c:\cxpl\codes;          \intrinsic 'code' declarations
 
func Logic(A, B);
int  A, B;
[HexOut(0, A and B);  ChOut(0, ^ );
 HexOut(0, A or  B);  ChOut(0, ^ );
 HexOut(0, not A);    ChOut(0, ^ );
 HexOut(0, A xor B);
]; \Logic
 
[Logic(false, false); CrLf(0);
 Logic(true, false);  CrLf(0);
 Logic(true, true);   CrLf(0);
 Logic(1, 1);   CrLf(0);
 Logic(1, 2);   CrLf(0);
]

Output:

00000000 00000000 FFFFFFFF 00000000
00000000 FFFFFFFF 00000000 FFFFFFFF
FFFFFFFF FFFFFFFF 00000000 00000000
00000001 00000001 FFFFFFFE 00000000
00000000 00000003 FFFFFFFE 00000003

XSLT

<xsl:template name="logic">
  <xsl:param name="a" select="true()"/>
  <xsl:param name="b" select="false()"/>
  <fo:block>a and b = <xsl:value-of select="$a and $b"/></fo:block>
  <fo:block>a or b = <xsl:value-of select="$a or $b"/></fo:block>
  <fo:block>not a = <xsl:value-of select="not($a)"/></fo:block>

</xsl:template>