Exemple #1
0
        /// <summary>
        /// Private temporal AND function
        /// </summary>
        private static Tbool And(Tbool t1, Tbool t2)
        {
            // Short circuit: If any input is eternally false, return false
            if (t1.IsFalse || t2.IsFalse) return new Tbool(false);

            // Else, apply the AND function to the inputs
            Tbool result = new Tbool();
            foreach(KeyValuePair<DateTime,List<Hval>> slice in TimePointValues(t1,t2))
            {    
                result.AddState(slice.Key, CoreAnd(slice.Value));
            }
            return result.Lean;
        }
Exemple #2
0
 /// <summary>
 /// Represents a nested if-then statement within in a boolean expression.
 /// </summary>
 public static Tbool IfThen(Tbool tb1, Tbool tb2)
 {
     return(!tb1 || tb2);
 }
Exemple #3
0
 /// <summary>
 /// Represents a nested if-then statement within in a boolean expression.
 /// </summary>
 public static Tbool IfThen(Tbool tb1, Tbool tb2)
 {
     return !tb1 || tb2;
 }
Exemple #4
0
 public Tnum RoundToNearest(Tnum multiple, Tbool breakTieByRoundingDown)
 {
     Tnum diff = this % multiple;
     return Switch<Tnum>(() => diff > multiple / 2, () => this - diff + multiple,
                         ()=> diff < multiple / 2 || breakTieByRoundingDown, ()=> this - diff,
                         () => true, () => this - diff + multiple);
 }
Exemple #5
0
 public void TestTvar10()
 {
     Tbool t2 = new Tbool(true);
     Assert.AreEqual(true, t2.Out);
 }
Exemple #6
0
        /// <summary>
        /// Scans the assumption table, looking for forward-chaining inferences.
        /// </summary>
        public static void TriggerInferences(string rel, Thing e1, Thing e2, Thing e3, Tvar val)
        {
            foreach (Pair p in Pairs)
            {
                // If A, then B
                if (p.LeftHandPoint.Relationship == rel)
                {
                    // TODO: Currently only handles expressions that are eternally true
                    if (Tvar.EqualTo(p.LeftHandPoint.Value, val))
                    {
                        // For each rightPoint.Arg number, get the corresponding Thing
                        Thing[] args = new Thing[3] {
                            e1, e2, e3
                        };

                        int a1 = p.RightHandPoint.Arg1 - 1;  // -1 b/c array is base-zero
                        int a2 = p.RightHandPoint.Arg2 - 1;
                        int a3 = p.RightHandPoint.Arg3 - 1;

                        Thing t1 = a1 >= 0 ? args[a1] : null;
                        Thing t2 = a2 >= 0 ? args[a2] : null;
                        Thing t3 = a3 >= 0 ? args[a3] : null;

                        Facts.Assert(t1, p.RightHandPoint.Relationship, t2, t3, p.RightHandPoint.Value);
                    }
                }

                // If -B, then -A
                else if (p.RightHandPoint.Relationship == rel)
                {
                    // If right-hand expression is always false...
                    if (Tvar.EqualTo(p.RightHandPoint.Value, val).IsFalse)
                    {
                        // If the left-hand side is a boolean (non-booleans can't be negated)...
                        if (Tvar.EqualTo(p.LeftHandPoint.Value, new Tbool(true)) ||
                            Tvar.EqualTo(p.LeftHandPoint.Value, new Tbool(false)))
                        {
                            // For each leftPoint.Arg number, get the corresponding Thing
                            int r1 = p.RightHandPoint.Arg1;
                            int r2 = p.RightHandPoint.Arg2;
                            int r3 = p.RightHandPoint.Arg3;

                            // I hope no one sees how ugly this is
                            Thing t1, t2, t3;
                            if (r1 == 1)
                            {
                                t1 = e1;
                            }
                            else if (r2 == 1)
                            {
                                t1 = e2;
                            }
                            else
                            {
                                t1 = e3;
                            }

                            if (r1 == 2)
                            {
                                t2 = e1;
                            }
                            else if (r2 == 2)
                            {
                                t2 = e2;
                            }
                            else
                            {
                                t2 = e3;
                            }

                            if (r1 == 3)
                            {
                                t3 = e1;
                            }
                            else if (r2 == 3)
                            {
                                t3 = e2;
                            }
                            else
                            {
                                t3 = e3;
                            }

                            // Assert -A
                            Tbool leftVal = (Tbool)p.LeftHandPoint.Value;
                            Facts.Assert(t1, p.LeftHandPoint.Relationship, t2, t3, !leftVal);
                        }
                    }
                }
            }
        }
Exemple #7
0
        /// <summary>
        /// Asserts a given fact (of the proper Tvar type)
        /// </summary>
        private static void AssertFact(Factoid f)
        {
            // Instantiate relevant Things
            Thing t1 = f.Arg1.ToString() != "" ? Facts.AddThing(f.Arg1.ToString()) : null;
            Thing t2 = f.Arg2.ToString() != "" ? Facts.AddThing(f.Arg2.ToString()) : null;
            Thing t3 = f.Arg3.ToString() != "" ? Facts.AddThing(f.Arg3.ToString()) : null;

            // Sometimes I have my doubts about static typing...
            if (f.FactType == "Tbool")
            {
                Tbool val = new Tbool();
                foreach (TemporalValue v in f.Timeline)
                {
                    val.AddState(v.Date, new Hval(v.Value));
                }
                Facts.Assert(t1, f.Relationship, t2, t3, val);
            }
            else if (f.FactType == "Tnum")
            {
                Tnum val = new Tnum();
                foreach (TemporalValue v in f.Timeline)
                {
                    val.AddState(v.Date, new Hval(v.Value));
                }
                Facts.Assert(t1, f.Relationship, t2, t3, val);
            }
            else if (f.FactType == "Tstr")
            {
                Tstr val = new Tstr();
                foreach (TemporalValue v in f.Timeline)
                {
                    val.AddState(v.Date, new Hval(v.Value));
                }
                Facts.Assert(t1, f.Relationship, t2, t3, val);
            }
            else if (f.FactType == "Tdate")
            {
                Tdate val = new Tdate();
                foreach (TemporalValue v in f.Timeline)
                {
                    val.AddState(v.Date, new Hval(v.Value));
                }
                Facts.Assert(t1, f.Relationship, t2, t3, val);
            }
            else if (f.FactType == "Tset")
            {
                Tset val = new Tset();
                foreach (TemporalValue v in f.Timeline)
                {
                    val.AddState(v.Date, new Hval(v.Value));
                }
                Facts.Assert(t1, f.Relationship, t2, t3, val);
            }
        }
        /// <summary>
        /// Returns a Tbool that's true up to a specified DateTime, and false
        /// at and after it.
        /// </summary>
        public static Tbool IsBefore(Tdate dt)
        {
            // Handle unknowns
            if (!dt.FirstValue.IsKnown)
            {
                return new Tbool(dt.FirstValue);
            }

            // Create boolean
            Tbool result = new Tbool();

            if (dt == DawnOf)
            {
                result.AddState(DawnOf, false);
            }
            else
            {
                result.AddState(DawnOf, true);
                result.AddState(dt.ToDateTime, false);
            }
            return result;
        }