Boolean datatype

From Wikipedia, the free encyclopedia

In computer science, the Boolean datatype, sometimes called the logical datatype, is a primitive datatype having one of two values: non-zero (often 1, or -1) and zero (which are equivalent to true and false, respectively). It is the special case of a binary numeric datatype of only one digit, or bit, and can also be represented in any other radix by restricting the range of allowed values for certain operations.

In some languages the Boolean datatype is defined to represent more than two truth values. For instance the ISO SQL:1999 standard defined a Boolean data type for SQL which could hold three possible values: true, false, unknown (SQL null is treated as equivalent to the unknown truth value, but only for the Boolean data type).

This datatype is used in Boolean and other operations such as and (AND, &, *), or (OR, |, +), exclusive or/not equivalent (xor, NEQV, ^), equal (EQV, =, ==) and not (NOT, ~, !) which correspond to some of the operations of Boolean algebra and arithmetic.

Contents

[edit] Ada

Ada defines Boolean in the package Standard as an enumerated type with values False and True where False < True.

type Boolean is (False, True);
 
p : Boolean := True;
...
if p then
  ...
end if;

The relational operators (=, /=, <, <=, >, >=) apply to all enumerated types, including Boolean. Boolean operators and, or, xor, and not are defined on Boolean and any declared subtype. The Boolean operators also apply to arrays of Boolean values.

[edit] Algol

Algol 60 had a Boolean datatype and associated operations, defined in the Algol 60 report. This was abbreviated to bool in ALGOL 68.[1]

An actual extract from the ALGOL 68 language specification (page 177) where the boolean operators are defined:

10.2.2. Operations on Boolean Operands

  1. op ∨ = (bool a, b) bool:( a | true | b );
  2. op ∧ = (bool a, b) bool: ( a | b | false );
  3. op ¬ = (bool a) bool: ( a | false | true );
  4. op = = (bool a, b) bool:( a∧b ) ∨ ( ¬b∧¬a );
  5. op ≠ = (bool a, b) bool: ¬(a=b);
  6. op abs = (bool a)int: ( a | 1 | 0 );

[edit] C

Prior to C99, the standards for the C programming language provided no Boolean type. This however does not mean that C90 cannot represent the concept of boolean values, as all the boolean operators (&&, ||) and conditional statements (if, while) in C interpret nonzero values to signify true and zero values to signify false. Thus, it is common to store boolean values in variables of another type, such as an integer or an enum. For convenience, it is also common to create a typedef for a boolean type, which resolves to some existing datatype. The C99 standard also provides a built-in boolean type.

To illustrate Booleans in C, note that the C code:

if (my_variable) {
  printf("True!\n");
} else {
  printf("False!\n");
}

is equivalent to:

if (my_variable != 0) {
  printf("True!\n");
} else {
  printf("False!\n");
}

This is straightforward for integer datatypes. Since C standards mandate that 0 be interpreted as the null pointer when used in a pointer context or cast to a pointer, the above construct can also be used to check a pointer for NULL, although some code styles discourage this use. While the same conditional is also valid for floating-point values, special care must be taken when comparing them for equality, since they often contain rounded results. Traditionally, integers are used to contain boolean variables.

While it is not necessary to name the true and false values in order to test variables for truth or falsehood, it is necessary to do so in order to assign values to them. (One way is to use the values zero and one, which have the advantage of being language-independent.) Alternatively, the enum keyword allows for naming elements in the language of your choice, for example:

typedef enum { FALSE, TRUE } boolean;
...
boolean b;

The following typical preprocessor macros are also often used.

#define FALSE 0
#define TRUE 1
...
int f = FALSE;

Sometimes TRUE may be defined as -1 or ~0 (the bitwise complement of zero). This means that all bits of the integer are set to 1, on the now common two's complement computer architectures.

However, problems arise from the fact that any non-zero value represents true in C, while the value TRUE is represented by a specific value. So while in other languages, if (foo == TRUE) ... is merely redundant, in C, it is actually incorrect code.

[edit] C99

