1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- ADA.NUMERICS.BIG_NUMBERS.BIG_INTEGERS --
-- --
-- S p e c --
-- --
-- This specification is derived from the Ada Reference Manual for use with --
-- GNAT. In accordance with the copyright of that document, you can freely --
-- copy and modify this specification, provided that if you redistribute a --
-- modified version, any changes that you have made are clearly indicated. --
-- --
------------------------------------------------------------------------------
pragma Ada_2020;
with Ada.Strings.Text_Output; use Ada.Strings.Text_Output;
private with Ada.Finalization;
private with System;
-- Note that some Ada 2020 aspects are commented out since they are not
-- supported yet.
package Ada.Numerics.Big_Numbers.Big_Integers
with Preelaborate
is
type Big_Integer is private with
Integer_Literal => From_String,
Put_Image => Put_Image;
function Is_Valid (Arg : Big_Integer) return Boolean
with Convention => Intrinsic;
function "=" (L, R : Big_Integer) return Boolean;
function "<" (L, R : Big_Integer) return Boolean;
function "<=" (L, R : Big_Integer) return Boolean;
function ">" (L, R : Big_Integer) return Boolean;
function ">=" (L, R : Big_Integer) return Boolean;
function To_Big_Integer (Arg : Integer) return Big_Integer;
subtype Big_Positive is Big_Integer
with Dynamic_Predicate =>
(if Is_Valid (Big_Positive)
then Big_Positive > To_Big_Integer (0)),
Predicate_Failure => (raise Constraint_Error);
subtype Big_Natural is Big_Integer
with Dynamic_Predicate =>
(if Is_Valid (Big_Natural)
then Big_Natural >= To_Big_Integer (0)),
Predicate_Failure => (raise Constraint_Error);
function In_Range (Arg, Low, High : Big_Integer) return Boolean is
((Low <= Arg) and (Arg <= High));
function To_Integer (Arg : Big_Integer) return Integer
with Pre => In_Range (Arg,
Low => To_Big_Integer (Integer'First),
High => To_Big_Integer (Integer'Last))
or else (raise Constraint_Error);
generic
type Int is range <>;
package Signed_Conversions is
function To_Big_Integer (Arg : Int) return Big_Integer;
function From_Big_Integer (Arg : Big_Integer) return Int
with Pre => In_Range (Arg,
Low => To_Big_Integer (Int'First),
High => To_Big_Integer (Int'Last))
or else (raise Constraint_Error);
end Signed_Conversions;
generic
type Int is mod <>;
package Unsigned_Conversions is
function To_Big_Integer (Arg : Int) return Big_Integer;
function From_Big_Integer (Arg : Big_Integer) return Int
with Pre => In_Range (Arg,
Low => To_Big_Integer (Int'First),
High => To_Big_Integer (Int'Last))
or else (raise Constraint_Error);
end Unsigned_Conversions;
function To_String (Arg : Big_Integer;
Width : Field := 0;
Base : Number_Base := 10) return String
with Post => To_String'Result'First = 1;
function From_String (Arg : String) return Big_Integer;
procedure Put_Image (S : in out Sink'Class; V : Big_Integer);
function "+" (L : Big_Integer) return Big_Integer;
function "-" (L : Big_Integer) return Big_Integer;
function "abs" (L : Big_Integer) return Big_Integer;
function "+" (L, R : Big_Integer) return Big_Integer;
function "-" (L, R : Big_Integer) return Big_Integer;
function "*" (L, R : Big_Integer) return Big_Integer;
function "/" (L, R : Big_Integer) return Big_Integer;
function "mod" (L, R : Big_Integer) return Big_Integer;
function "rem" (L, R : Big_Integer) return Big_Integer;
function "**" (L : Big_Integer; R : Natural) return Big_Integer;
function Min (L, R : Big_Integer) return Big_Integer;
function Max (L, R : Big_Integer) return Big_Integer;
function Greatest_Common_Divisor
(L, R : Big_Integer) return Big_Positive
with Pre => (L /= To_Big_Integer (0) and R /= To_Big_Integer (0))
or else (raise Constraint_Error);
private
type Controlled_Bignum is new Ada.Finalization.Controlled with record
C : System.Address := System.Null_Address;
end record;
procedure Adjust (This : in out Controlled_Bignum);
procedure Finalize (This : in out Controlled_Bignum);
type Big_Integer is record
Value : Controlled_Bignum;
end record;
end Ada.Numerics.Big_Numbers.Big_Integers;
|
