Code cleaning

Author: ccrock4t

InputChannel.py

@@ -134,6 +134,7 @@ def process_visual_sensory_input(input_string):
     #remove line endings
     input_string = input_string.replace("\n", "")
     input_string = input_string.replace("\r", "")
+    input_string = input_string[1:-1]
 
     subject_str = "V" + str(Global.Global.NARS.memory.get_next_percept_id())
     predicate_term = NALGrammar.Term.from_string("[BRIGHT]")

NALGrammar.py

@@ -19,7 +19,9 @@ def __init__(self, dimensions, truth_values = None, occurrence_time=None):
             provides a granularity = 2.0/(dim_length - 1)
         """
         self.is_array = dimensions is not None
+        self.truth_values = None
         if not self.is_array: return
+        self.truth_values = truth_values
         self.dimensions = dimensions
         self.num_of_dimensions = len(dimensions)
         assert self.num_of_dimensions <= 3, "ERROR: Does not support more than 3 dimensions"
@@ -54,12 +56,33 @@ def __init__(self, dimensions, truth_values = None, occurrence_time=None):
                         formatted_indices = [x, y, z]
 
                     if isinstance(self, StatementTerm):
-                        array_term: ArrayTerm = self.get_subject_term().subterms[0]
-                        atomic_element = array_term[formatted_indices] # get atomic array element
-                        element = StatementTerm(subject_term=CompoundTerm(subterms=[atomic_element],
-                                                                    term_connector=NALSyntax.TermConnector.ExtensionalSetStart),
-                                                predicate_term=self.get_predicate_term(),
-                                                copula=NALSyntax.Copula.Inheritance)
+                        subject_is_array = isinstance(self.get_subject_term(), CompoundTerm) and isinstance(self.get_subject_term().subterms[0], ArrayTerm)
+                        predicate_is_array = isinstance(self.get_predicate_term(), CompoundTerm) and isinstance(self.get_predicate_term().subterms[0], ArrayTerm)
+                        if subject_is_array and predicate_is_array:
+                            subject_array_term = self.get_subject_term().subterms[0]
+                            subject_atomic_element = subject_array_term[formatted_indices]  # get atomic array element
+                            predicate_array_term = self.get_predicate_term().subterms[0]
+                            predicate_atomic_element = predicate_array_term[formatted_indices]  # get atomic array element
+                            element = StatementTerm(subject_term=CompoundTerm(subterms=[subject_atomic_element],
+                                                                              term_connector=NALSyntax.TermConnector.ExtensionalSetStart),
+                                                    predicate_term=CompoundTerm(subterms=[predicate_atomic_element],
+                                                                              term_connector=NALSyntax.TermConnector.ExtensionalSetStart),
+                                                    copula=self.get_copula())
+                        elif subject_is_array:
+                            array_term = self.get_subject_term().subterms[0]
+                            atomic_element = array_term[formatted_indices]  # get atomic array element
+                            element = StatementTerm(subject_term=CompoundTerm(subterms=[atomic_element],
+                                                                              term_connector=NALSyntax.TermConnector.ExtensionalSetStart),
+                                                    predicate_term=self.get_predicate_term(),
+                                                    copula=self.get_copula())
+                        elif predicate_is_array:
+                            array_term = self.get_predicate_term().subterms[0]
+                            atomic_element = array_term[formatted_indices]  # get atomic array element
+                            element = StatementTerm(subject_term=self.get_subject_term(),
+                                                    predicate_term=CompoundTerm(subterms=[atomic_element],
+                                                                              term_connector=NALSyntax.TermConnector.ExtensionalSetStart),
+                                                    copula=self.get_copula())
+
                     elif isinstance(self, Judgment):
                         truth_value: TruthValue = truth_values[len(z_array)][len(y_array)][len(x_array)]
                         statement_element: StatementTerm = self.statement[formatted_indices] # get atomic array element
@@ -136,15 +159,18 @@ def __init__(self, statement, value, punctuation, occurrence_time=None):
         self.punctuation: NALSyntax.Punctuation = punctuation
         self.stamp = Stamp(self_sentence=self,occurrence_time=occurrence_time)
 
-        if statement.is_array:
+        if statement.is_array and hasattr(value, '__iter__') and value[1] is not None:
             if isinstance(self,Judgment) or isinstance(self,Goal):
                 Array.__init__(self,statement.get_dimensions(),truth_values=value[1])
                 self.value = value[0]
             else:
                 Array.__init__(self, statement.get_dimensions())
                 self.value = None
         else:
+            #not an array
             Array.__init__(self, None)
+            if hasattr(value, '__iter__'): # if its iterable, only use the primary truth-value
+                value = value[0]
             self.value = value  # truth-value (for Judgment) or desire-value (for Goal) or None (for Question)
 
     def __str__(self):
@@ -209,32 +235,41 @@ def new_sentence_from_string(cls, sentence_string: str):
         # create the statement
         statement_string = sentence_string[start_idx:end_idx + 1]
 
-        if punctuation != NALSyntax.Punctuation.Question and sentence_string[2] == NALSyntax.TermConnector.Array.value:
+        # create standard statement from string
+        statement = StatementTerm.from_string(statement_string)
+
+        if punctuation == NALSyntax.Punctuation.Judgment:
             if freq is None:
                 # No truth value, use default truth value
                 freq = Config.DEFAULT_JUDGMENT_FREQUENCY
                 conf = Config.DEFAULT_JUDGMENT_CONFIDENCE
-            sentence = cls.new_percept_from_string(statement_string, TruthValue(freq, conf))
+            truth_values = None
+            if statement.is_array:
+                dims = list(statement.get_dimensions())
+                while len(dims) < 3:
+                    dims.append(1)
+                truth_values = []
+                for z in range(dims[2]):
+                    layer = []
+                    for y in range(dims[1]):
+                        row = []
+                        for x in range(dims[0]):
+                            element = TruthValue(freq, conf)
+                            row.append(element)
+                        layer.append(row)
+                    truth_values.append(layer)
+
+            sentence = Judgment(statement, (TruthValue(freq, conf),truth_values))
+        elif punctuation == NALSyntax.Punctuation.Question:
+            sentence = Question(statement)
+        elif punctuation == NALSyntax.Punctuation.Goal:
+            if freq is None:
+                # No truth value, use default truth value
+                freq = Config.DEFAULT_GOAL_FREQUENCY
+                conf = Config.DEFAULT_GOAL_CONFIDENCE
+            sentence = Goal(statement, DesireValue(freq,conf))
         else:
-            # create standard statement from string
-            statement = StatementTerm.from_string(statement_string)
-
-            if punctuation == NALSyntax.Punctuation.Judgment:
-                if freq is None:
-                    # No truth value, use default truth value
-                    freq = Config.DEFAULT_JUDGMENT_FREQUENCY
-                    conf = Config.DEFAULT_JUDGMENT_CONFIDENCE
-                sentence = Judgment(statement, TruthValue(freq, conf))
-            elif punctuation == NALSyntax.Punctuation.Question:
-                sentence = Question(statement)
-            elif punctuation == NALSyntax.Punctuation.Goal:
-                if freq is None:
-                    # No truth value, use default truth value
-                    freq = Config.DEFAULT_GOAL_FREQUENCY
-                    conf = Config.DEFAULT_GOAL_CONFIDENCE
-                sentence = Goal(statement, DesireValue(freq,conf))
-            else:
-                assert False,"Error: No Punctuation!"
+            assert False,"Error: No Punctuation!"
 
         # Find Tense, if it exists
         # otherwise mark it as eternal
@@ -366,13 +401,14 @@ class Stamp:
         when it was created, its occurrence time (when is its truth value valid),
         evidential base, etc.
     """
