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 |
Comparison |
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.
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.
<lang ada>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;</lang>
Aikido
<lang aikido> function logic(a,b) {
println("a AND b: " + (a && b))
println("a OR b: " + (a || b))
println("NOT a: " + (!a))
} </lang>
Aime
<lang 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');
}</lang>
ALGOL 68
<lang algol68>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); 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)
)</lang>
AutoHotkey
<lang AutoHotkey>a = 1 b = 0 msgbox % "a and b is " . (a && b) msgbox % "a or b is " . (a || b) msgbox % "not a is " . (!a)</lang>
AWK
<lang 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</lang>
BASIC
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
Brat
<lang brat>logic = { a, b |
p "a and b: #{ a && b }"
p "a or b: #{ a || b }"
p "not a: #{ not a }"
}</lang>
C
<lang 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);
}</lang>
C++
<lang cpp>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";
}</lang>
C#
<lang csharp>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);
}
}
}</lang>
Clojure
<lang 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) </lang>
ColdFusion
<lang cfm><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></lang>
Common Lisp
<lang 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)))</lang>
D
<lang 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);
}</lang>
- 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
<lang 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.</lang>
Output:
a = TRUE b = FALSE a AND b: FALSE a OR b: TRUE NOT a: FALSE a XOR b: TRUE
DWScript
<lang Delphi>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);</lang>
Output:
a = True b = False a AND b: False a OR b: True NOT a: False a XOR b: True
E
<lang e>def logicalOperations(a :boolean, b :boolean) {
return ["and" => a & b,
"or" => a | b,
"not" => !a,
"xor" => a ^ b]
}</lang>
Each of these is a method on boolean objects; the above is precisely equivalent to:
<lang e>def logicalOperations(a :boolean, b :boolean) {
return ["and" => a.and(b),
"or" => a.or(b),
"not" => a.not(),
"xor" => a.xor(b)]
}</lang>
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
<lang 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)
} </lang>
Erlang
<lang 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</lang>
Euphoria
<lang 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</lang>
Factor
<lang factor>: logical-operators ( a b -- )
{
[ "xor is: " write xor . ]
[ "and is: " write and . ]
[ "or is: " write or . ]
[ "not is: " write drop not . ]
} 2cleave ;</lang>
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. <lang false>1 3=~["unequal, "]? 1 1= 1_=["true is -1, "]? 0~["false is 0, "]? 'm$'a>'z@>&["a < m < z"]?</lang>
Fantom
<lang 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)
}
}
}
} </lang>
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). <lang forth>: .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 ;</lang>
Fortran
In ANSI FORTRAN 66 or later, use LOGICAL data type: <lang fortran> 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</lang>
GAP
<lang 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 ]</lang>
gecho
<lang gecho>3 4 and</lang> 3&&4 <lang gecho>1 2 or</lang> 1||2
Go
<lang 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)
}</lang> Other operators that work on type bool are == and !=. == corresponds to the logical operation of equivalence. != corresponds to exclusive or.
Groovy
<lang 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} """ }</lang>
Program: <lang groovy>logical(true, true) logical(true, false) logical(false, false) logical(false, true)</lang>
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:
<lang haskell>a = False b = True
a_and_b = a && b a_or_b = a || b not_a = not a</lang>
HicEst
No logical variables. Nonzero is true, zero is false in logical expressions: <lang hicest> x = value1 /= 0
y = value2 /= 0 NOTx = x == 0 xANDy = x * y xORy = x + y /= 0 EOR = x /= y </lang>
Io
<lang 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)
)</lang>
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. <lang Icon>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</lang>
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.
<lang j> aon=: *.`+.`(-.@[)`:0</lang>
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).
<lang j>
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</lang>
Java
<lang 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));
}</lang>
Additionally, ^ is used for XOR and == is used for "equal to" (a.k.a. bidirectional implication).
JavaScript
<lang javascript>function logic(a,b) {
print("a AND b: " + (a && b));
print("a OR b: " + (a || b));
print("NOT a: " + (!a));
}</lang>
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". <lang lb> 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 </lang>
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. <lang logo>to logic :a :b
(print [a AND b =] and :a :b) (print [a OR b =] or :a :b) (print [NOT a =] not :a)
end</lang>
AND and OR may have arity greater than two if used in parentheses (and :a :b :c).
Lua
<lang lua> function logic(a,b)
return a and b, a or b, not a
end </lang>
M4
<lang m4>define(`logical',
`and($1,$2)=eval($1&&$2) or($1,$2)=eval($1||$2) not($1)=eval(!$1)')
logical(1,0)</lang>
Output:
and(1,0)=0 or(1,0)=1 not(1)=0
Mathematica
<lang Mathematica>And[a,b,...] Or[a,b,...] Not[a]</lang> 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: <lang Mathematica>Xor[a, b,...] Nand[a, b,...] Nor[a, b,...] Xnor[a, b,...]</lang> 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].
MAXScript
<lang 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)
)</lang>
Metafont
<lang 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;</lang>
<lang metafont>test(true, true); test(false, false); test(true, false); test(false, true); end</lang>
Modula-3
<lang modula3>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.</lang>
MUMPS
<lang 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
</lang>
Nemerle
<lang 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)}
}</lang> Or, if you prefer keywords to operators import the Nemerle.English namespace to use and, or, and not.
NewLISP
<lang 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)))
</lang>
Objeck
<lang 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);
}
}
} </lang>
OCaml
<lang 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)</lang>
Octave
<lang 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);</lang>
OpenEdge/Progress
The logical data type can have three values: true, false or unknown (represented by question mark).
<lang progress>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.</lang> <lang progress>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.</lang>
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
<lang 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</lang>
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.
<lang parigp>logic(a,b)={
print(a&b); \\ && is the same print(a|b); \\ || is the same print(!a);
};</lang>
Pascal
<lang 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;</lang>
Perl
<lang 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);
}</lang>
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. <lang perl6>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);</lang> Output: <lang>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</lang>
PHP
<lang 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";
}</lang>
PicoLisp
<lang 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)) )</lang>
PL/I
<lang PL/I> logical_ops: procedure (t, u);
declare (t, u) bit (1);
put skip list (a & b); put skip list (a | b); put skip list (^a); /* logical not */ put skip list (a ^ b); /* exclusive or */
end logical_ops; </lang>
Pop11
<lang 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;</lang>
Example usage is: <lang pop11>print_logic(true, false);</lang>
PostScript
<lang postscript> /logical{ /a exch def /b exch def a b and = a b or = a not = }def </lang>
PowerShell
<lang 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)
}</lang>
PureBasic
<lang PureBasic>Procedure LogicDebug(a,b)
Debug a And b Debug a Or b Debug Not a Debug a XOr b
EndProcedure</lang>
Python
<lang python>def logic(a, b):
print 'a and b:', a and b
print 'a or b:' , a or b
print 'not a:' , not a</lang>
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
<lang R>logic <- function(a, b) {
print(a && b) print(a || b) print(! a)
}
logic(TRUE, TRUE) logic(TRUE, FALSE) logic(FALSE, FALSE)</lang>
REBOL
<lang 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]]
]</lang>
Example:
>> logics true false and false or true not false xor true and~ false or~ true xor~ true any true all none
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
<lang RLaB>
>> x = 5
5
>> y = 0
0
>> !x
0
>> !y
1
>> x && y
0
</lang>
However, if arguments to the functions are of the type integer then the functions operate bit-wise. <lang RLaB> >> x = int(5) 5 >> y = int(0) 0 >> !x -6 >> !y -1 >> x && y 0 </lang>
Retro
<lang 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 ;</lang>
REXX
<lang rexx> /*REXX program to show some binary (bit) operations. */
aaa=1 bbb=0
say 'a='aaa " should be 1" say 'b='bbb " should be 0" say
yand=aaa & bbb say 'ANDing a with b:' yand
yor=aaa | bbb
say ' ORing a with b:' yor
yxor=aaa && bbb say 'XORing a with b:' yxor say
do aaa=0 to 1 do bbb=0 to 1 say 'a='aaa " b="bbb ' AND=' (aaa & bbb) end end
say
do aaa=0 to 1 do bbb=0 to 1 say 'a='aaa " b="bbb ' OR=' (aaa | bbb) end end
say
do aaa=0 to 1 do bbb=0 to 1 say 'a='aaa " b="bbb ' XOR=' (aaa && bbb) end end
</lang> Output:
a=1 should be 1 b=0 should be 0 ANDing a with b: 0 ORing a with b: 1 XORing a with b: 1 a=0 b=0 AND= 0 a=0 b=1 AND= 0 a=1 b=0 AND= 0 a=1 b=1 AND= 1 a=0 b=0 OR= 0 a=0 b=1 OR= 1 a=1 b=0 OR= 1 a=1 b=1 OR= 1 a=0 b=0 XOR= 0 a=0 b=1 XOR= 1 a=1 b=0 XOR= 1 a=1 b=1 XOR= 0
Ruby
<lang 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</lang>
and/or/not are synonymous with &&/||/! albeit with lower precedence.
Scala
In vanilla Scala: <lang scala>def logical(a: Boolean, b: Boolean): Unit = {
println("and: " + (a && b))
println("or: " + (a || b))
println("not: " + !a)
}
logical(true, false)</lang>
With Scalaz: <lang scala>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</lang>
Scheme
<lang 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))</lang>
Seed7
<lang 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;</lang>
Slate
<lang slate>{#/\. #\/. #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]]
].</lang>
Output:
<lang slate>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</lang>
Smalltalk
<lang smalltalk>|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.</lang>
Standard ML
<lang sml>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")
)</lang>
Tcl
<lang tcl>proc logic {a b} {
puts "a and b: [expr {$a && $b}]"
puts "a or b: [expr {$a || $b}]"
puts "not a: [expr {!$a}]"
}</lang>
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.
<lang toka>[ 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</lang>
V
Using stack shuffles.
<lang v>[mylogic
[get2 [dup] dip swap [dup] dip]. get2 and puts get2 or puts swap not puts pop ].</lang>
Using view. <lang v>[mylogic
[get2 [a b : a b a b] view]. get2 and puts get2 or puts swap not puts pop ].</lang>
Using internal defines
<lang v>[mylogic [a b] let
a b and puts a b or puts a not puts
].</lang>
Visual Basic .NET
<lang vbnet>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</lang>
XSLT
<lang xml><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></lang> </xsl:template>
- Programming Tasks
- Basic Data Operations
- Ada
- Aikido
- Aime
- ALGOL 68
- AutoHotkey
- AWK
- BASIC
- Brat
- C
- C++
- C sharp
- Clojure
- ColdFusion
- Common Lisp
- D
- Delphi
- DWScript
- E
- Efene
- Erlang
- Euphoria
- Factor
- FALSE
- Fantom
- Forth
- Fortran
- GAP
- Gecho
- Go
- Groovy
- Haskell
- HicEst
- Io
- Icon
- Unicon
- J
- Java
- JavaScript
- Liberty BASIC
- Logo
- Lua
- M4
- Mathematica
- MAXScript
- Metafont
- Modula-3
- MUMPS
- Nemerle
- NewLISP
- Objeck
- OCaml
- Octave
- OpenEdge/Progress
- Oz
- PARI/GP
- Pascal
- Perl
- Perl 6
- PHP
- PicoLisp
- PL/I
- Pop11
- PostScript
- PowerShell
- PureBasic
- Python
- R
- REBOL
- RLaB
- Retro
- REXX
- Ruby
- Scala
- Scheme
- Seed7
- Slate
- Slate examples needing attention
- Examples needing attention
- Smalltalk
- Standard ML
- Tcl
- Toka
- V
- Visual Basic .NET
- XSLT