**Tõeväärtus** on arvutiteaduses kahe võimaliku väärtusega andmetüüp, mille väärtusteks on kas tõene või väär.

Tõeväärtus on mõeldud loogika ja Boole’i algebra, millele pani aluse George Boole, väärtuste esitamiseks. See andmetüüp on peamiselt seotud tingimuslausetega, mis võimaldavad erinevaid toiminguid, muutes programmi juhtimisvoogu vastavalt väärtusele.

Üldine
------

Programmeerimiskeeltes, kus tõeväärtuse andmetüüp on eeldefineeritud, nagu Pascal ja Java, on üldjuhul väärtuste võrdlemiseks määratud operaatorid, näiteks `>` ja `≠`. Tingimuslausetega saab kontrollida ka loogikaavaldiste väärtuseid.

Keeled, millel pole tõeväärtuse andmetüüp eeldefineeritud, nagu C90 ja Lisp, kasutavad tõeväärtuste esitamiseks teisi andmetüüpe. Common Lisp käsitleb tühja loendit kui väära väärtust ja mistahes muud väärtust kui tõest väärtust. C-programmeerimiskeeltes kasutatakse täisarvu andmetüüpi, kus 1 tähistab tõest ja 0 väära väärtust ning tingimuslausetes koheldakse iga nullist erinevat väärtust tõesena.

Enamik programmeerimiskeeli toetab Boole’i algebralisi tehteid: konjunktsioon (`AND`), disjunktsioon (`OR`), ekvivalents (`==`) ja eitus (`NOT`).

Mõningates keeltes, nagu Ruby, on tõene ja väär eraldi klassid ehk sellistes keeltes pole tõeväärtuse andmetüüpi.

C, C++
------

Algselt C-keel (1972) ei sisaldanud tõeväärtuse tüüpi eraldi ja väärtusi esindasid täisarvud 1 (tõene) ja 0 (väär). Tingimuslausete korral on kõik nullist erinevad väärtused tõesed. Alates C99 standardist on lisatud tõeväärtuse tüüp. Selleks on vaja lisada päisesse `stdbool.h.` Seda tüüpi muutujad käituvad endiselt aga täisarvudena. Seega saab kasutada tõeväärtusi aritmeetiliste arvutuste tegemiseks. Sellist lähenemist kasutatakse C keeltes tänaseni.

Boolean-tüüpi väärtused C++is:

```
#include<stdio.h> 
#include<stdbool.h>

int main(void) 
{ 
	bool a = true, b = false, c = -1, d = 0, e = 1, f = 2;
	
	printf("%d\n", a); //tulemus on 1
	printf("%d\n", b); //tulemus on 0
	printf("%d\n", c); //tulemus on 1
	printf("%d\n", d); //tulemus on 0
	printf("%d\n", e); //tulemus on 1
	printf("%d\n", f); //tulemus on 1
} 
```

Tõeväärtustega aritmeetiliste tehete arvutamine C++is:

```
#include<iostream>
using namespace std;
int main()
{ 
	int m = 2; 
	bool b = true; 
	int x = false + 5 * m - b; 
	cout << x; 
}
//Tulemus 0 + 5 * 2 - 1 = 9
```

Python, Ruby ja JavaScript
--------------------------

Pythonisse lisati tõeväärtuse tüüp alates versioonist 2.3, mis on `int` klassi alamklass. Väärtusteks on `True` ja `False`, mis käituvad nagu 1 ja 0. Erinevalt teistest keeltest loetakse vääraks arv 0, kümnendmurd 0.0, tühi sõne, tühjad andmestruktuurid (järjendid, lõplikud jadad, magasin jne). Kõik ülejäänud väärtused loetakse tõeseks.

Erinevalt Pythonist on Rubys väär vaid `false` ja `nil` (Ruby nullväärtus), kõik ülejäänud väärtused loetakse tõeseks (kaasa arvatud arv 0, tühjad andmestruktuurid).

Javascriptis ja ka PHPs on väärad tühisõned (`""`), `null`, `undefined` (defineerimata), `NaN`, +0, -0 ja `false` ning ülejäänud on tõesed.

Tõeväärtused Pythonis:

```
# Tulemus on väär
x = False
print(bool(x))

# Tulemus on tõene 
x = True
print(bool(x))

# Tulemus on väär
x = 5
y = 10
print(bool(x==y))

# Tulemus on väär
x = None
print(bool(x))

# Tulemus on väär 
x = () 
print(bool(x))

# Tulemus on väär
x = {} 
print(bool(x))

# Tulemus on väär
x = 0.0
print(bool(x))

# Tulemus on tõene
x = 'näidis'
print(bool(x)) 
```

Java
----

Javas antakse vaikimisi väärtused alati väärad. Javas ei saa kasutada väärtusi kui täisarve nii nagu C keeltes, sest Javas tõeväärtusi ei teisendata arvulisteks väärtusteks. Seetõttu ei saa Javas kasutada võrratuse tehteid kahe tõeväärtuse vahel, kuid saab kasutada võrdust.

Vaikeväärtused Javas:

```
import java.util.Arrays;

public class A {

	public static void main(String[] args){
		
		boolean a[];
		a = new boolean[5];
		
		System.out.println(Arrays.toString(a)); //Tulemus: [false, false, false, false, false]
		
		a[1] = true;
		
		System.out.println(Arrays.toString(a)); //Tulemus: [false, true, false, false, false]
	}
}
```

SQL
---

Tõeväärtuse andmetüüp võeti kasutusele SQL:1999 standardiga. Kui väärtusel on piirang `NOT NULL`, siis saab olla tõeväärtus ainult tõene või väär nagu teisteski keeltes. Kuid SQLis on kasutusel ka kolmas tõeväärtus: `UNKNOWN` ehk tundmatu. Selline tõeväärtus väärtustatakse tühihulgaga, mis on samaväärne kui `NULL`. `NULL` pole väärtus, vaid olek, mis näitab, et andmebaasis objekti ei eksisteeri. Probleeme tekib kui võrrelda oma vahel kahte tundmatut, siis tulemuseks pole mitte tõene vaid `UNKNOWN/NULL`. Erandlikult PostgreSQL-i ja Firebirdi relatsioonilise andmebaasi haldamise süsteemides kasutatakse vaid kahte tõeväärtust ehk pole tundmatut tõeväärtust, kuid saab määrata olekuks `NULL`.

Viited
------

1. ↑  "What is a Boolean?". *computerhope.com*. Vaadatud 21. november 2018.
2. ↑  Kernighan, Brian W; Ritchie, Dennis M (1978). *The C Programming Language*. Englewood Cliffs, NJ: Prentice Hall. Lk 41.`{{raamatuviide}}`: CS1 hooldus: mitu nime: autorite loend (link)
3. ↑  Plauger, PJ; Brodie, Jim (1992). *ANSI and ISO Standard C Programmer's reference*. Microsoft Press. Lk 86–93.`{{raamatuviide}}`: CS1 hooldus: mitu nime: autorite loend (link)
4. ↑  "Intro to Truth Tables & Boolean Algebra". *medium.com*. Vaadatud 21. november 2018.
5. ↑  "Bool data type in C++". *geeksforgeeks.org*. Vaadatud 21. november 2018.
6. ↑  "Avaldised". *Python dokumentatsioon*. 22. mai 2013. Vaadatud 21. november 2018.
7. ↑  "Java ja C++i boolean-tüüpi võrdlus". *geeksforgeeks.org*. Vaadatud 21. november 2018.
8. ↑  Martyn Prigmore (2007). *Introduction to Databases With Web Applications*. Pearson Education Canada. Lk 197.