-    def __init__(self, self_sentence, occurrence_time=None):
+    def __init__(self, self_sentence, occurrence_time=None, derived_by=None):
         self.id = Global.Global.NARS.memory.get_next_stamp_id()
         self.creation_time = Global.Global.get_current_cycle_number()  # when was this stamp created (in inference cycles)?
         self.occurrence_time = occurrence_time
         self.sentence = self_sentence
         self.evidential_base = EvidentialBase(self_sentence=self_sentence)
         self.interacted_sentences = []  # list of sentence this sentence has already interacted with
+        self.derived_by = derived_by
         self.from_one_premise_inference = False # is this sentence derived from one-premise inference?
 
     def get_tense(self):
@@ -439,6 +475,7 @@ class Term:
     """
         Base class for all terms.
     """
+    term_dict = {} # a dictionary of existing terms to prevent duplicate term creation. Key: term string ; Value: term
 
     def __init__(self, term_string):
         assert isinstance(term_string, str), term_string + " must be a str"
@@ -480,6 +517,9 @@ def from_string(cls, term_string):
             :returns Term constructed using the string
         """
 
+        if term_string in cls.term_dict:
+            return cls.term_dict[term_string]
+
         if term_string[0] == NALSyntax.StatementSyntax.Start.value:
             """
                 Compound or Statement Term
