/// <summary>
 /// The constructor of GOM_Assignment_Constraint
 /// </summary>
 /// <param name="lvalue">The lvalue of the assignment</param>
 /// <param name="rvalue">The rvalue of the assignment</param>
 public GOM_Assignment_Constraint(GOM_Interface_Value lvalue, GOM_Interface_Value rvalue)
 {
     m_values = new GOM_Values();
     m_values.Add(lvalue);
     m_values.Add(rvalue);
 }
 /// <summary>
 /// Add a interface into the list
 /// </summary>
 /// <param name="val">The interface being stored</param>
 public void Add(GOM_Interface_Value val)
 {
     rgValues.Add(val);
 }
        /// <summary>
        /// The constructor of GOM_Binary_Value
        /// </summary>
        /// <param name="val1">The first operand of this node</param>
        /// <param name="val2">The second operand of this node</param>
        /// <param name="type">The type of the operator</param>
        public GOM_Binary_Value(GOM_Interface_Value val1, GOM_Interface_Value val2, ValueType type)
        {
            m_values = new GOM_Values();
            m_values.Add(val1);
            m_values.Add(val2);
            m_type	= type;

            if ((type != ValueType.Add_Value) && (type != ValueType.Minus_Value) &&
                (type != ValueType.Divide_Value) && (type != ValueType.Multiply_Value) &&
                (type != ValueType.Max_Value) && (type != ValueType.Min_Value))
            {
                m_type = ValueType.Error_Value;
                throw new ArgumentException("Invalid type");
            }
        }
        /// <summary>
        /// The constructor of GOM_Unary_Value
        /// </summary>
        /// <param name="val">The operand</param>
        /// <param name="type">The type of the operator</param>
        public GOM_Unary_Value(GOM_Interface_Value val, ValueType type)
        {
            m_values = new GOM_Values();
            m_values.Add(val);
            m_type	= type;

            if ((type != ValueType.Sin_Value) && (type != ValueType.Cos_Value) &&
                (type != ValueType.Tan_Value) && (type != ValueType.Sqrt_Value) &&
                (type != ValueType.Neg_Value))
            {
                m_type = ValueType.Error_Value;
                throw new ArgumentException("Invalid type");
            }
        }
        /// <summary>
        /// Clone a value node
        /// </summary>
        /// <param name="valueNode">The original value node</param>
        /// <returns>If successful, a value node is returned. Otherwise, null is returned.</returns>
        private GOM_Interface_Value CloneValue(GOM_Interface_Value valueNode)
        {
            if (valueNode is GOM_Num_Value)
            {
                GOM_Num_Value	val;

                val = new GOM_Num_Value();
                val.Value = valueNode.Value;

                return valueNode;
            }

            if (valueNode is GOM_Point_Value)
            {
                return new GOM_Point_Value(Points(((GOM_Point_Value)valueNode).point.id), valueNode.Type);
            }

            if (valueNode is GOM_Unary_Value)
            {
                return new GOM_Unary_Value(CloneValue(valueNode.values[0]), valueNode.Type);
            }

            if (valueNode is GOM_Binary_Value)
            {
                return new GOM_Binary_Value(CloneValue(valueNode.values[0]), CloneValue(valueNode.values[1]), valueNode.Type);
            }

            return null;
        }