0.1.1 - first public version

libraries/Troolean/Troolean.cpp

@@ -0,0 +1,147 @@
+//
+//    FILE: Troolean.cpp
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.1
+// PURPOSE: class for troolean math (true false unknown)
+//     URL:
+//
+// HISTORY:
+// 0.1.0 initial version
+// 0.1.1 adjust (in)equality so that unknown == unknown
+//       although there could be arguments that unknown != unknown
+//       added isTrue(), isFalse(), isUnknown()
+//       first public release
+//
+
+#include "Troolean.h"
+
+
+/////////////////////////////////////////////////////
+//
+// PUBLIC
+//
+Troolean::Troolean()
+{
+  _value = -1;
+}
+
+Troolean::Troolean(const int8_t val)
+{
+  if (val == 0) _value = 0;
+  else if (val == -1) _value = -1;
+  else _value = 1;
+}
+
+Troolean::Troolean(const Troolean &t)
+{
+  _value = t._value;
+}
+
+
+// PRINTING
+size_t Troolean::printTo(Print& p) const
+{
+  size_t n = 0;
+  if (_value == 0) n += p.print("false");
+  else if (_value == -1) n += p.print("unknown");
+  else n += p.print("true");
+  return n;
+};
+
+// EQUALITIES
+// t == t
+// f == f
+// u == u
+bool Troolean::operator == (const Troolean &t)
+{
+  return (_value == t._value);
+}
+
+bool Troolean::operator == (const bool &b)
+{
+  if (_value == 0 && !b) return true;
+  if (_value == 1 && b) return true;
+  return false;
+}
+
+bool Troolean::operator == (const int &i)
+{
+  if (_value == 0 && i == 0) return true;
+  if (_value == -1 && i == -1) return true;
+  if (_value == 1 && i != 0 && i != -1) return true;
+  return false;
+}
+
+bool Troolean::operator != (const Troolean &t)
+{
+  return (_value != t._value);
+}
+
+bool Troolean::operator != (const bool &b)
+{
+  if (_value == 0 && !b) return false;
+  if (_value == 1 && b) return false;
+  return true;
+}
+
+bool Troolean::operator != (const int &i)
+{
+  if (_value == 0 && i != 0) return true;
+  if (_value == -1 && i != -1) return true;
+  if (_value == 1 && (i == 0 || i == -1)) return true;
+  return false;
+}
+
+Troolean::operator bool() const
+{
+  if (_value == 1) return true;
+  if (_value == 0) return false;
+  return false;
+}
+
+
+// NEGATE
+// t -> f
+// f -> t
+// u -> u
+Troolean Troolean::operator ! ()
+{
+  if (_value == -1) return Troolean(-1);  // random 0 1 :)
+  if (_value == 1) return Troolean(0);
+  return Troolean(1);
+}
+
+// LOGICAL OPERATORS
+Troolean Troolean::operator && (const Troolean &t)
+{
+  if (_value == 0 || t._value == 0) return Troolean(0);
+  if (_value == 1 && t._value == 1) return Troolean(1);
+  return Troolean(-1);
+}
+
+Troolean Troolean::operator && (const bool &b)
+{
+  if (_value == 0 || !b) return Troolean(0);
+  if (_value == 1 && b) return Troolean(1);
+  return Troolean(-1);
+
+}
+
+Troolean Troolean::operator || (const Troolean &t)
+{
+  if (_value == 1 || t._value == 1) return Troolean(1);
+  if (_value == 0 && t._value == 0) return Troolean(0);
+  return Troolean(-1);
+}
+
+Troolean Troolean::operator || (const bool &b)
+{
+  if (_value == 1 || b) return Troolean(0);
+  if (_value == 0 && !b) return Troolean(1);
+  return Troolean(-1);
+}
+
+
+
+
+// END OF FILE

libraries/Troolean/Troolean.h

