Common — library colibrilib.stdq — module Export

The functions without precondition, for the extraction: a division by zero raises Division_by_zero

757
module Export
758
use colibrilib.spec.Value
759
use int.Int
760
use real.RealInfix
761
use real.FromInt
762
use colibrilib.q.Real as Real
763
use number.Gcd as Gcd
764
use colibrilib.zarith.Z as Z
765
use colibrilib.zarith.Q as Q
766
use StdQ'impl
767
768
exception
DivZero
769
Valid (53ms) (colibri2)
770
let
div_e
(a b:Q.t) : Q.t
771
ensures { value2 Q.real (fun x y -> from_int (Real.div_e x y)) a b result }
772
raises { DivZero -> Q.real b = 0. }
773
= if is_zero b then raise DivZero; div_e a b
774
Valid (58ms) (colibri2)
775
let
div_t
(a b:Q.t) : Q.t
776
ensures { value2 Q.real (fun x y -> from_int (Real.div_t x y)) a b result }
777
raises { DivZero -> Q.real b = 0. }
778
= if is_zero b then raise DivZero; div_t a b
779
Valid (63ms) (colibri2)
780
let
div_f
(a b:Q.t) : Q.t
781
ensures { value2 Q.real (fun x y -> from_int (Real.div_f x y)) a b result }
782
raises { DivZero -> Q.real b = 0. }
783
= if is_zero b then raise DivZero; div_f a b
784
Valid (52ms) (colibri2)
785
let
mod_e
(a b:Q.t) : Q.t
786
ensures { value2 Q.real Real.mod_e a b result }
787
raises { DivZero -> Q.real b = 0. }
788
= if is_zero b then raise DivZero; mod_e a b
789
Valid (57ms) (colibri2)
790
let
mod_t
(a b:Q.t) : Q.t
791
ensures { value2 Q.real Real.mod_t a b result }
792
raises { DivZero -> Q.real b = 0. }
793
= if is_zero b then raise DivZero; mod_t a b
794
Valid (61ms) (colibri2)
795
let
mod_f
(a b:Q.t) : Q.t
796
ensures { value2 Q.real Real.mod_f a b result }
797
raises { DivZero -> Q.real b = 0. }
798
= if is_zero b then raise DivZero; mod_f a b
799
800
use real.Truncate

floor (a / m) * m: for m > 0, the largest multiple of m below a (StdQ.round_down_to)

  Valid (78ms) (colibri2)
804
let
round_down_to
(a m:Q.t) : Q.t
805
ensures { value0 Q.real (from_int (floor (Q.real a /. Q.real m)) *. Q.real m) result }
806
raises { DivZero -> Q.real m = 0. }
807
= if is_zero m then raise DivZero;
808
Q.mul (floor (Q.div a m)) m

ceil (a / m) * m

  Valid (78ms) (colibri2)
811
let
round_up_to
(a m:Q.t) : Q.t
812
ensures { value0 Q.real (from_int (ceil (Q.real a /. Q.real m)) *. Q.real m) result }
813
raises { DivZero -> Q.real m = 0. }
814
= if is_zero m then raise DivZero;
815
Q.mul (ceil (Q.div a m)) m
816
817
use mach.int.Int63
818
use real.PowerInt as RP
819
use PowRound as SP
820
821
exception
PowDomain

The power q^n (Std.Q.pow); PowDomain for a negative power of zero, or for min_int, whose opposite does not fit

  Valid (306ms) (colibri2)
825
let
pow
(q:Q.t) (n:int63) : Q.t
826
ensures { value1 Q.real (fun x -> if 0 <= n then RP.power x n else 1. /. RP.power x (- n)) q result }
827
raises { PowDomain -> (n < 0 /\ Q.real q = 0.) \/ n <= -0x4000000000000000 }
828
= if (n < 0 && is_zero q) || n = -0x4000000000000000 then raise PowDomain;
829
SP.pow q n

A number below q with a smaller denominator (PowRound.round_down_to_small)

  Valid (31ms) (colibri2)
833
let
round_down_to_small
[@spec:none "a rounding: any number below q"] (max_size_bit:int) (q:Q.t) : Q.t
834
ensures { Q.real result <=. Q.real q }
835
= SP.round_down_to_small max_size_bit q

A number above q with a smaller denominator (PowRound.round_up_to_small)

  Valid (38ms) (colibri2)