@@ -513,6 +553,8 @@ def from_string(cls, term_string):
         else:
             term = AtomicTerm(term_string)
 
+        cls.term_dict[term_string] = term
+
         return term
 
     @classmethod
@@ -792,13 +834,23 @@ def __init__(self, subject_term: Term, predicate_term = None, copula=None, state
 
         CompoundTerm.__init__(self,subterms, statement_connector)
 
-        is_perceptual_term = isinstance(subject_term, CompoundTerm) \
+        subject_is_array_term = isinstance(subject_term, CompoundTerm) \
                              and subject_term.is_extensional_set() \
                              and isinstance(subject_term.subterms[0], Array) \
-                             and subject_term.subterms[0].is_array \
-                             and isinstance(predicate_term, CompoundTerm) \
-                             and predicate_term.is_intensional_set()
-        dimensions = subject_term.subterms[0].get_dimensions() if is_perceptual_term else None
+                             and subject_term.subterms[0].is_array
+        predicate_is_array_term = isinstance(predicate_term, CompoundTerm) \
+                             and predicate_term.is_extensional_set() \
+                             and isinstance(predicate_term.subterms[0], Array) \
+                             and predicate_term.subterms[0].is_array
+
+        dimensions = None
+        if subject_is_array_term and predicate_is_array_term:
+            dimensions = subject_term.subterms[0].get_dimensions()
+        elif subject_is_array_term:
+            dimensions = subject_term.subterms[0].get_dimensions()
+        elif predicate_is_array_term:
+            dimensions = predicate_term.subterms[0].get_dimensions()
+
         Array.__init__(self, dimensions=dimensions)
 
 

NALInferenceRules/Immediate.py

@@ -72,7 +72,8 @@ def Conversion(j):
 
     if isinstance(j, NALGrammar.Judgment):
         result_truth = TruthValueFunctions.F_Conversion(j.value.frequency, j.value.confidence)
-        result = NALGrammar.Judgment(result_statement, result_truth, occurrence_time=occurrence_time)
+        truth_values = TruthValueFunctions.TruthFunctionOnArray(j.truth_values,None,truth_value_function=TruthValueFunctions.F_Conversion)
+        result = NALGrammar.Judgment(result_statement, (result_truth, truth_values), occurrence_time=occurrence_time)
     elif isinstance(j, NALGrammar.Question):
         result = NALGrammar.Question(result_statement)
 

NALInferenceRules/Syllogistic.py

@@ -216,7 +216,6 @@ def Abduction(j1, j2):
     if isinstance(j1, NALGrammar.Judgment):
         # Get Truth Value
         (f1, c1), (f2, c2) = getevidentialvalues_from2sentences(j1, j2)
-
         result_truth = TruthValueFunctions.F_Abduction(f1, c1, f2, c2)
         result = NALGrammar.Judgment(result_statement, result_truth, occurrence_time=j1.stamp.occurrence_time)
     elif isinstance(j1, NALGrammar.Question):
@@ -351,8 +350,14 @@ def Comparison(j1, j2):
     if isinstance(j1, NALGrammar.Judgment):
         # Get Truth Value
         (f1, c1), (f2, c2) = getevidentialvalues_from2sentences(j1, j2)
-        result_truth = TruthValueFunctions.F_Comparison(f1, c1, f2, c2)
-        result = NALGrammar.Judgment(result_statement, result_truth, occurrence_time=j1.stamp.occurrence_time)
+        if j1.is_array and j2.is_array:
+            result_truths = TruthValueFunctions.TruthFunctionOnArray(j1.truth_values, j2.truth_values,truth_value_function=TruthValueFunctions.F_Comparison)
+            result_truth = TruthValueFunctions.ReviseArray(result_truths)
+        else:
+            result_truths = None
+            result_truth = TruthValueFunctions.F_Comparison(f1, c1, f2, c2)
+
+        result = NALGrammar.Judgment(result_statement, (result_truth,result_truths), occurrence_time=j1.stamp.occurrence_time)
     elif isinstance(j1, NALGrammar.Question):
         result = NALGrammar.Question(result_statement)
 

NALInferenceRules/TruthValueFunctions.py

@@ -12,8 +12,8 @@
 import Config
 import Global
 import NALGrammar
-from NALInferenceRules import HelperFunctions, ExtendedBooleanOperators
-from NALInferenceRules.HelperFunctions import get_truthvalue_from_evidence
+import NALInferenceRules
+from NALInferenceRules import ExtendedBooleanOperators
 
 
 def F_Revision(wp1, wn1, wp2, wn2):
@@ -24,7 +24,7 @@ def F_Revision(wp1, wn1, wp2, wn2):
     wp = wp1 + wp2
     wn = wn1 + wn2
     w = wp + wn
-    f_rev, c_rev = HelperFunctions.get_truthvalue_from_evidence(wp, w)
+    f_rev, c_rev = NALInferenceRules.HelperFunctions.get_truthvalue_from_evidence(wp, w)
     return NALGrammar.TruthValue(f_rev, c_rev)
 
 
@@ -39,14 +39,13 @@ def F_Negation(f, c):
 
 def F_Conversion(f, c):
     """
-        wp = AND(f, c)
-        wn = AND(NOT(f), c)
+        f_cnv = 1
+        c_cnv = (f*c)/(f*c+k)
         :return: F_cnv: Truth-Value (f,c)
     """
     # compute values of combined evidence
-    wp = ExtendedBooleanOperators.band(f, c)
-    w = wp
-    f_cnv, c_cnv = get_truthvalue_from_evidence(wp, w)
+    f_cnv = 1.0
+    c_cnv = (f*c)/(f*c+Config.k)
     return NALGrammar.TruthValue(f_cnv, c_cnv)
 
 
@@ -59,7 +58,7 @@ def F_Contraposition(f, c):
     wp = 0
     wn = ExtendedBooleanOperators.band(ExtendedBooleanOperators.bnot(f), c)
     w = wn
-    f_cnt, c_cnt = get_truthvalue_from_evidence(wp, w)
+    f_cnt, c_cnt = NALInferenceRules.Helperfunctions.get_truthvalue_from_evidence(wp, w)
 
     return NALGrammar.TruthValue(f_cnt, c_cnt)
 
@@ -112,7 +111,7 @@ def F_Abduction(f1, c1, f2, c2):
     # compute values of combined evidence
     wp = ExtendedBooleanOperators.band(f1, f2, c1, c2)
     w = ExtendedBooleanOperators.band(f1, c1, c2)
-    f_abd, c_abd = get_truthvalue_from_evidence(wp, w)
+    f_abd, c_abd = NALInferenceRules.HelperFunctions.get_truthvalue_from_evidence(wp, w)
     return NALGrammar.TruthValue(f_abd, c_abd)
 
 
@@ -123,7 +122,7 @@ def F_Induction(f1, c1, f2, c2):
     # compute values of combined evidence
     wp = ExtendedBooleanOperators.band(f1, f2, c1, c2)
     w = ExtendedBooleanOperators.band(f2, c1, c2)
-    f_ind, c_ind = get_truthvalue_from_evidence(wp, w)
+    f_ind, c_ind = NALInferenceRules.HelperFunctions.get_truthvalue_from_evidence(wp, w)
     return NALGrammar.TruthValue(f_ind, c_ind)
 
 
@@ -134,7 +133,7 @@ def F_Exemplification(f1, c1, f2, c2):
     # compute values of combined evidence
     wp = ExtendedBooleanOperators.band(f1, f2, c1, c2)
     w = wp
-    f_exe, c_exe = get_truthvalue_from_evidence(wp, w)
+    f_exe, c_exe = NALInferenceRules.HelperFunctions.get_truthvalue_from_evidence(wp, w)
     return NALGrammar.TruthValue(f_exe, c_exe)
 
 
@@ -145,7 +144,7 @@ def F_Comparison(f1, c1, f2, c2):
     # compute values of combined evidence
     wp = ExtendedBooleanOperators.band(f1, f2, c1, c2)
     w = ExtendedBooleanOperators.band(ExtendedBooleanOperators.bor(f1, f2), c1, c2)
-    f3, c3 = get_truthvalue_from_evidence(wp, w)
+    f3, c3 = NALInferenceRules.HelperFunctions.get_truthvalue_from_evidence(wp, w)
     return NALGrammar.TruthValue(f3, c3)
 
 
@@ -211,3 +210,46 @@ def Expectation(f, c):
             expectation value
     """
     return c * (f - 0.5) + 0.5
+
+def TruthFunctionOnArray(truth_value_array_1, truth_value_array_2, truth_value_function):
+    """
+        Performs a truth value function element-wise on the array
+    :param truth_value_array_1:
+    :param truth_value_array_2:
+    :param truth_value_function:
+    :return:
+    """
+    if truth_value_array_1 is None and truth_value_array_2 is None: return None
+    truth_values = []
+    for z, layer in enumerate(truth_value_array_1):
+        truth_values_layer = []
+        for y, row in enumerate(layer):
+            truth_values_row = []
+            for x, value in enumerate(row):
+                if truth_value_array_2 is None:
+                    # single truth value
+                    truth_values_row.append(truth_value_function(value.frequency, value.confidence))
+                else:
+                    truth_values_row.append(truth_value_function(value.frequency, value.confidence,truth_value_array_2[z][y][x].frequency, truth_value_array_2[z][y][x].confidence))
+            truth_values_layer.append(truth_values_row)
+        truth_values.append(truth_values_layer)
+    return truth_values
+
+
+def ReviseArray(array_to_iterate):
+    """
+         Performs a truth value function element-wise on the array
+         and revises it into a single truth-value
+    """
+    final_truth_value = None
+
+    for z, layer in enumerate(array_to_iterate):
+        for y, row in enumerate(layer):
+            for x, value in enumerate(row):
+                if final_truth_value is None:
+                    final_truth_value = value
+                else:
+                    wp1, w1, wn1 = NALInferenceRules.HelperFunctions.get_evidence_fromfreqconf(final_truth_value.frequency, final_truth_value.confidence)
+                    wp2, w2, wn2 = NALInferenceRules.HelperFunctions.get_evidence_fromfreqconf(value.frequency, value.confidence)
+                    final_truth_value = F_Revision(wp1,wn1,wp2,wn2)
+    return final_truth_value