anchor.diff:      static member op_LessThan (n, nn) =
           match n, nn with
           | Z z, Z zz ->
  -            BigInteger.(<) (z,zz)
  -        | Q q, Q qq ->
  -            (BigRationalLarge.lt q qq)
  -        | Z z, Q qq ->
  -            (BigRationalLarge.lt (BigRationalLarge.of_bigint z) qq)
  -        | Q q, Z zz ->
  -            (BigRationalLarge.lt q (BigRationalLarge.of_bigint zz))
  +            z < zz
  +        | Q q, Q qq ->
  +            q < qq
  +        | Z z, Q qq ->
  +            BigRationalLarge.FromBigInteger z < qq
  +        | Q q, Z zz ->
  +            q < BigRationalLarge.FromBigInteger zz
   
       /// This operator is for use from other .NET languages
       static member op_LessThanOrEqual (n, nn) =
           match n, nn with
           | Z z, Z zz ->
  -            BigInteger.(<=) (z,zz)
  -        | Q q, Q qq ->
  -            (BigRationalLarge.lte q qq)
  -        | Z z, Q qq ->
  -            (BigRationalLarge.lte (BigRationalLarge.of_bigint z) qq)
  -        | Q q, Z zz ->
  -            (BigRationalLarge.lte q (BigRationalLarge.of_bigint zz))
  +            z <= zz
  +        | Q q, Q qq ->
  +            q <= qq
  +        | Z z, Q qq ->
  +            BigRationalLarge.FromBigInteger z <= qq
  +        | Q q, Z zz ->
  +            q <= BigRationalLarge.FromBigInteger zz
   
       /// This operator is for use from other .NET languages
       static member op_GreaterThan (n, nn) =
           match n, nn with
           | Z z, Z zz ->
  -            BigInteger.(>) (z,zz)
  -        | Q q, Q qq ->
  -            (BigRationalLarge.gt q qq)
  -        | Z z, Q qq ->
  -            (BigRationalLarge.gt (BigRationalLarge.of_bigint z) qq)
  -        | Q q, Z zz ->
  -            (BigRationalLarge.gt q (BigRationalLarge.of_bigint zz))
  +            z > zz
  +        | Q q, Q qq ->
  +            q > qq
  +        | Z z, Q qq ->
  +            BigRationalLarge.FromBigInteger z > qq
  +        | Q q, Z zz ->
  +            q > BigRationalLarge.FromBigInteger zz
   
       /// This operator is for use from other .NET languages
       static member op_GreaterThanOrEqual (n, nn) =
           match n, nn with
           | Z z, Z zz ->
  -            BigInteger.(>=) (z,zz)
  -        | Q q, Q qq ->
  -            (BigRationalLarge.gte q qq)
  -        | Z z, Q qq ->
  -            (BigRationalLarge.gte (BigRationalLarge.of_bigint z) qq)
  -        | Q q, Z zz ->
  -            (BigRationalLarge.gte q (BigRationalLarge.of_bigint zz))
  +            z >= zz
  +        | Q q, Q qq ->
  +            q >= qq
  +        | Z z, Q qq ->
  +            BigRationalLarge.FromBigInteger z >= qq
  +        | Q q, Z zz ->
  +            q >= BigRationalLarge.FromBigInteger zz
   
       /// Return the absolute value of a rational number
       static member Abs (n : BigRational) =
  
positive.code:             | _ ->
                  invalidArg "obj" "the object does not have the correct type"
  
  
  //
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module private BigRationalLarge =
      //
      let inv (Q (ap, aq)) =
          BigRationalLarge.Normalize (aq, ap)
  
      //
      let pown (Q (p, q)) (n:int) =
          // p,q powers still coprime
          Q (BigInteger.Pow (p, n), BigInteger.Pow (q, n))
  
      //
      let equal (Q (ap, aq)) (Q (bp, bq)) =
          // normal form, so structural equality
          ap = bp && aq = bq
      
      //
      let lt a b =
          BigRationalLarge.LessThan (a, b)
      
      //
      let gt a b =
          BigRationalLarge.LessThan (b, a)
      
      //
      let lte (Q(ap, aq)) (Q(bp, bq)) =
          BigInteger.(<=) (ap * bq,bp * aq)
      
      //
      let gte (Q(ap, aq)) (Q(bp, bq)) =
          BigInteger.(>=) (ap * bq, bp * aq)
  
      //
      let of_bigint z =
          BigRationalLarge.RationalZ(z,OneI)
  
      //
      let of_int n =
          BigRationalLarge.Rational(n,1)
  
      // integer part
      let integer (Q (p, q)) =
          let mutable r = BigInteger(0)
  
          // have p = d.q + r, |r| < |q|
          let d = BigInteger.DivRem (p, q, &r)
          if r < ZeroI then
              // p = (d-1).q + (r+q)
              d - OneI
          else
              // p = d.q + r
              d
  
  
  /// The type of arbitrary-sized rational numbers.
  [<CustomEquality; CustomComparison>]
  [<StructuredFormatDisplay("{StructuredDisplayString}N")>]
  type BigRational =
      private
      //
      | Z of BigInteger
      //
  
negative.code:     /// Return the denominator of the normalized rational number
      member this.Denominator =
          match this with
          | Z _ -> BigInteger.One
          | Q q -> q.Denominator
  
      /// Return a boolean indicating if this rational number is strictly negative
  