839
let
round_up_to_small
[@spec:none "a rounding: any number above q"] (max_size_bit:int) (q:Q.t) : Q.t
840
ensures { Q.real q <=. Q.real result }
841
= SP.round_up_to_small max_size_bit q
842
843
use colibrilib.dv.Dv
844
Valid (27ms) (colibri2)
845
let
is_integer
(q:Q.t) : bool
846
ensures { result <-> q.Q.den = 1 }
847
ensures { result <-> exists z. Q.real q = from_int z }
848
= StdQ'impl.is_integer q
849
Valid (30ms) (colibri2)
850
let
floor
(x:Q.t) : Q.t
851
ensures { result.Q.den = 1 }
852
ensures { Q.real result = from_int (Truncate.floor (Q.real x)) }
853
= StdQ'impl.floor x
854
Valid (34ms) (colibri2)
855
let
ceil
(x:Q.t) : Q.t
856
ensures { result.Q.den = 1 }
857
ensures { Q.real result = from_int (Truncate.ceil (Q.real x)) }
858
= StdQ'impl.ceil x
859
Valid (33ms) (colibri2)
860
let
truncate
(d:Q.t) : Q.t
861
ensures { result.Q.den = 1 }
862
ensures { Q.real result = from_int (Truncate.truncate (Q.real d)) }
863
= StdQ'impl.truncate d
864
Valid (33ms) (colibri2)
865
let
floor_z
(x:Q.t) : int
866
ensures { result = Truncate.floor (Q.real x) }
867
= StdQ'impl.floor_z x
868
Valid (31ms) (colibri2)
869
let
ceil_z
(x:Q.t) : int
870
ensures { result = Truncate.ceil (Q.real x) }
871
= StdQ'impl.ceil_z x
872
Valid (29ms) (colibri2)
873
let
truncate_z
(x:Q.t) : int
874
ensures { result = Truncate.truncate (Q.real x) }
875
= StdQ'impl.truncate_z x
876
Valid (27ms) (colibri2)
877
let
is_zero
(c:Q.t) : bool
878
ensures { result <-> Q.real c = 0. }
879
= StdQ'impl.is_zero c
880
Valid (26ms) (colibri2)
881
let
gcd
(a b:Q.t) : Q.t
882
ensures { Q.real result = from_int (Gcd.gcd a.Q.num b.Q.num) /. from_int (Z.lcm a.Q.den b.Q.den) }
883
ensures { 0. <=. Q.real result }
884
ensures { dv (Q.real a) (Q.real result) }
885
ensures { dv (Q.real b) (Q.real result) }
886
ensures { forall r. dv (Q.real a) r -> dv (Q.real b) r -> dv (Q.real result) r }
887
= StdQ'impl.gcd a b
888
Valid (28ms) (colibri2)
889
let
gcdext3
(a b:Q.t) : (g:Q.t, u:int, v:int)
890
ensures { 0. <=. Q.real g }
891
ensures { dv (Q.real a) (Q.real g) }
892
ensures { dv (Q.real b) (Q.real g) }
893
ensures { Q.real g = from_int u *. Q.real a +. from_int v *. Q.real b }
894
= StdQ'impl.gcdext3 a b
895
Valid (36ms) (colibri2)
896
let
lcm
(a b:Q.t) : Q.t
897
ensures { 0. <=. Q.real result }
898
ensures { dv (Q.real result) (Q.real a) }
899
ensures { dv (Q.real result) (Q.real b) }
900
ensures { forall r. dv r (Q.real a) -> dv r (Q.real b) -> dv r (Q.real result) }
901
= StdQ'impl.lcm a b
902
Valid (24ms) (colibri2)
903
let
divisible
(a b:Q.t) : bool
904
ensures { result <-> dv (Q.real a) (Q.real b) }
905
= let r, _ = StdQ'impl.divisible a b in r

Raised by divexact when a is not an integer multiple of b

908
exception
NotDivisible
909
Valid (39ms) (colibri2)
910
let
divexact
(a b:Q.t) : int
911
ensures { Q.real b <> 0. /\ Q.real a = from_int result *. Q.real b }
912
raises { NotDivisible -> Q.real b = 0. \/ not dv (Q.real a) (Q.real b) }
913
= if StdQ'impl.is_zero b then raise NotDivisible
914
else begin
915
let r, _ = StdQ'impl.divisible a b in
916
if r then StdQ'impl.divexact a b else raise NotDivisible
917
end
918
end