In C99, there is a bool type, along with the values true and false, defined in the <stdbool.h> header:

#include <stdbool.h>
bool b = false;
...
b = true;

[edit] C++

During its standardization process, the C++ programming language introduced the bool, true and false keywords, adding a native datatype to support boolean data. Its size is implementation defined.[2] bool was introduced in 1993[3].

The 1998 C++ Standard Library defines a specialization of the vector<bool> class. To optimize space, the elements are packed so that every bool only uses one bit of memory. This is widely considered a mistake. vector<bool> does not meet the requirements for a STL container. For instance, a container<T>::reference must be a true lvalue of type T. This is not the case with vector<bool>. Similarly, the vector<bool>::iterator does not yield a bool& when dereferenced. There is a general consensus among the C++ Standard Committee and the Library Working Group that vector<bool> should be deprecated or entirely removed from the next version of the standard.[4][5]

[edit] C#

In C#, Boolean variables are identified through the reserved word bool, which is an alias for the predefined struct type System.Boolean. It occupies one byte. No standard conversions exist between bool and other types. The language also provides a boolean type DBbool that can represent three values: true, false, and null. This is similar to the type used for boolean expressions in SQL[6]

Code to output a Boolean could be represented like this:

bool myBool = (i == 5);
System.Console.WriteLine(myBool ? "I = 5" : "I != 5");

[edit] Fortran

The LOGICAL keyword and associated operations .NOT., .AND., .OR., etc. were introduced in the 1950s, before Fortran was standardized.

[edit] Java

In the Java programming language, boolean variables are represented by the primitive type boolean. The Java Virtual Machine (JVM) abstracts away from the actual representation in memory, so JVM writers can represent booleans in whatever manner is convenient (for example, one byte, or one word).

The Java Language Specification does not permit any explicit or implicit casts to or from boolean. Thus, it requires the compiler to reject this code:

int i = 1;
if (i)
  System.out.println("i is not zero.");
else
  System.out.println("i is zero.");

because the integer variable i cannot be cast to a boolean, and the if statement requires a boolean condition.[7]

In Java, boolean values (like other primitive types) can be appended to Strings. This feature provides a default visual representation of a boolean (true is displayed as "true" and false as "false").[7]

[edit] JavaScript

JavaScript has two keywords true and false, both of which are written in lowercase. It is a weakly typed language and does not have an explicit Boolean datatype for its variables. However many values will evaluate to false when used in a logical context, including zero, null, zero length strings, and unknown properties of objects. All other variable values, including empty arrays and empty objects, will evaluate to true. The language does offer a Boolean object which can be used as a wrapper for handling boolean values. The Boolean object will always evaluate to true even if it has a value of false.

var objBool = new Boolean(false);
 
if ( false || 0 || "" || null || window.not_a_property ) {
    alert("never this");    
} else if ( true && [] && {} && objBool ) {
    alert("Hello Wikipedia");             // will bring up this message 
}

[edit] Lambda calculus

In the lambda calculus formal model of computing, booleans are represented as Church booleans.

[edit] Lisp

Lisp has two special symbols T and NIL which represent the logical values of true and false respectively. However, any non-NIL value is interpreted by a LISP system as true. The special symbol NIL is also represented by (), the empty list. So the empty list is false, but any list with data has the logical value of true. Therefore "nothing" is false and everything else is true.

[edit] ML

Like Ocaml, ML has a bool type that has true and false values. For example:

- fun isittrue x = if x then "YES" else "NO" ;
> val isittrue = fn : bool -> string
- isittrue true;
> val it = "YES" : string
- isittrue false;
> val it = "NO" : string
- isittrue (8=8);
> val it = "YES" : string
- isittrue (7=5);
> val it = "NO" : string

[edit] Objective-C

Objective-C provides a type BOOL, and macros YES and NO. Since Objective-C is a superset of C, C language semantics for booleans also apply.

[edit] Ocaml

Ocaml has a bool type that has true and false values.

# 1 = 1 ;;
- : bool = true

Like other enumerated types, a value of this type uses a word of memory.

[edit] Pascal