@@ -0,0 +1,67 @@
+//
+//    FILE: Troolean.h
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.1
+// PURPOSE: class for Troolean math
+//     URL: https://en.wikipedia.org/wiki/Three-valued_logic
+//          Kleene and Priest logics
+//
+// HISTORY:
+// see Troolean.cpp file
+//
+
+#ifndef TROOLEAN_H
+#define TROOLEAN_H
+
+#include "Arduino.h"
+#include "Printable.h"
+
+#define TROOLEAN_LIB_VERSION (F("0.1.1"))
+
+// TODO:rvdt enum values in a separate type....
+#define unknown -1
+
+class Troolean: public Printable
+{
+public:
+  Troolean();
+  Troolean(const int8_t);
+  Troolean(const Troolean&);
+
+  size_t printTo(Print&) const;
+
+  bool operator == (const Troolean&);
+  bool operator == (const bool&);
+  bool operator == (const int&);
+  bool operator != (const Troolean&);
+  bool operator != (const bool&);
+  bool operator != (const int&);
+
+  operator bool() const;
+
+  Troolean operator ! ();   // negation
+
+  Troolean operator && (const Troolean&);
+  Troolean operator && (const bool&);
+  Troolean operator || (const Troolean&);
+  Troolean operator || (const bool&);
+
+  // faster than ==
+  inline bool isTrue()    { return _value == 1; };
+  inline bool isFalse()   { return _value == 0; };
+  inline bool isUnknown() { return _value == -1; };
+
+  // ideas
+  // bool toBool(); // returns random true/false if unknown....
+  // Troolean operator &&=
+  // Troolean operator ||=
+  // extend with dontcare ?  ==> four state logic ?  Foolean?
+
+private:
+  int8_t _value;
+
+};
+
+#endif
+
+// END OF FILE

libraries/Troolean/examples/testTroolean/testTroolean.ino

