Logical operations: Difference between revisions

 

=={{header|11l}}==

print(‘a and b: ’(a & b))

print(‘a or b: ’(a | b))

 

=={{header|360 Assembly}}==

</pre>

<br>An example:

LOGICAL CSECT

USING LOGICAL,R15

PG DC CL80' '

YREGS

{{out}}

<pre>

FALSE

</pre>

 

=={{header|ACL2}}==

 

(progn$ (cw "(and a b) = ~x0~%" (and a b))

(cw "(or a b) = ~x0~%" (or a b))

<br><br>

 

=={{header|Action!}}==

IF a=0 THEN

RETURN (1)

OD

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Logical_operations.png Screenshot from Atari 8-bit computer]

providing a direct link between logical and bitwise operations.

 

begin

Put_Line("A and B is " & Boolean'Image(A and B));

Put_Line("A xor B is " & Boolean'Image(A xor B));

Put_Line("not A is " & Boolean'Image(not A));

 

=={{header|Agda}}==

 

 

 

test : Bool → Bool → Bool × Bool × Bool

 

e.g.

 

test true false ⇒ false , true , false

 

=={{header|Aikido}}==

 

function logic(a,b) {

println("a AND b: " + (a && b))

println("NOT a: " + (!a))

}

 

=={{header|Aime}}==

 

out(integer a, integer b)

{

o_integer(!a);

o_byte('\n');

 

=={{header|ALGOL 68}}==

 

(

# for a 6-7 bit/byte compiler #

printf(($"not a is "gl$, ¬ a)

printf(($"a not equivalent to b is "gl$, a ≠ b)

 

=={{header|ALGOL W}}==

begin

 

write( a, " equ ", b, ": ", a = b );

 

 

=={{header|Amazing Hopper}}==

#include <hopper.h>

 

 

exit(0)

{{out}}

<pre>

 

=={{header|Apex}}==

boolean b = false;

System.Debug('a AND b: ' + (a && b));

System.Debug('NOT a: ' + (!a));

System.Debug('a XOR b: ' + (a ^ b));

 

=={{header|APL}}==

APL represents Boolean values using 1 and 0. This function takes Boolean arguments before it and after it—which may be arrays of Booleans—and returns an array consisting of arg1 AND arg2, arg1 OR arg2, NOT arg1, arg1 NAND arg2, arg1 NOR arg2, and arg1 XOR arg2, in that order.

 

=={{header|ARM Assembly}}==

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI */

/* program logicoper.s */

 

 

 

=={{header|Arturo}}==

print ["a AND b =" and? a b]

print ["a OR b =" or? a b]

]

 

{{out}}

 

=={{header|Asymptote}}==

bool b = false;

 

write(a || b); //(with conditional evaluation of right-hand argument)

write(a ^ b);

 

=={{header|AutoHotkey}}==

b = 0

msgbox % "a and b is " . (a && b)

msgbox % "a or b is " . (a || b)

 

=={{header|Avail}}==

Avail provides logical operators to cover all possibilities of a two-argument truth table. (Hence there are 12 entries below, plus the 4 ommitted for the trivial <code>a</code>, <code>b</code>, <code>true</code>, and <code>false</code> = 2^4.)

[

a : boolean;

Print: "a xor b: " ++ “a ⊕ b”; // equivalent to a ≠ b

Print: "a biconditional b: " ++ “a ↔ b”; // equivalent to a = b

 

=={{header|AWK}}==

0 0

and:0 or:0 not:1

and:0 or:1 not:0

1 1

 

=={{header|Axe}}==

r₁→A

r₂→B

Disp "OR:",(A??B)▶Dec,i

Disp "NOT:",(A?0,1)▶Dec,i

 

Note that unlike [[TI-83 BASIC]], the "and", "or", "xor", and "not(" tokens in Axe are bitwise operators, not logical operators.

 

=={{header|BASIC}}==

==={{header|BASIC256}}===

b = false

print a and b

print a or b

print a xor b

 

==={{header|BBC BASIC}}===

PROClogic(FALSE, TRUE)

PROClogic(TRUE, FALSE)

PRINT a% " EOR " b% " = " a% EOR b% TAB(60);

PRINT " NOT " a% " = " NOT a%

{{out}}

<pre>

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

</pre>

 

==={{header|IS-BASIC}}===

110 LET B=0

120 PRINT A AND B

160 PRINT 15 BAND 4

170 PRINT 2 BOR 15

 

==={{header|QBasic}}===

{{works with|QBasic|1.1}}

No booleans in BASIC... these are integers. -1 for True 0 for False.

b2 = 0

PRINT b1 AND b2

PRINT b1 OR b2

 

==={{header|Yabasic}}===

b2 = false //value of 0

print b1 and b2

print b1 or b2

 

==={{header|QuickBASIC}}===

{{works with|QuickBasic|4.5}}

PRINT a AND b

PRINT a OR b

PRINT NOT a

 

==={{header|FreeBASIC}}===

The following program illustrates the use of these operators:

 

 

Sub logicalDemo(b1 As Boolean, b2 As Boolean)

logicalDemo b1, b2

Print "Press any key to quit"

 

{{out}}

POSIX bc has neither Boolean values nor built-in logical operations.

Thus one has to write them oneself:

 

/* And */

"not a: "

n(a)

 

{{Works with|GNU bc}}

GNU bc's extensions make this task much easier:

print "a and b: ", a && b, "\n"

print "a or b: ", a || b, "\n"

print "not a: ", !a, "\n"

 

=={{header|Bracmat}}==

In the example below, the empty string represents 'true' and <code>~</code> represents 'false'. The binary operators <code>&</code> and <code>|</code>, which normally are used as the glue between expressions such as match operations, function definitions and function calls, are used as the logical operators 'and' and 'or', respectively.

 

= x y

. '$arg:(=?x,?y)

& out$(Logic$(,~))

& out$(Logic$(~,~))

{{out}}

<pre>(x,y)=(,):

 

=={{header|Brat}}==

p "a and b: #{ a && b }"

p "a or b: #{ a || b }"

p "not a: #{ not a }"

 

=={{header|C}}==

 

{

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);

 

=={{header|C sharp|C#}}==

 

namespace LogicalOperations

}

}

 

=={{header|C++}}==

 

{

std::cout << std::boolalpha; // so that bools are written as "true" and "false"

std::cout << "a or b is " << (a || b) << "\n";

std::cout << "not a is " << (!a) << "\n";

 

=={{header|Clipper}}==

// a and b was defined as .F. (false) or .T. (true)

? a .AND. b

? .NOT. a, .NOT. b

Return Nil

 

=={{header|Clojure}}==

(defn logical [a b]

(prn (str "a and b is " (and a b)))

 

(logical true false)

 

=={{header|COBOL}}==

Logical operations in COBOL are exactly the same as [[Bitwise operations#COBOL|bitwise operations]].

PROGRAM-ID. print-logic.

 

 

GOBACK

 

=={{header|ColdFusion}}==

<cfargument name = "a" required = "yes" type = "boolean" />

<cfargument name = "a" required = "yes" type = "boolean" />

NOT 'A' is #!a#

</cfoutput>

 

=={{header|Common Lisp}}==

 

 

=={{header|D}}==

 

void logic(T, U)(T lhs, U rhs) {

logic(nullStr, emptyStr);

logic(someC, nullC);

{{out}}

<pre>'true' is of type 'bool', 'false' is of type 'bool';

 

=={{header|Dc}}==

 

[ 0=T 0 ] s!

0 1 lF x

1 0 lF x

{{out}}

<pre>

 

=={{header|Delphi}}==

 

=={{header|DWScript}}==

var b := False;

 

 

Print('a XOR b: ');

{{out}}

<pre>a = True

=={{header|Dyalect}}==

 

var b = false

print("a and b is \(a && b)")

print("a or b is \(a || b)")

 

=={{header|Déjà Vu}}==

!.( a b or a b and a b xor a b not a )

 

for a in [ false true ]:

for b in [ false true ]:

{{out}}

<pre>true true true true false false

=={{header|E}}==

 

return ["and" => a & b,

"or" => a | b,

"not" => !a,

"xor" => a ^ b]

 

Each of these is a method on [http://wiki.erights.org/wiki/Boolean boolean objects]; the above is precisely equivalent to:

 

return ["and" => a.and(b),

"or" => a.or(b),

"not" => a.not(),

"xor" => a.xor(b)]

 

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

=={{header|EasyLang}}==

 

.

 

=={{header|ECL}}==

LogicalOperations(BOOLEAN A,BOOLEAN B) := FUNCTION

ANDit := A AND B;

LogicalOperations(TRUE,TRUE);

LogicalOperations(1>2,1=1); //Boolean expressions are also valid here

 

=={{header|Efene}}==

 

io.format("~p and ~p = ~p~n", [A, B, A and B])

io.format("~p or ~p = ~p~n", [A, B, A or B])

compare_bool(false, false)

}

 

=={{header|Elena}}==

ELENA 4.x:

public program()

console.printLine("Not a is ", a.Inverted);

console.printLine("a xor b is ", a ^^ b)

{{out}}

<pre>

=={{header|Elixir}}==

Elixir also provides three boolean operators: <code>or</code>, <code>and</code> and <code>not</code>. These operators are strict in the sense that they expect a boolean (<code>true</code> or <code>false</code>) as their first argument:

false

iex(2)> false or true

true

iex(3)> not false

<code>or</code> and <code>and</code> are short-circuit operators. They only execute the right side if the left side is not enough to determine the result:

 

Besides these boolean operators, Elixir also provides <code>||</code>, <code>&amp;&amp;</code> and <code>!</code> which accept arguments of any type. For these operators, all values except <code>false</code> and <code>nil</code> will evaluate to true:

23

iex(29)> [] || false

true

iex(34)> ! 3.14

As a rule of thumb, use <code>and</code>, <code>or</code> and <code>not</code> when you are expecting booleans. If any of the arguments are non-boolean, use <code>&amp;&amp;</code>, <code>||</code> and <code>!</code>.

 

=={{header|Elm}}==

--Open cmd and elm-repl and directly functions can be created

 

--Output will be False, True and True of type Boolean!

--end

 

=={{header|Erlang}}==

false

2> false or true.

true

5> not (true and true).

 

=={{header|Euphoria}}==

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)

 

=={{header|Excel}}==

If the values are typed in cells A1 and B1, type in the following in cell C1

 

=CONCATENATE($A1, " AND ", $B1, " is ", AND($A1,$B1))

 

In D1

 

=CONCATENATE($A1, " OR ", $B1, " is ", OR($A1,$B1))

 

In E1

 

=CONCATENATE(" NOT ", $A1, " is ", NOT($A1))

 

=={{header|F Sharp|F#}}==

printfn "a and b is %b" (a && b)

printfn "a or b is %b" (a || b)

printfn "Not a is %b" (not a)

// The not-equals operator has the same effect as XOR on booleans.

 

=={{header|Factor}}==

{

[ "xor is: " write xor . ]

[ "or is: " write or . ]

[ "not is: " write drop not . ]

 

=={{header|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 1= 1_=["true is -1, "]?

0~["false is 0, "]?

 

=={{header|Fantom}}==

 

class Main

{

}

}

 

=={{header|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).

: 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

 

=={{header|Fortran}}==

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

LOGICAL A, B

PRINT *, 'a and b is ', A .AND. B

C called "exclusive or"):

PRINT *, 'a not equivalent to b is ', A .NEQV. B

 

=={{header|FunL}}==

a and b = ${a and b}

a or b = ${a or b}

""" )

 

 

{{out}}

 

=={{header|FutureBasic}}==

 

 

print

<pre>

---------------------------------------

a b and or xor nand nor

1 1 1 1 0 0 -1

 

---------------------------------------

a b && || ^^ ^& ^|

 

=={{header|GAP}}==

return [ a or b, a and b, not a ];

end;

 

Logical(false, false);

 

=={{header|gecho}}==

3&&4

1||2

 

=={{header|Genie}}==

/*

Logical operations in Genie

a:bool = bool.parse(args[1])

b:bool = bool.parse(args[2])

 

{{out}}

 

=={{header|Go}}==

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.

 

Bitwise operators come into play when you have to work with byte- or bit-level data.

// stackoverflow.com/questions/28432398/difference-between-some-operators-golang

import "fmt"

// 3 &^ 6 = 00000001 = 1

fmt.Println(3 &^ 6)

 

=={{header|Groovy}}==

println """

a AND b = ${a} && ${b} = ${a & b}

a EQV b = ${a} == ${b} = ${a == b}

"""

 

Program:

 

{{out}}

 

=={{header|Harbour}}==

// a and b was defined as .F. (false) or .T. (true)

? a .AND. b

? a .OR. b

? ! a, ! b

 

=={{header|Haskell}}==

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

 

b = True

 

a_xor_b = a /= b

a_nxor_b = a == b

 

(&&) and (||) are lazy on the second argument and therefore this operations are not symmetric:

False

Prelude> undefined && False

True

Prelude> undefined || True

(<=), (<), (>=) and (>) on the other hand are strict:

*** Exception: Prelude.undefined

Prelude> undefined <= True

*** Exception: Prelude.undefined

Prelude> undefined < False

 

=={{header|hexiscript}}==

println "a and b = " + (a && b)

println "a or b = " + (a || b)

println " not a = " + (!a)

 

=={{header|HicEst}}==

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

y = value2 /= 0

NOTx = x == 0

xANDy = x * y

xORy = x + y /= 0

 

=={{header|HolyC}}==

 

Print("a and b is %d\n", a && b);

Print("a or b is %d\n", a || b);

}

 

 

=={{header|Hy}}==

(print "a and b:" (and a b))

(print "a or b:" (or a b))

 

=={{header|Icon}} and {{header|Unicon}}==

 

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.

 

procedure main() #: sample demonstrating boolean function use

b3 := char(iop(ord(b1[i]|z),ord(b2[i]|z))) || b3

return b3

 

{{out|Partial Sample Output:}}

bxor( "\x02\x00", "\x01" ) = "\x02\x01"

...</pre>

 

=={{header|Io}}==

writeln("a and b is ", a and b)

writeln("a or b is ", a or b)

writeln("not a is ", a not)

 

=={{header|J}}==

 

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

Given boolean arguments, <code>*.</code> is logical and, <code>+.</code> is logical or, and <code>-.</code>is logical not.

 

Additional primary logical operators include <code>*:</code> (not-and), <code>+:</code> (not-or), <code>~:</code> (exclusive-or) and <code><:</code> (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.

0 0 0 1

0 1 1 1

 

An alternate approach, based on a probabilistic interpretation, uses <code>*</code> for logical and, <code>-.</code> for logical negation and derives the others: <code>(*&.-.)</code> for logical or, <code>(-.@*)</code> for not-and, <code>(-.@*&.-.)</code> for not-or, <code>(* *&.-. -.@*&.-.)</code> for exclusive or, and <code>(*&.-. -.)~</code> for logical implication. You get the same results for simple truth values this way, but you also get consistent treatment for values between 0 and 1.

 

=={{header|Java}}==

 

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).

 

=={{header|JavaScript}}==

print("a AND b: " + (a && b));

print("a OR b: " + (a || b));

print("NOT a: " + (!a));

 

=={{header|jq}}==

 

In addition to the basic logical operators, jq has <tt>any</tt> and <tt>all</tt> filters. Versions of jq since 1.4 also have extended versions of these for working efficiently with streams.

"\(a) and \(b) => \(a and b)",

"\(a) or \(b) => \(a or b)",

"\(a) | not => \(a | not)",

'''Example''':

| (false, null, {}) as $b

<div style="overflow:scroll; height:200px;">

false and false => false

false or false => false

[] or {} => true

[] | not => false

 

=={{header|Julia}}==

 

function exerciselogic(a::Bool, b::Bool)

println(exerciselogic(a, b))

end

 

{{out}}

=={{header|Kotlin}}==

Similar style to FreeBASIC entry:

fun logicalDemo(b1: Boolean, b2: Boolean) {

println()

}

 

logicalDemo(true, true)

logicalDemo(true, false)

logicalDemo(false, false)

 

{{out}}

<pre>

 

 

 

</pre>

 

=={{header|Lambdatalk}}==

{and true true true false true} -> false

{or true true true false true} -> true

{not true} -> false

 

=={{header|langur}}==

 

The operators and, or, nand, nor, and?, or?, nand?, nor?, xor?, and nxor? are short-circuiting.

Operators that end with ? are null propagating or "database" operators, and will return null if either operand is null. They short-circuit differently than normal operators (only if the left operand is null).

 

 

val .tests = [

for .t in .tests {

write .test(.t[1], .t[2])

 

{{out}}

 

=={{header|Lasso}}==

define br => '\r'

 

'NOT a: ' + !#a

br

 

=={{header|Liberty BASIC}}==

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)

 

end

True =-1 False =0 NB True here shown as -1

.

 

=={{header|LIL}}==

set first [expr 1 == 1]

set second [expr 1 == 0]

}

 

 

{{out}}

 

=={{header|LiveCode}}==

local boolOpsResult

put p1 && "AND" && p2 && "=" && merge("[[p1 and p2]]") & cr after boolOpsResult

put "NOT" && p1 && "=" && merge("[[not p1]]") & cr after boolOpsResult

return boolOpsResult

Example

put boolops(bop, bop) & cr after bopResult

put boolops(bop, not bop) & cr after bopResult

false AND true = false

false OR true = true

 

=={{header|LLVM}}==

; LLVM does not provide a way to print values, so the alternative would be

; to just load the string into memory, and that would be boring.

}

 

{{out}}

<pre>a and b is 0

=={{header|Logo}}==

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

(print [a AND b =] and :a :b)

(print [a OR b =] or :a :b)

(print [NOT a =] not :a)

 

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

 

=={{header|Lua}}==

function logic(a,b)

return a and b, a or b, not a

end

 

=={{header|M2000 Interpreter}}==

Module CheckIt {

Def Boolean A, B

}

CheckIt

{{out}}

<pre>

 

=={{header|M4}}==

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

 

{{out}}

=={{header|Maple}}==

Infix and prefix operators are provided for each of <code>and</code>, <code>or</code>, <code>not</code> as well as <code>xor</code> and <code>implies</code>.

f:=proc(a,b) a and b, a or b, not a; end proc:

 

f(false,true);

f(false,false);

{{out}}

<pre> true, true, false

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Or[a,b,...]

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:

Nand[a, b,...]

Nor[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].

 

=={{header|Maxima}}==

 

/* to use multiple arguments, use any of these */

"or"(a, b, c, d);

apply("and", [a, b, c, d]);

 

=={{header|MAXScript}}==

(

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)

 

=={{header|Metafont}}==

 

def test(expr a, b) =

for o = "and", "or":

endfor

message "not " & tf(a);

 

test(false, false);

test(true, false);

test(false, true);

 

=={{header|min}}==

{{works with|min|0.19.3}}

:b :a

"xor is: " print! a b xor puts!

"or is: " print! a b or puts!

"not is: " print! a not puts!

 

=={{header|Modula-2}}==

FROM FormatString IMPORT FormatString;

FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

 

ReadChar

 

=={{header|Modula-3}}==

 

FROM IO IMPORT Put;

BEGIN

Test(TRUE, FALSE);

 

=={{header|MUMPS}}==

LOGIC(A,B)

WRITE !,A," AND ",B," IS ",A&B

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

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

 

=={{header|Nanoquery}}==

{{trans|Python}}

println "a and b: " + (a && b)

println "a or b: " + (a && b)

println "not a: " + !a

While this is translated from Python, Nanoquery does not allow any object to be treated as a boolean value. As a result, this function must be called with explicit boolean values.

{{out}}

 

=={{header|Neko}}==

Logical operations, in Neko

*/

if $istrue(logical) && logical > 0 $print("true path for logical AND\n")

if $istrue(logical) || logical > 1 $print("true path for logical OR\n")

 

{{out}}

 

=={{header|Nemerle}}==

using System.Console;

 

Main() : void {WriteLogical(true, false)}

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

 

=={{header|NetRexx}}==

options replace format comments java crossref symbols binary

 

end lx

return

{{out}}

<pre>

 

=={{header|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)))

 

 

=={{header|Nim}}==

echo "a and b: ", a and b

echo "a or b: ", a or b

echo "not a: ", not a

 

=={{header|Objeck}}==

bundle Default {

class Logic {

}

}

 

=={{header|OCaml}}==

 

Printf.printf "a and b is %B\n" (a && b);

Printf.printf "a or b is %B\n" (a || b);

 

=={{header|Octave}}==

 

s1 = num2str(a);

s2 = num2str(b);

test(false, false);

test(true, false);

 

=={{header|Oforth}}==

 

System.Out "and = " << b1 b2 and << cr

System.Out "or = " << b1 b2 or << cr

System.Out "xor = " << b1 b2 xor << cr

 

=={{header|OOC}}==

Bools in ooc are just covers for C's bools and respond to the same operators.

logic: func (a: Bool, b: Bool) {

println()

logic(false, true)

}

 

=={{header|OpenEdge/Progress}}==

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

 

i_l1 AS LOGICAL,

i_l2 AS LOGICAL

.

 

testLogical( FALSE, FALSE ) SKIP(1)

testLogical( FALSE, TRUE ) SKIP(1)

testLogical( ?, FALSE ) SKIP(1)

testLogical( ?, TRUE ) SKIP(1)

 

{{out}}

 

=={{header|Oz}}==

%% using not short-circuiting standard library functions

{Show {And A B}}

{Show A andthen B}

{Show A orelse B}

 

=={{header|PARI/GP}}==

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

print(a&b); \\ && is the same

print(a|b); \\ || is the same

print(!a);

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

 

{

return shift() ? 'true' : 'false', "\n";

print "not a is ", show_bool !$a;

print "a xor b is ", show_bool($a xor $b);

 

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

Other relational operators and maths are also valid, if you wanna get clever.

 

<span style="color: #008080;">function</span> <span style="color: #000000;">logicop</span><span style="color: #0000FF;">(</span><span style="color: #004080;">bool</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span> <span style="color: #008080;">and</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span> <span style="color: #008080;">or</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #008080;">not</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span> <span style="color: #008080;">xor</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">==</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">b</span><span style="color: #0000FF;">}</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

 

{{out}}

Simpler version using plain integer flags:

 

<span style="color: #008080;">function</span> <span style="color: #000000;">logiicop</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span> <span style="color: #008080;">and</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span> <span style="color: #008080;">or</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #008080;">not</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span> <span style="color: #008080;">xor</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">=</span><span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">!=</span><span style="color: #000000;">b</span><span style="color: #0000FF;">}</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

 

{{out}}

1 1 1 1 0 0 1 0

</pre>

 

=={{header|PHP}}==

 

{

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";

 

=={{header|PicoLisp}}==

(prin "A AND B is ")

(println (and A B))

(println (xor A B))

(prin "NOT A is ")

 

=={{header|PL/I}}==

declare (t, u) bit (1);

 

put skip list (^t); /* logical not */

put skip list (t ^ u); /* exclusive or */

 

=={{header|Pop11}}==

 

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');

 

Example usage is:

 

=={{header|PostScript}}==

/logical{

/a exch def

a not =

}def

 

=={{header|PowerShell}}==

Write-Host "A and B: " ($a -and $b)

Write-Host "A or B: " ($a -or $b)

Write-Host "not A: " (!$a)

Write-Host "A xor B: " ($a -xor $b)

 

=={{header|Prolog}}==

=={{header|PureBasic}}==

 

Debug a & b ;And

Debug a | b ;Or

logicDebug(#True, #True)

logicDebug(#True, #False)

 

=={{header|Python}}==

print('a and b:', a and b)

print('a or b:', a or b)

 

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.

=={{header|QB64}}==

 

Dim As _Unsigned _Bit First, Second

First = 0: Second = 1

 

 

 

=={{header|Quackery}}==

Quackery also has the boolean words <code>nand</code> and <code>xor</code>.

 

else [ say "false"] ] is echobool ( b --> )

 

say "A or B is " echobool cr

not

 

{{out}}

 

=={{header|R}}==

print(a && b)

print(a || b)

logic(TRUE, TRUE)

logic(TRUE, FALSE)

 

=={{header|Racket}}==

 

(define (logic a b)

(displayln (format "a nor b equals ~a" (nor a b)))

(displayln (format "a implies b equals ~a" (implies a b)))

 

=={{header|Raku}}==

 

Raku has an abundance of logical operators for various purposes.

say "$a && $b is ", $a && $b; # short-circuiting

say "$a || $b is ", $a || $b; # short-circuiting

}

 

{{out}}

<pre>3 && 10 is 10

 

=={{header|Rascal}}==

 

public void logic(bool a, bool b){

println("a implies b, is <a ==> b>");

println("not a", <!a>");

 

{{out}}

 

=={{header|REBOL}}==

print ['and tab a and b]

print ['or tab a or b]

print ['any tab any [a b]]

print ['all tab all [a b]]

 

Example:

 

=={{header|Relation}}==

program logic(x,y)

relation a, b, op, result

run logic(1,0)

run logic(1,1)

In Relation TRUE is the number 1 (or any different from 0) and FALSE 0.

 

=={{header|ReScript}}==

Js.log(string_of_bool(a) ++ " and " ++ string_of_bool(b) ++ " = " ++ string_of_bool(a && b))

Js.log(string_of_bool(a) ++ " or " ++ string_of_bool(b) ++ " = " ++ string_of_bool(a || b))

 

logic2(true)

{{out}}

<pre>

 

=={{header|Retro}}==

: logic ( ab- )

"\na = " puts over .bool "b = " puts dup .bool

"\na and b = " puts 2dup and .bool

"\na or b = " puts over or .bool

 

=={{header|REXX}}==

Any other value will raise a REXX '''syntax''' error condition.

===basic boolean functions===

x= 1 ; @x= ' x ' /*set the initial values of X and Y, */

y= 0 ; @y= ' y ' /* and a couple of literals for HDRs. */

@.= copies('═', 7) /*define a new header separator line. */

end /*j*/

{{out|output|text=&nbsp; when using the default (internal) inputs:}}

<pre>

===extended boolean functions===

All sixteen boolean functions could easily be shown.

x= 1 ; @x= ' x ' /*set the initial values of X and Y, */

y= 0 ; @y= ' y ' /* and a couple of literals for HDRs. */

@.= copies('═', 7) /*define a new separator (header) line.*/

end /*j*/

{{out|output|text=&nbsp; when using the default (internal) inputs:}}

<pre>

 

=={{header|Ring}}==

x = true

y = false

see "x or y = " + (x or y) + nl

see "not x = " + (not x) + nl

 

=={{header|RLaB}}==

<code>and/or/not</code> are synonymous with <code>&&/||/!</code>. 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

>> x && y

0

 

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

>> x = int(5)

5

>> x && y

0

 

=={{header|Robotic}}==

However, [[Bitwise_operations|bitwise operators]] can be used.

 

=={{header|Ruby}}==

print 'a and b: ', a && b, "\n"

print 'a or b: ' , a || b, "\n"

print 'not a: ' , !a , "\n"

print 'a xor b: ' , a ^ b, "\n"

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

 

=={{header|Rust}}==

{{works with|Rust|1.1}}

fn boolean_ops(a: bool, b: bool) {

println!("{} and {} -> {}", a, b, a && b);

boolean_ops(false, false)

}

The Boolean operators || and && are more efficient versions of | and & in that the right-hand operand is only evaluated when the left-hand operand does not already determine the result of the expression.

 

=={{header|Scala}}==

In vanilla Scala:

println("and: " + (a && b))

println("or: " + (a || b))

}

 

 

With Scalaz:

_ <- putStrLn("and: " ++ (a && b).shows)

_ <- putStrLn("or: " ++ (a || b).shows)

} yield ()

 

 

=={{header|Scheme}}==

(display "a and b is ")

(display (and a b))

(display "not a is ")

(display (not a))

 

=={{header|Seed7}}==

begin

writeln("a and b is " <& a and b);

writeln("a or b is " <& a or b);

writeln("not a is " <& not a);

 

=={{header|Self}}==

 

( true && false ) = false.

( true ^^ false ) = true. "xor"

( true || false ) = true. "or"

 

=={{header|Sidef}}==

say ("a and b: ", a && b);

say ("a or b: ", a || b);

}

 

{{out}}

<pre>a and b: false

This makes a closure that takes two Boolean values. Booleans can be indicated by predicate identifier names that end with a question mark <code>?</code>.

 

(a? b?)

[

println("a not xor b: " a nxor b)

]

 

Example call:

 

 

=={{header|Slate}}==

{{lines too long|Slate}}

func arity = 1 ifTrue: [inform: 'True ' ; (func as: String) ; ' = ' ; (func sendTo: {True}) printString.

inform: 'False ' ; (func as: String) ; ' = ' ; (func sendTo: {False}) printString.].

[ |:each| inform: each first printString ; (func as: String) ; each second printString ; ' = ' ; (func sendTo: each) printString]]

 

 

{{out}}

There are also non-evaluating versions named "and:" and "or:", which only evaluate expr2 if the result is not already determined by expr1.

 

test := [ :a :b |

('%1 %2 %3 = %4' % { a. 'and'. b. (a & b) }) displayNl.

test value: false value: false.

test value: true value: false.

 

 

{{works with|Smalltalk/X}}

 

=={{header|Standard ML}}==

 

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")

 

=={{header|Stata}}==

Stata does not have a boolean type, and uses instead 0 and 1 to denote resp. false and true.

 

args a b

di `a'&`b'

di `a'|`b'

di !`a'

 

Likewise in Mata:

 

printf("%f\n",a&b)

printf("%f\n",a|b)

printf("%f\n",!a)

 

=={{header|Swift}}==

 

println("a AND b: \(a && b)");

println("a OR b: \(a || b)");

println("NOT a: \(!a)");

 

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

 

=={{header|Tcl}}==

puts "a and b: [expr {$a && $b}]"

puts "a or b: [expr {$a || $b}]"

puts "not a: [expr {!$a}]"

 

=={{header|Toka}}==

that are the same as the well-formed flags in Forth.

 

[ ( a b -- )

cr ." a = " over .bool ." b = " dup .bool

cr ." a or b = " over or .bool

cr ." not a = " 0 = .bool

 

=={{header|uBasic/4tH}}==

uBasic/4tH does not have logical operators, but every non-zero value will be considered ''TRUE'' in conditional statements. However, comparison operators (like =, #, < and >) can be used in expressions and will return fully qualified booleans. Hence, simple arithmetic operators will do the trick just fine.

Proc _Boolean(0, 2)

Proc _Boolean(2, 0)

print "not A is "; a@ = 0 ' This will invert the boolean value

print

{{out}}

<pre>A and B is 1

 

0 OK, 0:63</pre>

 

=={{header|V}}==

Using stack shuffles.

 

[get2 [dup] dip swap [dup] dip].

get2 and puts

swap not puts

pop

 

Using view.

[get2 [a b : a b a b] view].

get2 and puts

swap not puts

pop

 

Using internal defines

 

a b and puts

a b or puts

a not puts

 

=={{header|Vala}}==

 

private static void print_logic (bool a, bool b) {

print ("a and b is %s\n", (a && b).to_string ());

return 0;

}

 

=={{header|Verilog}}==

integer a, b;

 

$finish ;

end

 

=={{header|Visual Basic .NET}}==

 

Console.WriteLine("And " & a And b)

Console.WriteLine("Or " & a Or b)

Console.WriteLine("And, short-circuited " & a AndAlso b)

Console.WriteLine("Or, short-circuited " & a OrElse b)

 

=={{header|Wren}}==

Wren has a built in Bool type which has two instances ''true'' and ''false'' which are also keywords.

 

 

Unlike some other C fanily languages, the Bool class doesn't support the operators ''&'', ''|'', ''^'' and ''~'' which, in Wren, only apply to bitwise operations on unsigned 32-bit integers.

 

However, it does support the short-circuiting ''&&'' and ''||'' logical operators as well as the conditional (or ternary) operator ''?:'' all of which behave as expected.

System.print("a = %(a)")

System.print("b = %(b)")

 

var tests = [ [true, true], [true, false], [false, true], [false, false] ]

 

{{out}}

 

=={{header|XLISP}}==

(print `(a and b = ,(and a b)))

(print `(a or b = ,(or a b)))

 

=={{header|XPL0}}==

convenient to combine logical and bitwise operations.

 

 

func Logic(A, B);

Logic(1, 1); CrLf(0);

Logic(1, 2); CrLf(0);

 

{{out}}

 

=={{header|XSLT}}==

<xsl:param name="a" select="true()"/>

<xsl:param name="b" select="false()"/>

<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>

 

=={{header|zkl}}==

Logical and/or do the logic and returns one of the ops.

fcn g(a,b){a or b}

<pre>

f(0,1) //-->0