Basic functionality

Author: goloop

.gitignore

@@ -0,0 +1,15 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, built with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Dependency directories (remove the comment below to include it)
+# vendor/

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 GoLoop
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -0,0 +1,140 @@
+[![Go Report Card](https://goreportcard.com/badge/github.com/goloop/trit)](https://goreportcard.com/report/github.com/goloop/trit) [![License](https://img.shields.io/badge/license-MIT-brightgreen)](https://github.com/goloop/trit/blob/master/LICENSE) [![License](https://img.shields.io/badge/godoc-YES-green)](https://godoc.org/github.com/goloop/trit) [![Stay with Ukraine](https://img.shields.io/static/v1?label=Stay%20with&message=Ukraine%20♥&color=ffD700&labelColor=0057B8&style=flat)](https://u24.gov.ua/)
+
+
+# trit
+
+It's useful package for working with trinary logic in Go!
+
+Package defines the data type and basic operations of a ternary logic system, often referred to as trinary or ternary logic. It supports three states, namely False, Nil, and True, with False represented by  negative number (-1), Nil represented by zero (0), and True represented by positive number (1).
+
+The logic operations NOT, AND, OR, XOR, NAND, NOR, and XNOR are implemented as methods of the Trit type, with each method applying the logic operation on the Trit receiver and a Trit argument to produce a Trit result according to the trinary truth table.
+
+There are also some useful methods provided for checking the state of a Trit value (IsFalse, IsNil, IsTrue), setting a Trit value from an integer (Set), returning the underlying int8 value of a Trit (Int), and returning a string representation of a Trit value (String).
+
+Overall, this package can be beneficial in scenarios where a "maybe" or "unknown" state is needed, such as in database systems and logic circuits, and in the construction of trinary computers and balanced ternary systems.
+
+## Quick start
+
+Install package:
+
+```shell
+$ go get github.com/goloop/trit
+```
+
+Some examples of using the package:
+
+```go
+package main
+
+import (
+	"fmt"
+
+	"github.com/goloop/trit"
+)
+
+func main() {
+	t1 := trit.True
+	t2 := trit.False
+
+	// IsTrue
+	fmt.Println(t1.IsTrue()) // Output: True
+
+	// IsFalse
+	fmt.Println(t2.IsFalse()) // Output: True
+
+	// Def
+	t3 := trit.Nil
+	t3.Def(trit.True)
+	fmt.Println(t3) // Output: True
+
+	// DefTrue
+	t4 := trit.Nil
+	t4.DefTrue()
+	fmt.Println(t4) // Output: True
+
+	// And
+	result := t1.And(t2)
+	fmt.Println(result) // Output: False
+
+	// Or
+	result = t1.Or(t2)
+	fmt.Println(result) // Output: True
+
+	// Xor
+	result = t1.Xor(t2)
+	fmt.Println(result) // Output: True
+
+	// Nand
+	result = t1.Nand(t2)
+	fmt.Println(result) // Output: True
+
+	// Nor
+	result = t1.Nor(t2)
+	fmt.Println(result) // Output: False
+
+	// Xnor
+	result = t1.Xnor(t2)
+	fmt.Println(result) // Output: False
+
+	// Int
+	fmt.Println(t1.Int()) // Output: 1
+
+	// String
+	fmt.Println(t1.String()) // Output: True
+}
+
+```
+
+## Truth Tables
+
+The truth table for the three-valued logic system is shown here. It's a mathematical table used in logic—specifically in connection with three-valued algebra, three-valued functions, and propositional calculus—which sets out the functional values of logical expressions on each of their functional arguments, that is, for each combination of values taken by their logical variables.
+
+```shell
+   NOT            AND             OR            XOR
+ A | B      A | B | C      A | B | C      A | B | C
+-------    -----------    -----------    -----------
+ T | F      T | T | T      T | T | T      T | T | F
+ N | N      T | N | N      T | N | T      T | N | T
+ F | T      T | F | F      T | F | T      T | F | T
+            N | T | N      N | T | T      N | T | T
+            N | N | N      N | N | N      N | N | F
+            N | F | F      N | F | F      N | F | F
+            F | T | F      F | T | T      F | T | T
+            F | N | F      F | N | N      F | N | T
+            F | F | F      F | F | F      F | F | F
+
+      NAND            NOR           XNOR
+ A | B | C      A | B | C      A | B | C
+-----------    -----------    -----------
+ T | T | F      T | T | F      T | T | T
+ T | N | T      T | N | F      T | N | F
+ T | F | T      T | F | F      T | F | F
+ N | T | T      N | T | F      N | T | F
+ N | N | T      N | N | T      N | N | T
+ N | F | T      N | F | F      N | F | T
+ F | T | T      F | T | F      F | T | F
+ F | N | T      F | N | T      F | N | T
+ F | F | T      F | F | T      F | F | T
+```
+
+## Explanation
+
+Here's an explanation of some key parts of this package:
+
+  - The Trit type is defined as an int8. This is a signed 8-bit integer, which means it can hold values between -128 and 127.
+
+  - The Trit type is used to represent a "trinary digit," which can take on three states: False, Nil, and True.
+
+  - Package defineds various methods on the Trit type that allow you to perform operations on trinary digits, including determining if a trinary digit represents False, Nil, or True, setting the value of a trinary digit based on an integer, normalizing a trinary digit, converting a trinary digit to an integer or a string, and performing logical NOT, AND, OR, XOR, NAND, NOR, and XNOR operations on trinary digits.
+
+  - The Trit type is defined as an alias for int8, and it can take one of three constants as its value: False, Nil, or True. False corresponds to any negative number (including -1), Nil corresponds to 0, and True corresponds to any positive number (including 1).
+
+  - There are four methods (Def, DefTrue, DefFalse, and Clean) that check if the value of a Trit is Nil and change its value based on the method called. For instance, DefTrue will set the Trit to True if its current value is Nil.
+
+  - There are three methods (IsFalse, IsNil, and IsTrue) that check the state of a Trit and return a boolean indicating if the Trit is in the corresponding state.
+
+  - These methods perform various operations like assigning a value to a Trit (Set), returning the normalized value of a Trit (Val), normalizing the Trit in place (Norm), getting the integer representation of the Trit (Int), and getting the string representation of the Trit (String).
+
+  - There are several methods for performing logic operations on Trit values including Not, And, Or, Xor, Nand, and Nor. These methods implement trinary logic versions of their respective boolean logic operations.
+
+  - The logic operation methods follow truth tables for ternary logic which are defined in the package comment section.

go.mod

@@ -0,0 +1,3 @@
+module github.com/goloop/trit
+
+go 1.20