@@ -0,0 +1,428 @@
+//
+//    FILE: testTroolean.ino
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.1
+// PURPOSE: test for troolean (tri state) math library for Arduino
+//     URL:
+//
+// Released to the public domain
+//
+
+#include "Troolean.h"
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println(__FILE__);
+  Serial.print("TROOLEAN_LIB_VERSION: ");
+  Serial.println(TROOLEAN_LIB_VERSION);
+
+  testConstructor();
+  testEquality();
+  testInEquality();
+  testAssignment();
+  testAND();
+  testOR();
+  testNOT();
+  testIF();
+  testIS();
+}
+
+void loop()
+{
+}
+
+void testConstructor()
+{
+  Troolean f(false);
+  Troolean t(true);
+  Troolean u(-1);
+  Troolean v(u);
+
+  Serial.println();
+  Serial.println(__FUNCTION__);
+  Serial.print(f);
+  Serial.print('\t');
+  Serial.print(t);
+  Serial.print('\t');
+  Serial.print(u);
+  Serial.print('\t');
+  Serial.println(v);
+}
+
+void testEquality()
+{
+  Troolean f(false);
+  Troolean t(true);
+  Troolean u(unknown);
+
+  Serial.println();
+  Serial.println(__FUNCTION__);
+  Serial.print(f == f);
+  Serial.print('\t');
+  Serial.print(f == t);
+  Serial.print('\t');
+  Serial.println(f == u);
+  Serial.print(t == f);
+  Serial.print('\t');
+  Serial.print(t == t);
+  Serial.print('\t');
+  Serial.println(t == u);
+  Serial.print(u == f);
+  Serial.print('\t');
+  Serial.print(u == t);
+  Serial.print('\t');
+  Serial.println(u == u);
+
+  Serial.print(f == false);
+  Serial.print('\t');
+  Serial.print(t == true);
+  Serial.print('\t');
+  Serial.print(u == false);
+  Serial.print('\t');
+  Serial.println(u == true);
+}
+
+void testInEquality()
+{
+  Troolean f(false);
+  Troolean t(true);
+  Troolean u(-1);
+
+  Serial.println();
+  Serial.println(__FUNCTION__);
+  Serial.print(f != f);
+  Serial.print('\t');
+  Serial.print(f != t);
+  Serial.print('\t');
+  Serial.println(f != u);
+  Serial.print(t != f);
+  Serial.print('\t');
+  Serial.print(t != t);
+  Serial.print('\t');
+  Serial.println(t != u);
+  Serial.print(u != f);
+  Serial.print('\t');
+  Serial.print(u != t);
+  Serial.print('\t');
+  Serial.println(u != u);
+
+  Serial.print(f != false);
+  Serial.print('\t');
+  Serial.print(t != true);
+  Serial.print('\t');
+  Serial.print(u != false);
+  Serial.print('\t');
+  Serial.println(u != true);
+}
+
+void testAssignment()
+{
+  Troolean f(false);
+  Troolean t(true);
+  Troolean u(-1);
+
+  f = true;
+  t = unknown;
+  u = false;
+  Serial.println();
+  Serial.println(__FUNCTION__);
+  Serial.print(f);
+  Serial.print('\t');
+  Serial.print(t);
+  Serial.print('\t');
+  Serial.println(u);
+}
+
+void testAND()
+{
+  Troolean a, b, c;
+
+  Serial.println();
+  Serial.println(__FUNCTION__);
+  a = true;
+  b = false;
+  c = a && b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = true;
+  b = true;
+  c = a && b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = true;
+  b = unknown;
+  c = a && b;
+  Serial.println(c);
+
+  a = false;
+  b = false;
+  c = a && b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = false;
+  b = true;
+  c = a && b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = false;
+  b = unknown;
+  c = a && b;
+  Serial.println(c);
+
+  a = unknown;
+  b = false;
+  c = a && b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = unknown;
+  b = true;
+  c = a && b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = unknown;
+  b = unknown;
+  c = a && b;
+  Serial.println(c);
+}
+
+void testOR()
+{
+  Troolean a, b, c;
+
+  Serial.println();
+  Serial.println(__FUNCTION__);
+  a = true;
+  b = false;
+  c = a || b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = true;
+  b = true;
+  c = a || b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = true;
+  b = unknown;
+  c = a || b;
+  Serial.println(c);
+
+  a = false;
+  b = false;
+  c = a || b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = false;
+  b = true;
+  c = a || b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = false;
+  b = unknown;
+  c = a || b;
+  Serial.println(c);
+
+  a = unknown;
+  b = false;
+  c = a || b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = unknown;
+  b = true;
+  c = a || b;
+  Serial.print(c);
+  Serial.print('\t');
+  a = unknown;
+  b = unknown;
+  c = a || b;
+  Serial.println(c);
+}
+
+void testNOT()
+{
+  Troolean a(false), b(true), c(unknown);
+
+  Serial.println();
+  Serial.println(__FUNCTION__);
+  Serial.print(!a);
+  Serial.print('\t');
+  Serial.print(!b);
+  Serial.print('\t');
+  Serial.println(!c);
+
+  Serial.print(!!a);
+  Serial.print('\t');
+  Serial.print(!!b);
+  Serial.print('\t');
+  Serial.println(!!c);
+}
+
+void testIF()
+{
+  // a troolean cannot be used directly in a if or while statement
+  // it must be compared to either boolean ot troolean.
+  Troolean a(false), b(true), c(unknown);
+
+  Serial.println();
+  Serial.println(__FUNCTION__);
+
+  Serial.print("TRUE");
+  Serial.print('\t');
+  if (a == true)
+  {
+    Serial.print('a');
+    Serial.print('\t');
+  }
+  if (b == true)
+  {
+    Serial.print('b');
+    Serial.print('\t');
+  }
+  if (c == true)
+  {
+    Serial.print('c');
+    Serial.print('\t');
+  }
+  Serial.println();
+
+  Serial.print("FALSE");
+  Serial.print('\t');
+  if (a == false)
+  {
+    Serial.print('a');
+    Serial.print('\t');
+  }
+  if (b == false)
+  {
+    Serial.print('b');
+    Serial.print('\t');
+  }
+  if (c == false)
+  {
+    Serial.print('c');
+    Serial.print('\t');
+  }
+  Serial.println();
+
+  Serial.print("UNKNOWN");
+  Serial.print('\t');
+  if (a == unknown)
+  {
+    Serial.print('a');
+    Serial.print('\t');
+  }
+  if (b == unknown)
+  {
+    Serial.print(b);
+    Serial.print('b');
+    Serial.print('\t');
+  }
+  if (c == unknown)
+  {
+    Serial.print('c');
+    Serial.print('\t');
+  }
+  Serial.println();
+
+  Serial.print("BOOL()");
+  Serial.print('\t');
+  if (a)
+  {
+    Serial.print('a');
+    Serial.print('\t');
+  }
+  if (b)
+  {
+    Serial.print('b');
+    Serial.print('\t');
+  }
+  if (c)
+  {
+    Serial.print('c');
+    Serial.print('\t');
+  }
+  Serial.println();
+}
+
+void testIS()
+{
+  Troolean f(false), t(true), u(unknown);
+
+  Serial.println();
+  Serial.println(__FUNCTION__);
+
+  Serial.print(f.isFalse());
+  Serial.print('\t');
+  Serial.print(f.isTrue());
+  Serial.print('\t');
+  Serial.println(f.isUnknown());
+
+  Serial.print(t.isFalse());
+  Serial.print('\t');
+  Serial.print(t.isTrue());
+  Serial.print('\t');
+  Serial.println(t.isUnknown());
+
+  Serial.print(u.isFalse());
+  Serial.print('\t');
+  Serial.print(u.isTrue());
+  Serial.print('\t');
+  Serial.println(u.isUnknown());
+
+  Serial.println();
+}
+
+
+////////////////////////////////////////////////////////////
+//
+// EXPECTED OUTPUT
+//
+/*
+  .....\test1.ino
+TROOLEAN_LIB_VERSION: 0.1.1
+
+testConstructor
+false	true	unknown	unknown
+
+testEquality
+1	0	0
+0	1	0
+0	0	1
+1	1	0	0
+
+testInEquality
+0	1	1
+1	0	1
+1	1	0
+0	0	1	1
+
+testAssignment
+true	unknown	false
+
+testAND
+false	true	unknown
+false	false	false
+false	unknown	unknown
+
+testOR
+true	true	true
+false	true	unknown
+unknown	true	unknown
+
+testNOT
+true	false	unknown
+false	true	unknown
+
+testIF
+TRUE	b	
+FALSE	a	
+UNKNOWN	c	
+BOOL()	trueb	
+
+testIS
+1	0	0
+0	1	0
+0	0	1
+
+*/
+// END OF FILE

