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). Computer science (or computing science) is the study and the Science of the theoretical foundations of Information and Computation and their Boolean algebra (or Boolean logic) is a logical calculus of truth values, developed by George Boole in the late 1830s In Computer science, primitive types — as distinct from Composite types ' — are Data types provided by a Programming language as basic In Logic and Mathematics, a logical value, also called a truth value, is a value indicating the extent to which a Proposition is true 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. The binary numeral system, or base-2 number system, is a Numeral system that represents numeric values using two symbols usually 0 and 1. A bit is a binary digit, taking a value of either 0 or 1 Binary digits are a basic unit of Information storage and communication In mathematical numeral systems, the base or radix is usually the number of unique digits, including zero that a positional Numeral

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). Null is a special marker used in Structured Query Language (SQL to indicate that a data value does not exist in the database

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. In Logic and/or Mathematics, logical conjunction or and is a two-place Logical operation that results in a value of true if both of In Logic, statements p and q are logically equivalent if they have the same logical content In Logic and Mathematics, negation or not is an operation on Logical values for example the logical value of a Proposition Boolean algebra (or Boolean logic) is a logical calculus of truth values, developed by George Boole in the late 1830s Arithmetic or arithmetics (from the Greek word αριθμός = number is the oldest and most elementary branch of mathematics used by almost everyone

## Contents

Ada defines `Boolean` in the package Standard as an enumerated type with values `False` and `True` where `False` < `True`. Ada is a structured, Statically typed, imperative, and object-oriented high-level computer Programming language

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

## Algol

Algol 60 had a `Boolean` datatype and associated operations, defined in the Algol 60 report. Algol (β Per / Beta Persei known colloquially as the Demon Star, is a bright Star in the Constellation Perseus. This was abbreviated to `bool` in ALGOL 68. Time-line of ALGOL 68 The Algorithmic Language ALGOL 68 Reports Mar [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 );

## C

Prior to C99, the standards for the C programming language provided no Boolean type. tags please moot on the talk page first! --> In Computing, C is a general-purpose cross-platform block structured tags please moot on the talk page first! --> In Computing, C is a general-purpose cross-platform block structured 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. typedef is a keyword in the C and C++ Programming languages It is used to give a Data type a new name The C99 standard also provides a built-in boolean type. tags please moot on the talk page first! --> In Computing, C is a general-purpose cross-platform block structured

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. The integers (from the Latin integer, literally "untouched" hence "whole" the word entire comes from the same origin but via French 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. Programming style refers to a set of rules or guidelines used when writing the Source code for a Computer program. 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. In Computing, floating point describes a system for numerical representation in which a string of digits (or Bits represents a Real number. 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;. In Computer programming, an enumerated type is a Data type (usually user-defined consisting of a set of named constants called enumerators. . . boolean b;`

The following typical preprocessor macros are also often used. The C preprocessor ( cpp) is the Preprocessor for the C programming language.

`#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. The two's complement of a Binary number is defined as the value obtained by subtracting the number from a large power of two (specifically from 2 N for

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.

### C99

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

`#include <stdbool. TemplateC_Standard_library -->The header stdboolh in the C Standard Library for the C programming language contains h>bool b = false;. . . b = true;`

## C++

During its standardization process, the C++ programming language introduced the `bool`, `true` and `false` keywords, adding a native datatype to support boolean data. C++ (" C Plus Plus " ˌsiːˌplʌsˈplʌs is a general-purpose Programming language. A programming language is an Artificial language that can be used to write programs which control the behavior of a machine particularly a Computer. 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`. In Computer science, a value is a sequence of Bits that is interpreted according to some Data type. This is not the case with `vector<bool>`. Similarly, the `vector<bool>::iterator` does not yield a `bool&` when dereferenced. The dereference operator or indirection operator, "*" is a Unary operator found in C -like languages that include pointer variables 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]

## C#

In C#, Boolean variables are identified through the reserved word `bool`, which is an alias for the predefined struct type `System. C# (pronounced C Sharp is a Multi-paradigm Boolean`. It occupies one byte. A byte (pronounced "bite" baɪt is the basic unit of measurement of information storage in Computer science. 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");`

## Fortran

The `LOGICAL` keyword and associated operations `. NOT. `, `. AND. `, `. OR. `, etc. were introduced in the 1950s, before Fortran was standardized. The 1950s Decade refers to the years of 1950 to 1959 inclusive Fortran (previously FORTRAN) is a general-purpose, procedural, imperative Programming language that is especially suited to

## 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). A Java Virtual Machine ( JVM) is a set of computer software programs and data structures which use a Virtual machine In Computing, " word " is a term for the natural unit of data used by a particular computer design

The Java Language Specification does not permit any explicit or implicit casts to or from `boolean`. In Computer science, type conversion or typecasting refers to changing an entity of one Data type into another 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]

## JavaScript

JavaScript has two keywords `true` and `false`, both of which are written in lowercase. JavaScript is a Scripting language most often used for Client-side web development 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 }`

## Lambda calculus

In the lambda calculus formal model of computing, booleans are represented as Church booleans. In Mathematical logic and Computer science, lambda calculus, also written as λ-calculus, is a Formal system designed to investigate function In Mathematics, Church encoding is a means of embedding data and operators into the Lambda calculus, the most familiar form being the Church numerals, a

## Lisp

Lisp has two special symbols `T` and `NIL` which represent the logical values of true and false respectively. Lisp (or LISP) is a family of Computer Programming languages with a long history and a distinctive fully parenthesized syntax 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.

## ML

Like Ocaml, ML has a `bool` type that has `true` and `false` values. ML is a general-purpose Functional programming language developed by Robin Milner and others in the late 1970s at the University of Edinburgh, whose syntax 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`

## Objective-C

Objective-C provides a type `BOOL`, and macros `YES` and `NO`. Objective-C is a reflective, object-oriented Programming language which adds Smalltalk -style messaging to C. Since Objective-C is a superset of C, C language semantics for booleans also apply. tags please moot on the talk page first! --> In Computing, C is a general-purpose cross-platform block structured In Computer science, the Boolean datatype, sometimes called the logical datatype, is a Primitive datatype having one of two values

## Ocaml

Ocaml has a `bool` type that has `true` and `false` values. Objective Caml ( OCaml) is the main implementation of the Caml Programming language, created by Xavier Leroy, Jérôme Vouillon

`# 1 = 1 ;;- : bool = true`

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

## Pascal

`Boolean` is a basic datatype provided by Pascal. Pascal is an influential imperative and procedural Programming language, designed in 1968/9 and published in 1970 by Niklaus Wirth as a small Its definition and uses:

`(* declaration in system or standard*)Type    Boolean = (False,True); (* usage *) var  value: Boolean; . . .  value := True;value := False; if value thenbegin. . . 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)

## Perl

In the Perl programming language, there is no distinction between numbers, strings and other non-aggregate data types. NOTES FOR EDITORS "Perl" is not an acronym (read the "Name" section below (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. Perl 6 is a planned major revision to the Perl Programming language.

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

## 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 `===`.

## 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. Python is a general-purpose High-level programming language. Its design philosophy emphasizes programmer productivity and code readability 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>>>>`

## Ruby

The Ruby programming language does not have a Boolean data type as part of the language. Ruby is a dynamic, reflective, general purpose Object-oriented programming language that combines syntax inspired by Perl with Smalltalk 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 `""`. Ruby is a dynamic, reflective, general purpose Object-oriented programming language that combines syntax inspired by Perl with Smalltalk The values `true`, `false`, and `nil` can be assigned to variables, returned from functions or methods, and compared in Boolean expressions.

`a = 0if (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. Object-oriented programming (OOP is a Programming paradigm that uses " objects " and their interactions to design applications and computer programs classp true. classp nil. class`

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

## Scheme

Scheme has two special symbols `#t` and `#f` which represent the logical values of true and false respectively. Scheme is a Multi-paradigm programming language. It is one of the two main dialects of Lisp and supports a number of programming paradigms but is 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.

## 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 test1VALUES (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 test1VALUES (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.

## 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)`. Visual Basic ( VB) is the third-generation event-driven programming language and associated development environment (IDE from For example:

`Dim isSmall As BooleanisSmall = intMyNumber < 10       ' Expression evaluates to True or FalseIf isSmall Then   MsgBox("The number is small")End If Dim hellFreezesOver As Boolean   ' Boolean variables are initialized as FalsehellFreezesOver = False          ' Or you can use an assignment statementDo   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 = 1End Sub Sub Bar(ByRef b As Boolean)   b = 1End Sub Dim b1 As Boolean, b2 As Booleanb1 = Trueb2 = TrueDebug. Print (b1 = b2) 'TrueCall Voo(b2)Debug. Print (b1 = b2) 'FalseCall Bar(b2)Debug. Print (b1 = b2) 'True`

## XPath and XQuery

XML Path Language (XPath 2. XPath (XML Path Language is a language for selecting nodes from an XML document 0) and XML Query Language (XQuery 1. XQuery is a Query language (with some Programming language features that is designed to query collections of XML data 0) both rely on XML Schema for Boolean data type support. XML Schema, published as a W3C recommendation in May 2001 is one of several XML schema languages. 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.

## Notes and references

1. ^ Report on the Algorithmic Language ALGOL 68, Section 10.2.2. (Aug 1968). In Unix-like Operating systems true is a command whose only function is to always return the value 0 which is regarded by the shell as the In Unix-like Operating systems false is the command that always returns the value 1 which is regarded by the shell as the Logical value A shell script is a script written for the shell, or Command line interpreter, of an Operating system. In mathematics Shannon's expansion or the Shannon decomposition is a method by which a Boolean function can be represented by the sum of two sub-functions of the
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.

© 2009 citizendia.org; parts available under the terms of GNU Free Documentation License, from http://en.wikipedia.org
network: | |