Boolean is a basic datatype provided by Pascal. Its definition and uses:

(* declaration in system or standard*)
Type 
   Boolean = (False,True);
 
(* usage *)
 
var
  value: Boolean;
 
...
 
value := True;
value := False;
 
if value then
begin
...
end;

Note that values outside the enum are not defined. Some compilers like Delphi have as extension special boolean type that map onto C numeric types for interfacing purposes. (Delphi: bytebool,wordbool,longbool)

[edit] Perl

In the Perl programming language, there is no distinction between numbers, strings and other non-aggregate data types. (They are all called "scalar".) Aggregate types without any elements, empty strings, numbers which equal a value of 0, the strings "" and "0", and undefined variables evaluate to "false" when used in a Boolean context. All other values (including strings such as 0.0 and 0E0 which are "zero but true") evaluate to "true".

Elements of aggregates may also be tested against "existence" or "non-existence"[1], and all variables may be evaluated as either "defined" or "undefined".[2] (An element of a hash or array that has been assigned the value undef exists but is undefined.) In Perl this distinction is important when evaluating scalars in a boolean manner to prevent "false falses" where one of the above values should be considered "true".

There are no built-in true or false constants in Perl 5, however the values do exist internally in Perl6.

1 is traditionally used for true, and constructs such as ... while 1 are special-cased to avoid advisory warnings. Internally, recent versions of Perl 5 have a variety of predefined yesses and nos, so that the recommended way to provide a false value has recently shifted from undef to !1 .

[edit] PHP