libraries/Troolean/examples/testTrooleanArray/testTrooleanArray.ino

@@ -0,0 +1,61 @@
+//
+//    FILE: testTrooleanArray.ino
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.1
+// PURPOSE: test for troolean (tri state) math library for Arduino
+//     URL:
+//
+// Released to the public domain
+//
+
+#include "Troolean.h"
+
+// minimal array test
+Troolean arr[10];
+Troolean brr[5] = { true, false, unknown };
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println(__FILE__);
+  Serial.print("TROOLEAN_LIB_VERSION: ");
+  Serial.println(TROOLEAN_LIB_VERSION);
+
+  for (int i = 0; i < 10; i++) arr[i] = false;
+  for (int i = 0; i < 10; i++)
+  {
+    Serial.print(arr[i]);
+    Serial.print(" ");
+  }
+  Serial.println();
+
+  for (int i = 0; i < 10; i++) arr[i] = true;
+  for (int i = 0; i < 10; i++)
+  {
+    Serial.print(arr[i]);
+    Serial.print(" ");
+  }
+  Serial.println();
+
+  for (int i = 0; i < 10; i++) arr[i] = unknown;
+  for (int i = 0; i < 10; i++)
+  {
+    Serial.print(arr[i]);
+    Serial.print(" ");
+  }
+  Serial.println();
+
+  Serial.println();
+  for (int i = 0; i < 5; i++)
+  {
+    Serial.print(brr[i]);
+    Serial.print(" ");
+  }
+  Serial.println();
+}
+
+void loop()
+{
+}
+
+// END OF FILE

libraries/Troolean/keywords.txt

@@ -0,0 +1,18 @@
+#######################################
+# Syntax Coloring Map for Troolean
+#######################################
+
+#######################################
+# Datatypes (KEYWORD1)
+#######################################
+
+Troolean	KEYWORD1
+
+#######################################
+# Methods and Functions (KEYWORD2)
+#######################################
+
+#######################################
+# Constants (LITERAL1)
+#######################################
+unknown	LITERAL1

libraries/Troolean/library.json

@@ -0,0 +1,24 @@
+{
+  "name": "Troolean",
+  "keywords": "Troolean,numbers",
+  "description": "Library with Troolean math for Arduino.",
+  "authors":
+  [
+    {
+      "name": "Rob Tillaart",
+      "email": "Rob.Tillaart@gmail.com",
+      "maintainer": true
+    }
+  ],
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/RobTillaart/Arduino.git"
+  },
+  "version":"0.1.1",
+  "frameworks": "arduino",
+  "platforms": "*",
+  "export": {
+    "include": "libraries/Troolean"
+  }
+}

libraries/Troolean/library.properties

@@ -0,0 +1,9 @@
+name=Troolean
+version=0.1.1
+author=Rob Tillaart <rob.tillaart@gmail.com>
+maintainer=Rob Tillaart <rob.tillaart@gmail.com>
+sentence=Library with troolean math for Arduino. 
+paragraph=
+category=Data Processing
+url=https://github.com/RobTillaart/Arduino/tree/master/libraries/
+architectures=*