Add tolerance based equals node

src/Engine/ProtoCore/Utils/MathUtils.cs

@@ -4,7 +4,7 @@ namespace ProtoCore.Utils
 {
     public static class MathUtils
     {
-        public static double Tolerance = 1e-5;
+        public const double Tolerance = 1e-5;
 
         [Obsolete("This method is no longer used. Remove in Dynamo 3.0")]
         public static bool IsLessThan(double lhs, double rhs)
@@ -30,15 +30,15 @@ public static bool IsLessThanOrEquals(double lhs, double rhs)
             return (lhs < rhs) || Equals(lhs, rhs);
         }
 
-        public static bool Equals(double lhs, double rhs)
+        public static bool Equals(double lhs, double rhs, double tolerance = Tolerance)
         {
             if (double.IsPositiveInfinity(lhs) && double.IsPositiveInfinity(rhs))
                 return true;
 
             if (double.IsNegativeInfinity(lhs) && double.IsNegativeInfinity(rhs))
                 return true;
 
-            return Math.Abs(lhs - rhs) < Tolerance;
+            return Math.Abs(lhs - rhs) < tolerance;
         }
     }
 }

src/Libraries/CoreNodeModels/CoreNodeModels.csproj

@@ -53,6 +53,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Equals.cs" />
     <Compile Include="Input\ColorPalette.cs" />
     <Compile Include="Input\DateTime.cs" />
     <Compile Include="DynamoConvert.cs" />

src/Libraries/CoreNodeModels/Equals.cs

@@ -0,0 +1,92 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Dynamo.Graph.Nodes;
+using Newtonsoft.Json;
+using ProtoCore.AST.AssociativeAST;
+using ProtoCore.DSASM;
+using ProtoCore.Utils;
+
+namespace CoreNodeModels
+{
+    [NodeName("==")]
+    [NodeDescription("Equals with tolerance input")]
+    [NodeCategory("Core.Math")]
+    [NodeSearchTags("Equals")]
+    [InPortTypes("double ", "double", "double")]
+    [OutPortTypes("bool")]
+    [IsDesignScriptCompatible]
+    public class Equals : NodeModel
+    {
+        private static readonly DoubleNode tolerancePortDefaultValue = new DoubleNode(MathUtils.Tolerance);
+
+        [JsonConstructor]
+        private Equals(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(inPorts, outPorts)
+        {
+            ArgumentLacing = LacingStrategy.Auto;
+            inPorts.ElementAt(2).DefaultValue = tolerancePortDefaultValue;
+        }
+
+        public Equals()
+        {
+            ArgumentLacing = LacingStrategy.Auto;
+
+            InPorts.Add(new PortModel(PortType.Input, this, new PortData("lhs", "integer or double value")));
+            InPorts.Add(new PortModel(PortType.Input, this, new PortData("rhs", "integer or double value")));
+            InPorts.Add(new PortModel(PortType.Input, this,
+                new PortData("tolerance", "tolerance", tolerancePortDefaultValue)));
+            OutPorts.Add(new PortModel(PortType.Output, this, new PortData("bool", "result of equality check")));
+            RegisterAllPorts();
+        }
+
+        public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode> inputAstNodes)
+        {
+            if (!InPorts[0].IsConnected && !InPorts[1].IsConnected && !InPorts[2].IsConnected)
+            {
+                return new[] { AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), AstFactory.BuildNullNode()) };
+            }
+
+            AssociativeNode rhs;
+            if (IsPartiallyApplied)
+            {
+                var connectedInputs = Enumerable.Range(0, InPorts.Count)
+                    .Where(index => InPorts[index].IsConnected)
+                    .Select(x => new IntNode(x) as AssociativeNode)
+                    .ToList();
+                var arguments = AstFactory.BuildExprList(inputAstNodes);
+
+
+                var functionNode = new IdentifierListNode
+                {
+                    LeftNode = new IdentifierNode("DSCore.Math"),
+                    RightNode = new IdentifierNode("Equals")
+                };
+                IntNode paramNumNode = new IntNode(3);
+                var positionNode = AstFactory.BuildExprList(connectedInputs);
+
+                var inputParams = new List<AssociativeNode>
+                {
+                    functionNode,
+                    paramNumNode,
+                    positionNode,
+                    arguments,
+                    AstFactory.BuildBooleanNode(true)
+                };
+
+                rhs = AstFactory.BuildFunctionCall("__CreateFunctionObject", inputParams);
+            }
+            else
+            {
+                UseLevelAndReplicationGuide(inputAstNodes);
+
+                rhs = AstFactory.BuildFunctionCall(new Func<double, double, double, bool>(DSCore.Math.Equals),
+                    inputAstNodes);
+            }
+
+            return new[]
+            {
+                AstFactory.BuildAssignment(GetAstIdentifierForOutputIndex(0), rhs)
+            };
+        }
+    }
+}