PHP has a boolean datatype [8] with two values: true and false (case doesn't matter).

$var = true;
$var = false;
print $var == true ? "T" : "F";
print $var === true ? "T" : "F";
print is_bool($var) ? "T" : "F";
print gettype($var);

Several values evaluate to a logical false [9] with the loose comparison operator ==. There are generally empty instances of a type, or are considered equivalent to the number 0. These vales are:

  • false
  • zero
  • "0"
  • NULL
  • empty array
  • empty string

PHP programmers wishing to distinguish a boolean variable set to false from other types of variable must use the strict comparison operator ===.

[edit] Python

The Python programming language defines True and False values as its boolean type, as well as allowing all objects to be tested for their truth value. The following values are considered false:

  • Numeric zero, None, False.
  • Empty containers such as empty strings, lists, tuples, dicts and sets.
  • User defined object instances have control over their boolean value through special methods __nonzero__[10] and __len__.

In all other cases, objects are considered true.

Boolean operators and boolean built-in types always return one of the boolean values True and False except for the operators "or" and "and" which return one of their operands (from left to right, the first operand that determines the boolean value of the expression).[11]

>>> class spam: pass    # spam is assigned a class object.
... 
>>> eggs = "eggs"       # eggs is assigned a string object.
>>> spam == eggs        # (Note double equals sign for equality testing).
False
>>> spam != eggs        # != and == always return bool values.
True
>>> spam and eggs       # and returns an operand.
'eggs'
>>> spam or eggs        # or also returns an operand.
<class __main__.spam at 0x01292660>
>>>

[edit] Ruby

The Ruby programming language does not have a Boolean data type as part of the language. Like many other interpreted languages, all variables are dynamically typed. Instead, ruby defines the explicit values of false and nil, and everything else is considered true, including 0, [ ], and the empty string "". The values true, false, and nil can be assigned to variables, returned from functions or methods, and compared in Boolean expressions.

a = 0
if (a) 
  print "true"
else
  print "false"
end

will print "true", which might come as a surprise to a new user of the language.

Since Ruby is a pure object-oriented programming language, even the "explicitly" defined values of true, false and nil are objects that each have their own class:

p false.class
p true.class
p nil.class

Would output "FalseClass", "TrueClass" and "NilClass" respectively.

[edit] Scheme

Scheme has two special symbols #t and #f which represent the logical values of true and false respectively. However, any non-#f value is interpreted as true. Note that unlike Lisp, nil or '(), the empty list, is separate from #f in Scheme, and therefore is considered true.

[edit] SQL

SQL supports three-valued logic (3VL), and comparison predicates in SQL can return any of three possible results: true, false, or unknown. The Boolean datatype was introduced in the ISO SQL:1999 standard, which specified that in addition to the three possible SQL Boolean values, instances of the datatype could be set to null[12]. For DBMSs that implement the ISO SQL:1999 standard, the following code creates a table which holds instances of the Boolean data type.

CREATE TABLE test1 
(
  a int, 
  b BOOLEAN
);
 
INSERT INTO test1 
VALUES (1, true);
 
INSERT INTO test1 
VALUES (2, false);
 
INSERT INTO test1
VALUES (3, NULL);
 
-- The SQL:1999 standard says that vendors can use null in place of the 
-- SQL Boolean value unknown.  It is left to the vendor to decide if
-- null should be used to completely replace unknown.  The standard also 
-- says that null should be treated as equivalent to unknown, which is an 
-- inconsistency.  The following line may not work on all SQL:1999-compliant 
-- systems.
 
INSERT INTO test1
VALUES (4, unknown);
 
SELECT * 
FROM test1;

The SQL Boolean data type did not gain widespread adoption, owing to inconsistencies in the standard and lack of support from vendors. Most SQL DBMSs use other data types like bit, byte, and char to simulate the behavior of Boolean data types.

[edit] Visual Basic

In Visual Basic Boolean values from comparisons can be stored in variables with the Boolean data type, which is stored as a 16-bit signed integer, but should only have the values True(-1) and False(0). For example:

Dim isSmall As Boolean
isSmall = intMyNumber < 10       ' Expression evaluates to True or False
If isSmall Then
   MsgBox("The number is small")
End If
 
Dim hellFreezesOver As Boolean   ' Boolean variables are initialized as False
hellFreezesOver = False          ' Or you can use an assignment statement
Do
   Call CheckAndProcessUserInput()
Loop Until hellFreezesOver

Note: Although Boolean values should only be -1 or 0, other values can be coerced into them by calling a function with a Variant ByRef parameter. It is highly recommended that you do not do this.

Sub Voo(ByRef v As Variant)
   v = 1
End Sub
 
Sub Bar(ByRef b As Boolean)
   b = 1
End Sub
 
Dim b1 As Boolean, b2 As Boolean
b1 = True
b2 = True
Debug.Print (b1 = b2) 'True
Call Voo(b2)
Debug.Print (b1 = b2) 'False
Call Bar(b2)
Debug.Print (b1 = b2) 'True

[edit] XPath and XQuery

XML Path Language (XPath 2.0) and XML Query Language (XQuery 1.0) both rely on XML Schema for Boolean data type support. The XML Schema xs:boolean data type supports both true and false Boolean values. XPath and XQuery define a set of rules for calculating the effective Boolean value of expressions.

XPath 1.0 and languages based on it, like XML Stylesheet Language (XSL), also support Boolean data types and implicit calculation of effective Boolean values from non-Boolean expressions.

[edit] See also

[edit] Notes and references

  1. ^ Report on the Algorithmic Language ALGOL 68, Section 10.2.2. (Aug 1968).
  2. ^ Working Paper for Draft Proposed International Standard for Information Systems-- Programming Language C++ (Dec 1996).
  3. ^ Evolving a language in and for the real world: C++ 1991-2006 (2007).
  4. ^ vector<bool>: More Problems, Better Solutions (Aug 1999).
  5. ^ A Specification to deprecate vector<bool> (Mar 2007).
  6. ^ C# Language Specifications, online at http://msdn.microsoft.com/en-us/library/aa664483(VS.71).aspx
  7. ^ a b Java Language Specification, 3rd edition - online at http://java.sun.com/docs/books/jls/
  8. ^ PHP: Booleans - Manual
  9. ^ PHP: PHP type comparison tables - Manual
  10. ^ Special method names: Basic customization. Python Language Reference.
  11. ^ Boolean operations.
  12. ^ ISO/IEC. ISO/IEC 9075-1:1999 SQL Standard (pdf format). Section 4.4.3.3. 1999.