C# C语言中的条件表达式代数#

我正在研究使用布尔条件表达式的匹配系统的一小部分

这些条件表达式与一个变量和一个运算符相矛盾（边的大小写为Inclusive-Between）

我对以下方面感兴趣：

• 等于“=”
• 大于“>”
• 大于或等于“>=”
• 小于“=和1000”与“X>999”重叠？是。
  2） 如果存在重叠，则返回重叠：
  X>1000与“X>999”的重叠为“X>1000”
  3） 条件表达式是否受另一个条件表达式的约束
  “X<999”受“X<1000”约束；“X<1001”不受“X<1000”的约束

  ---

  到目前为止，我所做的是建立一个包含所有可能组合的真值表并返回结果，但我想知道是否有更简单的方法来计算这些组合

  ---

  有任何理论/参考资料/C#库吗？
  我没有听说过，但是如果你将约束表示为间隔，你可以很容易地不用它们：
  x>1000变为（1000，双倍无穷大）
  x==1000变为[10001000]
  等等
  这样你只需要一节课

  class Constraint
  {
      double Lower; bool isLowerStrict;
      double Upper; bool isUpperStrict;
      bool isIn(double d)
      { 
          return (isLowerStrict ? Lower < d : Lower <= d) &&
                 (isUpperStrict ? Upper > d : Upper >= d);
      }
  
      Constraint intersect(Constraint other)
      {
          Constraint result = new Constraint();
          if (Lower > other.Lower)
          {
              result.Lower = Lower;
              result.isLowerStrict = isLowerStrict;
          }
          else if (Lower < other.Lower)
          {
              result.Lower = other.Lower;
              result.isLowerStrict = other.isLowerStrict;
          }
          else
          {
              result.Lower = Lower;
              result.IsLowerStrict = isLowerStrict || other.isLowerStrict;
          }
          // the same for upper
          return result;
      }
  
      public bool isEmpty()
      {
          if (Lower > Upper) return true;
          if (Lower == Upper && (isLowerStrict || isUpperStrict)) return true;
          return false;
      }
      public bool Equals(Constraint other)
      {
          if (isEmpty()) return other.isEmpty();
          return (Lower == other.Lower) && (Upper = other.Upper) &&
                 (isLowerStrict == other.IsLowerStrict) &&
                 (isUpperStrict == other.isUpperStrict);
      }
  
      // construction:
      static Constraint GreaterThan(double d)
      {
          return new Constraint()
          {
              Lower = d,
              isLowerStrict = true,
              Upper = double.PositiveInfinity,
              isUpperStrict = false
          };
      }
      static Constraint IsEqualTo(double d)
      {
          return new Constraint()
          {
              Lower = d,
              isLowerStrict = false,
              Upper = d,
              isUpperStrict = false
          };
      }
      // etc.
  }
  

  类约束
  {
  双下；布尔岛下；
  双上；布尔是严格的；
  布尔伊辛（双d）
  { 
  返回（isLowerStrict？下=d）；
  }
  约束相交（约束其他）
  {
  约束结果=新约束（）；
  如果（降低>其他。降低）
  {
  结果：较低=较低；
  result.isLowerStrict=isLowerStrict；
  }
  else if（较低<其他.较低）
  {
  结果.下限=其他.下限；
  result.islowerstrit=其他.islowerstrit；
  }
  其他的
  {
  结果：较低=较低；
  result.IsLowerStrict=IsLowerStrict | | other.IsLowerStrict；
  }
  //鞋面也一样
  返回结果；
  }
  公共图书馆是空的
  {
  如果（下限>上限）返回true；
  如果（Lower==Upper&（isLowerStrict | | isUpperStrict））返回true；
  返回false；
  }
  公共布尔等于（其他约束）
  {
  if（isEmpty（））返回other.isEmpty（）；
  返回值（下限==其他.下限）&&（上限=其他.上限）&&
  （isLowerStrict==其他.isLowerStrict）&&
  （isUpperStrict==other.isUpperStrict）；
  }
  //结构：
  大于（双d）的静态约束
  {
  返回新约束（）
  {
  下=d，
  isLowerStrict=true，
  上限=双正整数，
  isUpperStrict=false
  };
  }
  静态约束相等（双d）
  {
  返回新约束（）
  {
  下=d，
  isLowerStrict=false，
  上限=d，
  isUpperStrict=false
  };
  }
  //等等。
  }
  

  使用此代码，您可以回答以下问题：
  1） 重叠：

  a.Intersect（b.isEmpty（）

  2） 相交：

  a.相交（b）

  3） 约束：

  a.相交（b）.等于（a）

  ---

  编辑：
  

  ---

  正如@ Cordin混沌所建议的，你应该考虑用小数替换双。请注意，decimal缺少无限值，因此您应该使用decimal.MaxValue和decimal.MinValue。
  我已经快速编写了一些示例代码。希望它有意义：

  enum SygnType
  {
      More, Less, Equal
  }
  public class Representation
  {
      public SignType sign;
      public int value;
  }
  public class Range
  {
      public bool infinityNegative;
      public bool infinityPositive;
      public int minValue;
      public int maxValue;
      public Range(List<Representation> values)
      {
          infinityNegative=true;
          infinityPositive=true;
          foreach(var value in values)
          {
              if (value.sign==SignType.More)
              {
                  infinityNegative=false;
                  if (value>minValue)
                      minValue=value;
              }
              else if (value.sign==SignType.Less)
              {
                  infinityPositive=false;
                  if (value<maxValue)
                      maxValue=value;
              }
              else if (value.sign==SignType.Equal)
              {
                  infinityPositive=infinityNegative=false;
                  minValue=maxValue=value;
                  break;
              }
          }
      }
      public bool Overlaps(Range checkRange)
      {
          if (checkRange.infinityPositive)
              return CompareUpperLevelValue(checkRange); //this method should compare upper value overlapping
          else if (checkRange.infinityNegative)
              return CompareLowerLevelValue(checkRange); //this method should compare lower value overlapping
          else
              return CompareInterval(checkRange); //this method should compare interval
      }
      public bool CompareUpperLevelValue(Range checkRange)
      {
          if (checkRange.maxValue<maxValue)
              return true;
          else 
              return false
      }
      public bool CompareLowerLevelValue(Range checkRange)
      {
          if (checkRange.minValue>minValue)
              return true;
          else 
              return false
      }
      public bool CompareInterval(Range checkRange)
      {
          if ((checkRange.minValue>minValue)&&(checkRange.maxValue<maxValue))
              return true;
          else
              return false;
      }
  }
  

  enum SygnType
  {
  多、少、等
  }
  公共阶级代表
  {
  公共标志类型标志；
  公共价值观；
  }
  公共类范围
  {
  公共布尔不定式否定；
  公共布尔不定式正；
  公共价值；
  公共整数最大值；
  公共范围（列表值）
  {
  无限负=真；
  无限正=真；
  foreach（值中的var值）
  {
  if（value.sign==SignType.More）
  {
  不定式负=假；
  如果（值>最小值）
  最小值=最小值；
  }
  else if（value.sign==SignType.Less）
  {
  不定式正=假；
  if（valueminValue）&（checkRange.maxValueI）首先搜索“解线性不等式组”类似的。我会考虑使用<代码>十进制< /代码>。从文本中解析的限制可以精确地表示。@ CODENMLISH：在这种情况下，我会选择一个通用的数字类型。不确定你所说的弗拉德是什么意思。使用动态类型/运行时代码生成，但这是丑陋和缓慢的。@ Cordin Surrul:哦，我忘记C++的泛型与C++模板有很大的不同。在C++中，这是可能的（使用STD：：数字限制）。我喜欢这个答案。通过简单地将交点与原始交点进行比较来确定表达式是否有矛盾是一个很好的洞察。