src/Libraries/CoreNodeModels/Logic/If.cs

@@ -17,10 +17,15 @@ namespace CoreNodeModels.Logic
     public class If : NodeModel
     {
         [JsonConstructor]
-        private If(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(inPorts, outPorts) { }
+        private If(IEnumerable<PortModel> inPorts, IEnumerable<PortModel> outPorts) : base(inPorts, outPorts)
+        {
+            ArgumentLacing = LacingStrategy.Auto;
+        }
 
         public If()
         {
+            ArgumentLacing = LacingStrategy.Auto;
+
             InPorts.Add(new PortModel(PortType.Input, this, new PortData("test", Resources.PortDataTestBlockToolTip)));
             InPorts.Add(new PortModel(PortType.Input, this, new PortData("true", Resources.PortDataTrueBlockToolTip)));
             InPorts.Add(new PortModel(PortType.Input, this, new PortData("false", Resources.PortDataFalseBlockToolTip)));
@@ -58,6 +63,8 @@ public override IEnumerable<AssociativeNode> BuildOutputAst(List<AssociativeNode
             }
             else
             {
+                UseLevelAndReplicationGuide(inputAstNodes);
+
                 rhs = new InlineConditionalNode
                 {
                     ConditionExpression = inputAstNodes[0],

src/Libraries/CoreNodes/CoreNodes.csproj

@@ -97,6 +97,10 @@
       <Name>DynamoCore</Name>
       <Private>False</Private>
     </ProjectReference>
+    <ProjectReference Include="..\..\Engine\ProtoCore\ProtoCore.csproj">
+      <Project>{7a9e0314-966f-4584-baa3-7339cbb849d1}</Project>
+      <Name>ProtoCore</Name>
+    </ProjectReference>
     <ProjectReference Include="..\..\NodeServices\DynamoServices.csproj">
       <Project>{ef879a10-041d-4c68-83e7-3192685f1bae}</Project>
       <Name>DynamoServices</Name>

src/Libraries/CoreNodes/Math.cs

@@ -2,9 +2,11 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Windows.Media;
 using Autodesk.DesignScript.Runtime;
 using DSCore.Properties;
 using NCalc;
+using ProtoCore.Utils;
 using CSMath = System.Math;
 
 namespace DSCore
@@ -14,6 +16,10 @@ namespace DSCore
     /// </summary>
     public static class Math
     {
+        // This is chosen to be the same as the default tolerance used for VM equality operator.
+        // See ProtoCore\Utils\MathUtils.cs
+        private const double tolerance = MathUtils.Tolerance;
+
         /// <summary>
         ///     Generates a random double in the range of [0, 1).
         /// </summary>
@@ -200,6 +206,12 @@ public static double Abs(double number)
             return CSMath.Abs(number);
         }
 
+        [IsVisibleInDynamoLibrary(false)]
+        public static bool Equals(double lhs, double rhs, double tol = tolerance)
+        {
+            return MathUtils.Equals(lhs, rhs, tol);
+        }
+
         /// <summary>
         ///     Finds the absolute value of a number.
         /// </summary>

src/LibraryViewExtension/web/library/layoutSpecs.json

@@ -687,6 +687,9 @@
                 {
                   "path": "Operators.=="
                 },
+                {
+                  "path": "Core.Math.=="
+                },
                 {
                   "path": "Operators.>="
                 },

test/Engine/FFITarget/TestDefaultArgumentAttributes.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using Autodesk.DesignScript.Runtime;
 using FFITarget.DesignScript;
 
@@ -16,5 +18,10 @@ public static double ComputeCircleConflict([DefaultArgument("Point.ByCoordinates
         {
             return radius * radius * Math.PI;
         }
+
+        public static IEnumerable<Point> ComputeFlattenedPoints([DefaultArgument("FFITarget.DesignScript.Point.ByCoordinates((1..10)<1>, (2..20)<2>, 0)")]IEnumerable<IEnumerable<Point>> points)
+        {
+            return points.SelectMany(x => x);
+        }
     }
 }