z3 0.0.20160221 → 0.0.20160323

Sign up to get free protection for your applications and to get access to all the features.
Files changed (48) hide show
  1. checksums.yaml +4 -4
  2. data/README.md +3 -1
  3. data/examples/algebra_problems +24 -24
  4. data/examples/basic_int_math +8 -8
  5. data/examples/basic_logic +8 -8
  6. data/examples/bit_tricks +161 -0
  7. data/examples/bridges_solver +1 -1
  8. data/examples/clogic_puzzle_solver +135 -0
  9. data/examples/four_hackers_puzzle +194 -0
  10. data/examples/geometry_problem +11 -11
  11. data/examples/kakuro_solver +3 -3
  12. data/examples/kinematics_problems +37 -37
  13. data/examples/letter_connections_solver +11 -11
  14. data/examples/light_up_solver +5 -5
  15. data/examples/minisudoku_solver +4 -4
  16. data/examples/selfref_solver +35 -35
  17. data/examples/sudoku_solver +4 -4
  18. data/examples/verbal_arithmetic +2 -2
  19. data/lib/z3/exception.rb +25 -0
  20. data/lib/z3/func_decl.rb +7 -7
  21. data/lib/z3/interface.rb +255 -0
  22. data/lib/z3/low_level.rb +4 -6
  23. data/lib/z3/low_level_auto.rb +1551 -1547
  24. data/lib/z3/model.rb +3 -2
  25. data/lib/z3/solver.rb +65 -54
  26. data/lib/z3/sort/bitvec_sort.rb +40 -0
  27. data/lib/z3/sort/bool_sort.rb +31 -0
  28. data/lib/z3/sort/int_sort.rb +21 -0
  29. data/lib/z3/sort/real_sort.rb +36 -0
  30. data/lib/z3/sort/sort.rb +76 -0
  31. data/lib/z3/value/arith_value.rb +53 -0
  32. data/lib/z3/value/bitvec_value.rb +67 -0
  33. data/lib/z3/value/bool_value.rb +29 -0
  34. data/lib/z3/value/int_value.rb +7 -0
  35. data/lib/z3/value/real_value.rb +7 -0
  36. data/lib/z3/value/value.rb +48 -0
  37. data/lib/z3/very_low_level.rb +28 -45
  38. data/lib/z3/very_low_level_auto.rb +518 -516
  39. data/lib/z3.rb +23 -33
  40. data/spec/integration/bit_tricks_spec.rb +21 -0
  41. data/spec/model_spec.rb +9 -9
  42. data/spec/solver_spec.rb +2 -2
  43. data/spec/sort_spec.rb +38 -13
  44. data/spec/{ast_spec.rb → value_spec.rb} +60 -57
  45. metadata +21 -6
  46. data/lib/z3/ast.rb +0 -302
  47. data/lib/z3/sort.rb +0 -33
  48. /data/spec/integration/{bagic_int_math_spec.rb → basic_int_math_spec.rb} +0 -0
@@ -1,2063 +1,2067 @@
1
- def algebraic_add(ast1, ast2)
2
- Z3::VeryLowLevel.Z3_algebraic_add(_ctx_pointer, ast1._ast, ast2._ast)
3
- end
1
+ module Z3::LowLevel
2
+ class << self
3
+ def algebraic_add(ast1, ast2) #=> :ast_pointer
4
+ Z3::VeryLowLevel.Z3_algebraic_add(_ctx_pointer, ast1._ast, ast2._ast)
5
+ end
4
6
 
5
- def algebraic_div(ast1, ast2)
6
- Z3::VeryLowLevel.Z3_algebraic_div(_ctx_pointer, ast1._ast, ast2._ast)
7
- end
7
+ def algebraic_div(ast1, ast2) #=> :ast_pointer
8
+ Z3::VeryLowLevel.Z3_algebraic_div(_ctx_pointer, ast1._ast, ast2._ast)
9
+ end
8
10
 
9
- def algebraic_eq(ast1, ast2)
10
- Z3::VeryLowLevel.Z3_algebraic_eq(_ctx_pointer, ast1._ast, ast2._ast)
11
- end
11
+ def algebraic_eq(ast1, ast2) #=> :bool
12
+ Z3::VeryLowLevel.Z3_algebraic_eq(_ctx_pointer, ast1._ast, ast2._ast)
13
+ end
12
14
 
13
- def algebraic_ge(ast1, ast2)
14
- Z3::VeryLowLevel.Z3_algebraic_ge(_ctx_pointer, ast1._ast, ast2._ast)
15
- end
15
+ def algebraic_ge(ast1, ast2) #=> :bool
16
+ Z3::VeryLowLevel.Z3_algebraic_ge(_ctx_pointer, ast1._ast, ast2._ast)
17
+ end
16
18
 
17
- def algebraic_gt(ast1, ast2)
18
- Z3::VeryLowLevel.Z3_algebraic_gt(_ctx_pointer, ast1._ast, ast2._ast)
19
- end
19
+ def algebraic_gt(ast1, ast2) #=> :bool
20
+ Z3::VeryLowLevel.Z3_algebraic_gt(_ctx_pointer, ast1._ast, ast2._ast)
21
+ end
20
22
 
21
- def algebraic_is_neg(ast)
22
- Z3::VeryLowLevel.Z3_algebraic_is_neg(_ctx_pointer, ast._ast)
23
- end
23
+ def algebraic_is_neg(ast) #=> :bool
24
+ Z3::VeryLowLevel.Z3_algebraic_is_neg(_ctx_pointer, ast._ast)
25
+ end
24
26
 
25
- def algebraic_is_pos(ast)
26
- Z3::VeryLowLevel.Z3_algebraic_is_pos(_ctx_pointer, ast._ast)
27
- end
27
+ def algebraic_is_pos(ast) #=> :bool
28
+ Z3::VeryLowLevel.Z3_algebraic_is_pos(_ctx_pointer, ast._ast)
29
+ end
28
30
 
29
- def algebraic_is_value(ast)
30
- Z3::VeryLowLevel.Z3_algebraic_is_value(_ctx_pointer, ast._ast)
31
- end
31
+ def algebraic_is_value(ast) #=> :bool
32
+ Z3::VeryLowLevel.Z3_algebraic_is_value(_ctx_pointer, ast._ast)
33
+ end
32
34
 
33
- def algebraic_is_zero(ast)
34
- Z3::VeryLowLevel.Z3_algebraic_is_zero(_ctx_pointer, ast._ast)
35
- end
35
+ def algebraic_is_zero(ast) #=> :bool
36
+ Z3::VeryLowLevel.Z3_algebraic_is_zero(_ctx_pointer, ast._ast)
37
+ end
36
38
 
37
- def algebraic_le(ast1, ast2)
38
- Z3::VeryLowLevel.Z3_algebraic_le(_ctx_pointer, ast1._ast, ast2._ast)
39
- end
39
+ def algebraic_le(ast1, ast2) #=> :bool
40
+ Z3::VeryLowLevel.Z3_algebraic_le(_ctx_pointer, ast1._ast, ast2._ast)
41
+ end
40
42
 
41
- def algebraic_lt(ast1, ast2)
42
- Z3::VeryLowLevel.Z3_algebraic_lt(_ctx_pointer, ast1._ast, ast2._ast)
43
- end
43
+ def algebraic_lt(ast1, ast2) #=> :bool
44
+ Z3::VeryLowLevel.Z3_algebraic_lt(_ctx_pointer, ast1._ast, ast2._ast)
45
+ end
44
46
 
45
- def algebraic_mul(ast1, ast2)
46
- Z3::VeryLowLevel.Z3_algebraic_mul(_ctx_pointer, ast1._ast, ast2._ast)
47
- end
47
+ def algebraic_mul(ast1, ast2) #=> :ast_pointer
48
+ Z3::VeryLowLevel.Z3_algebraic_mul(_ctx_pointer, ast1._ast, ast2._ast)
49
+ end
48
50
 
49
- def algebraic_neq(ast1, ast2)
50
- Z3::VeryLowLevel.Z3_algebraic_neq(_ctx_pointer, ast1._ast, ast2._ast)
51
- end
51
+ def algebraic_neq(ast1, ast2) #=> :bool
52
+ Z3::VeryLowLevel.Z3_algebraic_neq(_ctx_pointer, ast1._ast, ast2._ast)
53
+ end
52
54
 
53
- def algebraic_power(ast, num)
54
- Z3::VeryLowLevel.Z3_algebraic_power(_ctx_pointer, ast._ast, num)
55
- end
55
+ def algebraic_power(ast, num) #=> :ast_pointer
56
+ Z3::VeryLowLevel.Z3_algebraic_power(_ctx_pointer, ast._ast, num)
57
+ end
56
58
 
57
- def algebraic_root(ast, num)
58
- Z3::VeryLowLevel.Z3_algebraic_root(_ctx_pointer, ast._ast, num)
59
- end
59
+ def algebraic_root(ast, num) #=> :ast_pointer
60
+ Z3::VeryLowLevel.Z3_algebraic_root(_ctx_pointer, ast._ast, num)
61
+ end
60
62
 
61
- def algebraic_sign(ast)
62
- Z3::VeryLowLevel.Z3_algebraic_sign(_ctx_pointer, ast._ast)
63
- end
63
+ def algebraic_sign(ast) #=> :int
64
+ Z3::VeryLowLevel.Z3_algebraic_sign(_ctx_pointer, ast._ast)
65
+ end
64
66
 
65
- def algebraic_sub(ast1, ast2)
66
- Z3::VeryLowLevel.Z3_algebraic_sub(_ctx_pointer, ast1._ast, ast2._ast)
67
- end
67
+ def algebraic_sub(ast1, ast2) #=> :ast_pointer
68
+ Z3::VeryLowLevel.Z3_algebraic_sub(_ctx_pointer, ast1._ast, ast2._ast)
69
+ end
68
70
 
69
- def app_to_ast(app)
70
- Z3::VeryLowLevel.Z3_app_to_ast(_ctx_pointer, app._app)
71
- end
71
+ def app_to_ast(app) #=> :ast_pointer
72
+ Z3::VeryLowLevel.Z3_app_to_ast(_ctx_pointer, app._app)
73
+ end
72
74
 
73
- def apply_result_convert_model(apply_result, num, model)
74
- Z3::VeryLowLevel.Z3_apply_result_convert_model(_ctx_pointer, apply_result._apply_result, num, model._model)
75
- end
75
+ def apply_result_convert_model(apply_result, num, model) #=> :model_pointer
76
+ Z3::VeryLowLevel.Z3_apply_result_convert_model(_ctx_pointer, apply_result._apply_result, num, model._model)
77
+ end
76
78
 
77
- def apply_result_dec_ref(apply_result)
78
- Z3::VeryLowLevel.Z3_apply_result_dec_ref(_ctx_pointer, apply_result._apply_result)
79
- end
79
+ def apply_result_dec_ref(apply_result) #=> :void
80
+ Z3::VeryLowLevel.Z3_apply_result_dec_ref(_ctx_pointer, apply_result._apply_result)
81
+ end
80
82
 
81
- def apply_result_get_num_subgoals(apply_result)
82
- Z3::VeryLowLevel.Z3_apply_result_get_num_subgoals(_ctx_pointer, apply_result._apply_result)
83
- end
83
+ def apply_result_get_num_subgoals(apply_result) #=> :uint
84
+ Z3::VeryLowLevel.Z3_apply_result_get_num_subgoals(_ctx_pointer, apply_result._apply_result)
85
+ end
84
86
 
85
- def apply_result_get_subgoal(apply_result, num)
86
- Z3::VeryLowLevel.Z3_apply_result_get_subgoal(_ctx_pointer, apply_result._apply_result, num)
87
- end
87
+ def apply_result_get_subgoal(apply_result, num) #=> :goal_pointer
88
+ Z3::VeryLowLevel.Z3_apply_result_get_subgoal(_ctx_pointer, apply_result._apply_result, num)
89
+ end
88
90
 
89
- def apply_result_inc_ref(apply_result)
90
- Z3::VeryLowLevel.Z3_apply_result_inc_ref(_ctx_pointer, apply_result._apply_result)
91
- end
91
+ def apply_result_inc_ref(apply_result) #=> :void
92
+ Z3::VeryLowLevel.Z3_apply_result_inc_ref(_ctx_pointer, apply_result._apply_result)
93
+ end
92
94
 
93
- def apply_result_to_string(apply_result)
94
- Z3::VeryLowLevel.Z3_apply_result_to_string(_ctx_pointer, apply_result._apply_result)
95
- end
95
+ def apply_result_to_string(apply_result) #=> :string
96
+ Z3::VeryLowLevel.Z3_apply_result_to_string(_ctx_pointer, apply_result._apply_result)
97
+ end
96
98
 
97
- def ast_map_contains(ast_map, ast)
98
- Z3::VeryLowLevel.Z3_ast_map_contains(_ctx_pointer, ast_map._ast_map, ast._ast)
99
- end
99
+ def ast_map_contains(ast_map, ast) #=> :bool
100
+ Z3::VeryLowLevel.Z3_ast_map_contains(_ctx_pointer, ast_map._ast_map, ast._ast)
101
+ end
100
102
 
101
- def ast_map_dec_ref(ast_map)
102
- Z3::VeryLowLevel.Z3_ast_map_dec_ref(_ctx_pointer, ast_map._ast_map)
103
- end
103
+ def ast_map_dec_ref(ast_map) #=> :void
104
+ Z3::VeryLowLevel.Z3_ast_map_dec_ref(_ctx_pointer, ast_map._ast_map)
105
+ end
104
106
 
105
- def ast_map_erase(ast_map, ast)
106
- Z3::VeryLowLevel.Z3_ast_map_erase(_ctx_pointer, ast_map._ast_map, ast._ast)
107
- end
107
+ def ast_map_erase(ast_map, ast) #=> :void
108
+ Z3::VeryLowLevel.Z3_ast_map_erase(_ctx_pointer, ast_map._ast_map, ast._ast)
109
+ end
108
110
 
109
- def ast_map_find(ast_map, ast)
110
- Z3::VeryLowLevel.Z3_ast_map_find(_ctx_pointer, ast_map._ast_map, ast._ast)
111
- end
111
+ def ast_map_find(ast_map, ast) #=> :ast_pointer
112
+ Z3::VeryLowLevel.Z3_ast_map_find(_ctx_pointer, ast_map._ast_map, ast._ast)
113
+ end
112
114
 
113
- def ast_map_inc_ref(ast_map)
114
- Z3::VeryLowLevel.Z3_ast_map_inc_ref(_ctx_pointer, ast_map._ast_map)
115
- end
115
+ def ast_map_inc_ref(ast_map) #=> :void
116
+ Z3::VeryLowLevel.Z3_ast_map_inc_ref(_ctx_pointer, ast_map._ast_map)
117
+ end
116
118
 
117
- def ast_map_insert(ast_map, ast1, ast2)
118
- Z3::VeryLowLevel.Z3_ast_map_insert(_ctx_pointer, ast_map._ast_map, ast1._ast, ast2._ast)
119
- end
119
+ def ast_map_insert(ast_map, ast1, ast2) #=> :void
120
+ Z3::VeryLowLevel.Z3_ast_map_insert(_ctx_pointer, ast_map._ast_map, ast1._ast, ast2._ast)
121
+ end
120
122
 
121
- def ast_map_keys(ast_map)
122
- Z3::VeryLowLevel.Z3_ast_map_keys(_ctx_pointer, ast_map._ast_map)
123
- end
123
+ def ast_map_keys(ast_map) #=> :ast_vector_pointer
124
+ Z3::VeryLowLevel.Z3_ast_map_keys(_ctx_pointer, ast_map._ast_map)
125
+ end
124
126
 
125
- def ast_map_reset(ast_map)
126
- Z3::VeryLowLevel.Z3_ast_map_reset(_ctx_pointer, ast_map._ast_map)
127
- end
127
+ def ast_map_reset(ast_map) #=> :void
128
+ Z3::VeryLowLevel.Z3_ast_map_reset(_ctx_pointer, ast_map._ast_map)
129
+ end
128
130
 
129
- def ast_map_size(ast_map)
130
- Z3::VeryLowLevel.Z3_ast_map_size(_ctx_pointer, ast_map._ast_map)
131
- end
131
+ def ast_map_size(ast_map) #=> :uint
132
+ Z3::VeryLowLevel.Z3_ast_map_size(_ctx_pointer, ast_map._ast_map)
133
+ end
132
134
 
133
- def ast_map_to_string(ast_map)
134
- Z3::VeryLowLevel.Z3_ast_map_to_string(_ctx_pointer, ast_map._ast_map)
135
- end
135
+ def ast_map_to_string(ast_map) #=> :string
136
+ Z3::VeryLowLevel.Z3_ast_map_to_string(_ctx_pointer, ast_map._ast_map)
137
+ end
136
138
 
137
- def ast_to_string(ast)
138
- Z3::VeryLowLevel.Z3_ast_to_string(_ctx_pointer, ast._ast)
139
- end
139
+ def ast_to_string(ast) #=> :string
140
+ Z3::VeryLowLevel.Z3_ast_to_string(_ctx_pointer, ast._ast)
141
+ end
140
142
 
141
- def ast_vector_dec_ref(ast_vector)
142
- Z3::VeryLowLevel.Z3_ast_vector_dec_ref(_ctx_pointer, ast_vector._ast_vector)
143
- end
143
+ def ast_vector_dec_ref(ast_vector) #=> :void
144
+ Z3::VeryLowLevel.Z3_ast_vector_dec_ref(_ctx_pointer, ast_vector._ast_vector)
145
+ end
144
146
 
145
- def ast_vector_get(ast_vector, num)
146
- Z3::VeryLowLevel.Z3_ast_vector_get(_ctx_pointer, ast_vector._ast_vector, num)
147
- end
147
+ def ast_vector_get(ast_vector, num) #=> :ast_pointer
148
+ Z3::VeryLowLevel.Z3_ast_vector_get(_ctx_pointer, ast_vector._ast_vector, num)
149
+ end
148
150
 
149
- def ast_vector_inc_ref(ast_vector)
150
- Z3::VeryLowLevel.Z3_ast_vector_inc_ref(_ctx_pointer, ast_vector._ast_vector)
151
- end
151
+ def ast_vector_inc_ref(ast_vector) #=> :void
152
+ Z3::VeryLowLevel.Z3_ast_vector_inc_ref(_ctx_pointer, ast_vector._ast_vector)
153
+ end
152
154
 
153
- def ast_vector_push(ast_vector, ast)
154
- Z3::VeryLowLevel.Z3_ast_vector_push(_ctx_pointer, ast_vector._ast_vector, ast._ast)
155
- end
155
+ def ast_vector_push(ast_vector, ast) #=> :void
156
+ Z3::VeryLowLevel.Z3_ast_vector_push(_ctx_pointer, ast_vector._ast_vector, ast._ast)
157
+ end
156
158
 
157
- def ast_vector_resize(ast_vector, num)
158
- Z3::VeryLowLevel.Z3_ast_vector_resize(_ctx_pointer, ast_vector._ast_vector, num)
159
- end
159
+ def ast_vector_resize(ast_vector, num) #=> :void
160
+ Z3::VeryLowLevel.Z3_ast_vector_resize(_ctx_pointer, ast_vector._ast_vector, num)
161
+ end
160
162
 
161
- def ast_vector_set(ast_vector, num, ast)
162
- Z3::VeryLowLevel.Z3_ast_vector_set(_ctx_pointer, ast_vector._ast_vector, num, ast._ast)
163
- end
163
+ def ast_vector_set(ast_vector, num, ast) #=> :void
164
+ Z3::VeryLowLevel.Z3_ast_vector_set(_ctx_pointer, ast_vector._ast_vector, num, ast._ast)
165
+ end
164
166
 
165
- def ast_vector_size(ast_vector)
166
- Z3::VeryLowLevel.Z3_ast_vector_size(_ctx_pointer, ast_vector._ast_vector)
167
- end
167
+ def ast_vector_size(ast_vector) #=> :uint
168
+ Z3::VeryLowLevel.Z3_ast_vector_size(_ctx_pointer, ast_vector._ast_vector)
169
+ end
168
170
 
169
- def ast_vector_to_string(ast_vector)
170
- Z3::VeryLowLevel.Z3_ast_vector_to_string(_ctx_pointer, ast_vector._ast_vector)
171
- end
171
+ def ast_vector_to_string(ast_vector) #=> :string
172
+ Z3::VeryLowLevel.Z3_ast_vector_to_string(_ctx_pointer, ast_vector._ast_vector)
173
+ end
172
174
 
173
- def ast_vector_translate(ast_vector, context)
174
- Z3::VeryLowLevel.Z3_ast_vector_translate(_ctx_pointer, ast_vector._ast_vector, context._context)
175
- end
175
+ def ast_vector_translate(ast_vector, context) #=> :ast_vector_pointer
176
+ Z3::VeryLowLevel.Z3_ast_vector_translate(_ctx_pointer, ast_vector._ast_vector, context._context)
177
+ end
176
178
 
177
- def datatype_update_field(func_decl, ast1, ast2)
178
- Z3::VeryLowLevel.Z3_datatype_update_field(_ctx_pointer, func_decl._func_decl, ast1._ast, ast2._ast)
179
- end
179
+ def datatype_update_field(func_decl, ast1, ast2) #=> :ast_pointer
180
+ Z3::VeryLowLevel.Z3_datatype_update_field(_ctx_pointer, func_decl._func_decl, ast1._ast, ast2._ast)
181
+ end
180
182
 
181
- def dec_ref(ast)
182
- Z3::VeryLowLevel.Z3_dec_ref(_ctx_pointer, ast._ast)
183
- end
183
+ def dec_ref(ast) #=> :void
184
+ Z3::VeryLowLevel.Z3_dec_ref(_ctx_pointer, ast._ast)
185
+ end
184
186
 
185
- def del_config(config)
186
- Z3::VeryLowLevel.Z3_del_config(config._config)
187
- end
187
+ def del_config(config) #=> :void
188
+ Z3::VeryLowLevel.Z3_del_config(config._config)
189
+ end
188
190
 
189
- def del_constructor(constructor)
190
- Z3::VeryLowLevel.Z3_del_constructor(_ctx_pointer, constructor._constructor)
191
- end
191
+ def del_constructor(constructor) #=> :void
192
+ Z3::VeryLowLevel.Z3_del_constructor(_ctx_pointer, constructor._constructor)
193
+ end
192
194
 
193
- def del_constructor_list(constructor_list)
194
- Z3::VeryLowLevel.Z3_del_constructor_list(_ctx_pointer, constructor_list._constructor_list)
195
- end
195
+ def del_constructor_list(constructor_list) #=> :void
196
+ Z3::VeryLowLevel.Z3_del_constructor_list(_ctx_pointer, constructor_list._constructor_list)
197
+ end
196
198
 
197
- def del_context
198
- Z3::VeryLowLevel.Z3_del_context(_ctx_pointer)
199
- end
199
+ def del_context #=> :void
200
+ Z3::VeryLowLevel.Z3_del_context(_ctx_pointer)
201
+ end
200
202
 
201
- def disable_trace(str)
202
- Z3::VeryLowLevel.Z3_disable_trace(str)
203
- end
203
+ def disable_trace(str) #=> :void
204
+ Z3::VeryLowLevel.Z3_disable_trace(str)
205
+ end
204
206
 
205
- def enable_trace(str)
206
- Z3::VeryLowLevel.Z3_enable_trace(str)
207
- end
207
+ def enable_trace(str) #=> :void
208
+ Z3::VeryLowLevel.Z3_enable_trace(str)
209
+ end
208
210
 
209
- def finalize_memory
210
- Z3::VeryLowLevel.Z3_finalize_memory()
211
- end
211
+ def finalize_memory #=> :void
212
+ Z3::VeryLowLevel.Z3_finalize_memory()
213
+ end
212
214
 
213
- def fixedpoint_add_cover(fixedpoint, num, func_decl, ast)
214
- Z3::VeryLowLevel.Z3_fixedpoint_add_cover(_ctx_pointer, fixedpoint._fixedpoint, num, func_decl._func_decl, ast._ast)
215
- end
215
+ def fixedpoint_add_cover(fixedpoint, num, func_decl, ast) #=> :void
216
+ Z3::VeryLowLevel.Z3_fixedpoint_add_cover(_ctx_pointer, fixedpoint._fixedpoint, num, func_decl._func_decl, ast._ast)
217
+ end
216
218
 
217
- def fixedpoint_add_rule(fixedpoint, ast, sym)
218
- Z3::VeryLowLevel.Z3_fixedpoint_add_rule(_ctx_pointer, fixedpoint._fixedpoint, ast._ast, sym)
219
- end
219
+ def fixedpoint_add_rule(fixedpoint, ast, sym) #=> :void
220
+ Z3::VeryLowLevel.Z3_fixedpoint_add_rule(_ctx_pointer, fixedpoint._fixedpoint, ast._ast, sym)
221
+ end
220
222
 
221
- def fixedpoint_assert(fixedpoint, ast)
222
- Z3::VeryLowLevel.Z3_fixedpoint_assert(_ctx_pointer, fixedpoint._fixedpoint, ast._ast)
223
- end
223
+ def fixedpoint_assert(fixedpoint, ast) #=> :void
224
+ Z3::VeryLowLevel.Z3_fixedpoint_assert(_ctx_pointer, fixedpoint._fixedpoint, ast._ast)
225
+ end
224
226
 
225
- def fixedpoint_dec_ref(fixedpoint)
226
- Z3::VeryLowLevel.Z3_fixedpoint_dec_ref(_ctx_pointer, fixedpoint._fixedpoint)
227
- end
227
+ def fixedpoint_dec_ref(fixedpoint) #=> :void
228
+ Z3::VeryLowLevel.Z3_fixedpoint_dec_ref(_ctx_pointer, fixedpoint._fixedpoint)
229
+ end
228
230
 
229
- def fixedpoint_from_file(fixedpoint, str)
230
- Z3::VeryLowLevel.Z3_fixedpoint_from_file(_ctx_pointer, fixedpoint._fixedpoint, str)
231
- end
231
+ def fixedpoint_from_file(fixedpoint, str) #=> :ast_vector_pointer
232
+ Z3::VeryLowLevel.Z3_fixedpoint_from_file(_ctx_pointer, fixedpoint._fixedpoint, str)
233
+ end
232
234
 
233
- def fixedpoint_from_string(fixedpoint, str)
234
- Z3::VeryLowLevel.Z3_fixedpoint_from_string(_ctx_pointer, fixedpoint._fixedpoint, str)
235
- end
235
+ def fixedpoint_from_string(fixedpoint, str) #=> :ast_vector_pointer
236
+ Z3::VeryLowLevel.Z3_fixedpoint_from_string(_ctx_pointer, fixedpoint._fixedpoint, str)
237
+ end
236
238
 
237
- def fixedpoint_get_answer(fixedpoint)
238
- Z3::VeryLowLevel.Z3_fixedpoint_get_answer(_ctx_pointer, fixedpoint._fixedpoint)
239
- end
239
+ def fixedpoint_get_answer(fixedpoint) #=> :ast_pointer
240
+ Z3::VeryLowLevel.Z3_fixedpoint_get_answer(_ctx_pointer, fixedpoint._fixedpoint)
241
+ end
240
242
 
241
- def fixedpoint_get_assertions(fixedpoint)
242
- Z3::VeryLowLevel.Z3_fixedpoint_get_assertions(_ctx_pointer, fixedpoint._fixedpoint)
243
- end
243
+ def fixedpoint_get_assertions(fixedpoint) #=> :ast_vector_pointer
244
+ Z3::VeryLowLevel.Z3_fixedpoint_get_assertions(_ctx_pointer, fixedpoint._fixedpoint)
245
+ end
244
246
 
245
- def fixedpoint_get_cover_delta(fixedpoint, num, func_decl)
246
- Z3::VeryLowLevel.Z3_fixedpoint_get_cover_delta(_ctx_pointer, fixedpoint._fixedpoint, num, func_decl._func_decl)
247
- end
247
+ def fixedpoint_get_cover_delta(fixedpoint, num, func_decl) #=> :ast_pointer
248
+ Z3::VeryLowLevel.Z3_fixedpoint_get_cover_delta(_ctx_pointer, fixedpoint._fixedpoint, num, func_decl._func_decl)
249
+ end
248
250
 
249
- def fixedpoint_get_help(fixedpoint)
250
- Z3::VeryLowLevel.Z3_fixedpoint_get_help(_ctx_pointer, fixedpoint._fixedpoint)
251
- end
251
+ def fixedpoint_get_help(fixedpoint) #=> :string
252
+ Z3::VeryLowLevel.Z3_fixedpoint_get_help(_ctx_pointer, fixedpoint._fixedpoint)
253
+ end
252
254
 
253
- def fixedpoint_get_num_levels(fixedpoint, func_decl)
254
- Z3::VeryLowLevel.Z3_fixedpoint_get_num_levels(_ctx_pointer, fixedpoint._fixedpoint, func_decl._func_decl)
255
- end
255
+ def fixedpoint_get_num_levels(fixedpoint, func_decl) #=> :uint
256
+ Z3::VeryLowLevel.Z3_fixedpoint_get_num_levels(_ctx_pointer, fixedpoint._fixedpoint, func_decl._func_decl)
257
+ end
256
258
 
257
- def fixedpoint_get_param_descrs(fixedpoint)
258
- Z3::VeryLowLevel.Z3_fixedpoint_get_param_descrs(_ctx_pointer, fixedpoint._fixedpoint)
259
- end
259
+ def fixedpoint_get_param_descrs(fixedpoint) #=> :param_descrs_pointer
260
+ Z3::VeryLowLevel.Z3_fixedpoint_get_param_descrs(_ctx_pointer, fixedpoint._fixedpoint)
261
+ end
260
262
 
261
- def fixedpoint_get_reason_unknown(fixedpoint)
262
- Z3::VeryLowLevel.Z3_fixedpoint_get_reason_unknown(_ctx_pointer, fixedpoint._fixedpoint)
263
- end
263
+ def fixedpoint_get_reason_unknown(fixedpoint) #=> :string
264
+ Z3::VeryLowLevel.Z3_fixedpoint_get_reason_unknown(_ctx_pointer, fixedpoint._fixedpoint)
265
+ end
264
266
 
265
- def fixedpoint_get_rules(fixedpoint)
266
- Z3::VeryLowLevel.Z3_fixedpoint_get_rules(_ctx_pointer, fixedpoint._fixedpoint)
267
- end
267
+ def fixedpoint_get_rules(fixedpoint) #=> :ast_vector_pointer
268
+ Z3::VeryLowLevel.Z3_fixedpoint_get_rules(_ctx_pointer, fixedpoint._fixedpoint)
269
+ end
268
270
 
269
- def fixedpoint_get_statistics(fixedpoint)
270
- Z3::VeryLowLevel.Z3_fixedpoint_get_statistics(_ctx_pointer, fixedpoint._fixedpoint)
271
- end
271
+ def fixedpoint_get_statistics(fixedpoint) #=> :stats_pointer
272
+ Z3::VeryLowLevel.Z3_fixedpoint_get_statistics(_ctx_pointer, fixedpoint._fixedpoint)
273
+ end
272
274
 
273
- def fixedpoint_inc_ref(fixedpoint)
274
- Z3::VeryLowLevel.Z3_fixedpoint_inc_ref(_ctx_pointer, fixedpoint._fixedpoint)
275
- end
275
+ def fixedpoint_inc_ref(fixedpoint) #=> :void
276
+ Z3::VeryLowLevel.Z3_fixedpoint_inc_ref(_ctx_pointer, fixedpoint._fixedpoint)
277
+ end
276
278
 
277
- def fixedpoint_pop(fixedpoint)
278
- Z3::VeryLowLevel.Z3_fixedpoint_pop(_ctx_pointer, fixedpoint._fixedpoint)
279
- end
279
+ def fixedpoint_pop(fixedpoint) #=> :void
280
+ Z3::VeryLowLevel.Z3_fixedpoint_pop(_ctx_pointer, fixedpoint._fixedpoint)
281
+ end
280
282
 
281
- def fixedpoint_push(fixedpoint)
282
- Z3::VeryLowLevel.Z3_fixedpoint_push(_ctx_pointer, fixedpoint._fixedpoint)
283
- end
283
+ def fixedpoint_push(fixedpoint) #=> :void
284
+ Z3::VeryLowLevel.Z3_fixedpoint_push(_ctx_pointer, fixedpoint._fixedpoint)
285
+ end
284
286
 
285
- def fixedpoint_query(fixedpoint, ast)
286
- Z3::VeryLowLevel.Z3_fixedpoint_query(_ctx_pointer, fixedpoint._fixedpoint, ast._ast)
287
- end
287
+ def fixedpoint_query(fixedpoint, ast) #=> :int
288
+ Z3::VeryLowLevel.Z3_fixedpoint_query(_ctx_pointer, fixedpoint._fixedpoint, ast._ast)
289
+ end
288
290
 
289
- def fixedpoint_register_relation(fixedpoint, func_decl)
290
- Z3::VeryLowLevel.Z3_fixedpoint_register_relation(_ctx_pointer, fixedpoint._fixedpoint, func_decl._func_decl)
291
- end
291
+ def fixedpoint_register_relation(fixedpoint, func_decl) #=> :void
292
+ Z3::VeryLowLevel.Z3_fixedpoint_register_relation(_ctx_pointer, fixedpoint._fixedpoint, func_decl._func_decl)
293
+ end
292
294
 
293
- def fixedpoint_set_params(fixedpoint, params)
294
- Z3::VeryLowLevel.Z3_fixedpoint_set_params(_ctx_pointer, fixedpoint._fixedpoint, params._params)
295
- end
295
+ def fixedpoint_set_params(fixedpoint, params) #=> :void
296
+ Z3::VeryLowLevel.Z3_fixedpoint_set_params(_ctx_pointer, fixedpoint._fixedpoint, params._params)
297
+ end
296
298
 
297
- def fixedpoint_update_rule(fixedpoint, ast, sym)
298
- Z3::VeryLowLevel.Z3_fixedpoint_update_rule(_ctx_pointer, fixedpoint._fixedpoint, ast._ast, sym)
299
- end
299
+ def fixedpoint_update_rule(fixedpoint, ast, sym) #=> :void
300
+ Z3::VeryLowLevel.Z3_fixedpoint_update_rule(_ctx_pointer, fixedpoint._fixedpoint, ast._ast, sym)
301
+ end
300
302
 
301
- def fpa_get_ebits(sort)
302
- Z3::VeryLowLevel.Z3_fpa_get_ebits(_ctx_pointer, sort._sort)
303
- end
303
+ def fpa_get_ebits(sort) #=> :uint
304
+ Z3::VeryLowLevel.Z3_fpa_get_ebits(_ctx_pointer, sort._sort)
305
+ end
304
306
 
305
- def fpa_get_numeral_exponent_string(ast)
306
- Z3::VeryLowLevel.Z3_fpa_get_numeral_exponent_string(_ctx_pointer, ast._ast)
307
- end
307
+ def fpa_get_numeral_exponent_string(ast) #=> :string
308
+ Z3::VeryLowLevel.Z3_fpa_get_numeral_exponent_string(_ctx_pointer, ast._ast)
309
+ end
308
310
 
309
- def fpa_get_numeral_significand_string(ast)
310
- Z3::VeryLowLevel.Z3_fpa_get_numeral_significand_string(_ctx_pointer, ast._ast)
311
- end
311
+ def fpa_get_numeral_significand_string(ast) #=> :string
312
+ Z3::VeryLowLevel.Z3_fpa_get_numeral_significand_string(_ctx_pointer, ast._ast)
313
+ end
312
314
 
313
- def fpa_get_sbits(sort)
314
- Z3::VeryLowLevel.Z3_fpa_get_sbits(_ctx_pointer, sort._sort)
315
- end
315
+ def fpa_get_sbits(sort) #=> :uint
316
+ Z3::VeryLowLevel.Z3_fpa_get_sbits(_ctx_pointer, sort._sort)
317
+ end
316
318
 
317
- def func_decl_to_ast(func_decl)
318
- Z3::VeryLowLevel.Z3_func_decl_to_ast(_ctx_pointer, func_decl._func_decl)
319
- end
319
+ def func_decl_to_ast(func_decl) #=> :ast_pointer
320
+ Z3::VeryLowLevel.Z3_func_decl_to_ast(_ctx_pointer, func_decl._func_decl)
321
+ end
320
322
 
321
- def func_decl_to_string(func_decl)
322
- Z3::VeryLowLevel.Z3_func_decl_to_string(_ctx_pointer, func_decl._func_decl)
323
- end
323
+ def func_decl_to_string(func_decl) #=> :string
324
+ Z3::VeryLowLevel.Z3_func_decl_to_string(_ctx_pointer, func_decl._func_decl)
325
+ end
324
326
 
325
- def func_entry_dec_ref(func_entry)
326
- Z3::VeryLowLevel.Z3_func_entry_dec_ref(_ctx_pointer, func_entry._func_entry)
327
- end
327
+ def func_entry_dec_ref(func_entry) #=> :void
328
+ Z3::VeryLowLevel.Z3_func_entry_dec_ref(_ctx_pointer, func_entry._func_entry)
329
+ end
328
330
 
329
- def func_entry_get_arg(func_entry, num)
330
- Z3::VeryLowLevel.Z3_func_entry_get_arg(_ctx_pointer, func_entry._func_entry, num)
331
- end
331
+ def func_entry_get_arg(func_entry, num) #=> :ast_pointer
332
+ Z3::VeryLowLevel.Z3_func_entry_get_arg(_ctx_pointer, func_entry._func_entry, num)
333
+ end
332
334
 
333
- def func_entry_get_num_args(func_entry)
334
- Z3::VeryLowLevel.Z3_func_entry_get_num_args(_ctx_pointer, func_entry._func_entry)
335
- end
335
+ def func_entry_get_num_args(func_entry) #=> :uint
336
+ Z3::VeryLowLevel.Z3_func_entry_get_num_args(_ctx_pointer, func_entry._func_entry)
337
+ end
336
338
 
337
- def func_entry_get_value(func_entry)
338
- Z3::VeryLowLevel.Z3_func_entry_get_value(_ctx_pointer, func_entry._func_entry)
339
- end
339
+ def func_entry_get_value(func_entry) #=> :ast_pointer
340
+ Z3::VeryLowLevel.Z3_func_entry_get_value(_ctx_pointer, func_entry._func_entry)
341
+ end
340
342
 
341
- def func_entry_inc_ref(func_entry)
342
- Z3::VeryLowLevel.Z3_func_entry_inc_ref(_ctx_pointer, func_entry._func_entry)
343
- end
343
+ def func_entry_inc_ref(func_entry) #=> :void
344
+ Z3::VeryLowLevel.Z3_func_entry_inc_ref(_ctx_pointer, func_entry._func_entry)
345
+ end
344
346
 
345
- def func_interp_dec_ref(func_interp)
346
- Z3::VeryLowLevel.Z3_func_interp_dec_ref(_ctx_pointer, func_interp._func_interp)
347
- end
347
+ def func_interp_dec_ref(func_interp) #=> :void
348
+ Z3::VeryLowLevel.Z3_func_interp_dec_ref(_ctx_pointer, func_interp._func_interp)
349
+ end
348
350
 
349
- def func_interp_get_arity(func_interp)
350
- Z3::VeryLowLevel.Z3_func_interp_get_arity(_ctx_pointer, func_interp._func_interp)
351
- end
351
+ def func_interp_get_arity(func_interp) #=> :uint
352
+ Z3::VeryLowLevel.Z3_func_interp_get_arity(_ctx_pointer, func_interp._func_interp)
353
+ end
352
354
 
353
- def func_interp_get_else(func_interp)
354
- Z3::VeryLowLevel.Z3_func_interp_get_else(_ctx_pointer, func_interp._func_interp)
355
- end
355
+ def func_interp_get_else(func_interp) #=> :ast_pointer
356
+ Z3::VeryLowLevel.Z3_func_interp_get_else(_ctx_pointer, func_interp._func_interp)
357
+ end
356
358
 
357
- def func_interp_get_entry(func_interp, num)
358
- Z3::VeryLowLevel.Z3_func_interp_get_entry(_ctx_pointer, func_interp._func_interp, num)
359
- end
359
+ def func_interp_get_entry(func_interp, num) #=> :func_entry_pointer
360
+ Z3::VeryLowLevel.Z3_func_interp_get_entry(_ctx_pointer, func_interp._func_interp, num)
361
+ end
360
362
 
361
- def func_interp_get_num_entries(func_interp)
362
- Z3::VeryLowLevel.Z3_func_interp_get_num_entries(_ctx_pointer, func_interp._func_interp)
363
- end
363
+ def func_interp_get_num_entries(func_interp) #=> :uint
364
+ Z3::VeryLowLevel.Z3_func_interp_get_num_entries(_ctx_pointer, func_interp._func_interp)
365
+ end
364
366
 
365
- def func_interp_inc_ref(func_interp)
366
- Z3::VeryLowLevel.Z3_func_interp_inc_ref(_ctx_pointer, func_interp._func_interp)
367
- end
367
+ def func_interp_inc_ref(func_interp) #=> :void
368
+ Z3::VeryLowLevel.Z3_func_interp_inc_ref(_ctx_pointer, func_interp._func_interp)
369
+ end
368
370
 
369
- def get_algebraic_number_lower(ast, num)
370
- Z3::VeryLowLevel.Z3_get_algebraic_number_lower(_ctx_pointer, ast._ast, num)
371
- end
371
+ def get_algebraic_number_lower(ast, num) #=> :ast_pointer
372
+ Z3::VeryLowLevel.Z3_get_algebraic_number_lower(_ctx_pointer, ast._ast, num)
373
+ end
372
374
 
373
- def get_algebraic_number_upper(ast, num)
374
- Z3::VeryLowLevel.Z3_get_algebraic_number_upper(_ctx_pointer, ast._ast, num)
375
- end
375
+ def get_algebraic_number_upper(ast, num) #=> :ast_pointer
376
+ Z3::VeryLowLevel.Z3_get_algebraic_number_upper(_ctx_pointer, ast._ast, num)
377
+ end
376
378
 
377
- def get_app_arg(app, num)
378
- Z3::VeryLowLevel.Z3_get_app_arg(_ctx_pointer, app._app, num)
379
- end
379
+ def get_app_arg(app, num) #=> :ast_pointer
380
+ Z3::VeryLowLevel.Z3_get_app_arg(_ctx_pointer, app._app, num)
381
+ end
380
382
 
381
- def get_app_decl(app)
382
- Z3::VeryLowLevel.Z3_get_app_decl(_ctx_pointer, app._app)
383
- end
383
+ def get_app_decl(app) #=> :func_decl_pointer
384
+ Z3::VeryLowLevel.Z3_get_app_decl(_ctx_pointer, app._app)
385
+ end
384
386
 
385
- def get_app_num_args(app)
386
- Z3::VeryLowLevel.Z3_get_app_num_args(_ctx_pointer, app._app)
387
- end
387
+ def get_app_num_args(app) #=> :uint
388
+ Z3::VeryLowLevel.Z3_get_app_num_args(_ctx_pointer, app._app)
389
+ end
388
390
 
389
- def get_arity(func_decl)
390
- Z3::VeryLowLevel.Z3_get_arity(_ctx_pointer, func_decl._func_decl)
391
- end
391
+ def get_arity(func_decl) #=> :uint
392
+ Z3::VeryLowLevel.Z3_get_arity(_ctx_pointer, func_decl._func_decl)
393
+ end
392
394
 
393
- def get_array_sort_domain(sort)
394
- Z3::VeryLowLevel.Z3_get_array_sort_domain(_ctx_pointer, sort._sort)
395
- end
395
+ def get_array_sort_domain(sort) #=> :sort_pointer
396
+ Z3::VeryLowLevel.Z3_get_array_sort_domain(_ctx_pointer, sort._sort)
397
+ end
396
398
 
397
- def get_array_sort_range(sort)
398
- Z3::VeryLowLevel.Z3_get_array_sort_range(_ctx_pointer, sort._sort)
399
- end
399
+ def get_array_sort_range(sort) #=> :sort_pointer
400
+ Z3::VeryLowLevel.Z3_get_array_sort_range(_ctx_pointer, sort._sort)
401
+ end
400
402
 
401
- def get_as_array_func_decl(ast)
402
- Z3::VeryLowLevel.Z3_get_as_array_func_decl(_ctx_pointer, ast._ast)
403
- end
403
+ def get_as_array_func_decl(ast) #=> :func_decl_pointer
404
+ Z3::VeryLowLevel.Z3_get_as_array_func_decl(_ctx_pointer, ast._ast)
405
+ end
404
406
 
405
- def get_ast_hash(ast)
406
- Z3::VeryLowLevel.Z3_get_ast_hash(_ctx_pointer, ast._ast)
407
- end
407
+ def get_ast_hash(ast) #=> :uint
408
+ Z3::VeryLowLevel.Z3_get_ast_hash(_ctx_pointer, ast._ast)
409
+ end
408
410
 
409
- def get_ast_id(ast)
410
- Z3::VeryLowLevel.Z3_get_ast_id(_ctx_pointer, ast._ast)
411
- end
411
+ def get_ast_id(ast) #=> :uint
412
+ Z3::VeryLowLevel.Z3_get_ast_id(_ctx_pointer, ast._ast)
413
+ end
412
414
 
413
- def get_ast_kind(ast)
414
- Z3::VeryLowLevel.Z3_get_ast_kind(_ctx_pointer, ast._ast)
415
- end
415
+ def get_ast_kind(ast) #=> :uint
416
+ Z3::VeryLowLevel.Z3_get_ast_kind(_ctx_pointer, ast._ast)
417
+ end
416
418
 
417
- def get_bool_value(ast)
418
- Z3::VeryLowLevel.Z3_get_bool_value(_ctx_pointer, ast._ast)
419
- end
419
+ def get_bool_value(ast) #=> :int
420
+ Z3::VeryLowLevel.Z3_get_bool_value(_ctx_pointer, ast._ast)
421
+ end
420
422
 
421
- def get_bv_sort_size(sort)
422
- Z3::VeryLowLevel.Z3_get_bv_sort_size(_ctx_pointer, sort._sort)
423
- end
423
+ def get_bv_sort_size(sort) #=> :uint
424
+ Z3::VeryLowLevel.Z3_get_bv_sort_size(_ctx_pointer, sort._sort)
425
+ end
424
426
 
425
- def get_datatype_sort_constructor(sort, num)
426
- Z3::VeryLowLevel.Z3_get_datatype_sort_constructor(_ctx_pointer, sort._sort, num)
427
- end
427
+ def get_datatype_sort_constructor(sort, num) #=> :func_decl_pointer
428
+ Z3::VeryLowLevel.Z3_get_datatype_sort_constructor(_ctx_pointer, sort._sort, num)
429
+ end
428
430
 
429
- def get_datatype_sort_constructor_accessor(sort, num1, num2)
430
- Z3::VeryLowLevel.Z3_get_datatype_sort_constructor_accessor(_ctx_pointer, sort._sort, num1, num2)
431
- end
431
+ def get_datatype_sort_constructor_accessor(sort, num1, num2) #=> :func_decl_pointer
432
+ Z3::VeryLowLevel.Z3_get_datatype_sort_constructor_accessor(_ctx_pointer, sort._sort, num1, num2)
433
+ end
432
434
 
433
- def get_datatype_sort_num_constructors(sort)
434
- Z3::VeryLowLevel.Z3_get_datatype_sort_num_constructors(_ctx_pointer, sort._sort)
435
- end
435
+ def get_datatype_sort_num_constructors(sort) #=> :uint
436
+ Z3::VeryLowLevel.Z3_get_datatype_sort_num_constructors(_ctx_pointer, sort._sort)
437
+ end
436
438
 
437
- def get_datatype_sort_recognizer(sort, num)
438
- Z3::VeryLowLevel.Z3_get_datatype_sort_recognizer(_ctx_pointer, sort._sort, num)
439
- end
439
+ def get_datatype_sort_recognizer(sort, num) #=> :func_decl_pointer
440
+ Z3::VeryLowLevel.Z3_get_datatype_sort_recognizer(_ctx_pointer, sort._sort, num)
441
+ end
440
442
 
441
- def get_decl_ast_parameter(func_decl, num)
442
- Z3::VeryLowLevel.Z3_get_decl_ast_parameter(_ctx_pointer, func_decl._func_decl, num)
443
- end
443
+ def get_decl_ast_parameter(func_decl, num) #=> :ast_pointer
444
+ Z3::VeryLowLevel.Z3_get_decl_ast_parameter(_ctx_pointer, func_decl._func_decl, num)
445
+ end
444
446
 
445
- def get_decl_double_parameter(func_decl, num)
446
- Z3::VeryLowLevel.Z3_get_decl_double_parameter(_ctx_pointer, func_decl._func_decl, num)
447
- end
447
+ def get_decl_double_parameter(func_decl, num) #=> :double
448
+ Z3::VeryLowLevel.Z3_get_decl_double_parameter(_ctx_pointer, func_decl._func_decl, num)
449
+ end
448
450
 
449
- def get_decl_func_decl_parameter(func_decl, num)
450
- Z3::VeryLowLevel.Z3_get_decl_func_decl_parameter(_ctx_pointer, func_decl._func_decl, num)
451
- end
451
+ def get_decl_func_decl_parameter(func_decl, num) #=> :func_decl_pointer
452
+ Z3::VeryLowLevel.Z3_get_decl_func_decl_parameter(_ctx_pointer, func_decl._func_decl, num)
453
+ end
452
454
 
453
- def get_decl_int_parameter(func_decl, num)
454
- Z3::VeryLowLevel.Z3_get_decl_int_parameter(_ctx_pointer, func_decl._func_decl, num)
455
- end
455
+ def get_decl_int_parameter(func_decl, num) #=> :int
456
+ Z3::VeryLowLevel.Z3_get_decl_int_parameter(_ctx_pointer, func_decl._func_decl, num)
457
+ end
456
458
 
457
- def get_decl_kind(func_decl)
458
- Z3::VeryLowLevel.Z3_get_decl_kind(_ctx_pointer, func_decl._func_decl)
459
- end
459
+ def get_decl_kind(func_decl) #=> :uint
460
+ Z3::VeryLowLevel.Z3_get_decl_kind(_ctx_pointer, func_decl._func_decl)
461
+ end
460
462
 
461
- def get_decl_name(func_decl)
462
- Z3::VeryLowLevel.Z3_get_decl_name(_ctx_pointer, func_decl._func_decl)
463
- end
463
+ def get_decl_name(func_decl) #=> :symbol_pointer
464
+ Z3::VeryLowLevel.Z3_get_decl_name(_ctx_pointer, func_decl._func_decl)
465
+ end
464
466
 
465
- def get_decl_num_parameters(func_decl)
466
- Z3::VeryLowLevel.Z3_get_decl_num_parameters(_ctx_pointer, func_decl._func_decl)
467
- end
467
+ def get_decl_num_parameters(func_decl) #=> :uint
468
+ Z3::VeryLowLevel.Z3_get_decl_num_parameters(_ctx_pointer, func_decl._func_decl)
469
+ end
468
470
 
469
- def get_decl_parameter_kind(func_decl, num)
470
- Z3::VeryLowLevel.Z3_get_decl_parameter_kind(_ctx_pointer, func_decl._func_decl, num)
471
- end
471
+ def get_decl_parameter_kind(func_decl, num) #=> :uint
472
+ Z3::VeryLowLevel.Z3_get_decl_parameter_kind(_ctx_pointer, func_decl._func_decl, num)
473
+ end
472
474
 
473
- def get_decl_rational_parameter(func_decl, num)
474
- Z3::VeryLowLevel.Z3_get_decl_rational_parameter(_ctx_pointer, func_decl._func_decl, num)
475
- end
475
+ def get_decl_rational_parameter(func_decl, num) #=> :string
476
+ Z3::VeryLowLevel.Z3_get_decl_rational_parameter(_ctx_pointer, func_decl._func_decl, num)
477
+ end
476
478
 
477
- def get_decl_sort_parameter(func_decl, num)
478
- Z3::VeryLowLevel.Z3_get_decl_sort_parameter(_ctx_pointer, func_decl._func_decl, num)
479
- end
479
+ def get_decl_sort_parameter(func_decl, num) #=> :sort_pointer
480
+ Z3::VeryLowLevel.Z3_get_decl_sort_parameter(_ctx_pointer, func_decl._func_decl, num)
481
+ end
480
482
 
481
- def get_decl_symbol_parameter(func_decl, num)
482
- Z3::VeryLowLevel.Z3_get_decl_symbol_parameter(_ctx_pointer, func_decl._func_decl, num)
483
- end
483
+ def get_decl_symbol_parameter(func_decl, num) #=> :symbol_pointer
484
+ Z3::VeryLowLevel.Z3_get_decl_symbol_parameter(_ctx_pointer, func_decl._func_decl, num)
485
+ end
484
486
 
485
- def get_denominator(ast)
486
- Z3::VeryLowLevel.Z3_get_denominator(_ctx_pointer, ast._ast)
487
- end
487
+ def get_denominator(ast) #=> :ast_pointer
488
+ Z3::VeryLowLevel.Z3_get_denominator(_ctx_pointer, ast._ast)
489
+ end
488
490
 
489
- def get_domain(func_decl, num)
490
- Z3::VeryLowLevel.Z3_get_domain(_ctx_pointer, func_decl._func_decl, num)
491
- end
491
+ def get_domain(func_decl, num) #=> :sort_pointer
492
+ Z3::VeryLowLevel.Z3_get_domain(_ctx_pointer, func_decl._func_decl, num)
493
+ end
492
494
 
493
- def get_domain_size(func_decl)
494
- Z3::VeryLowLevel.Z3_get_domain_size(_ctx_pointer, func_decl._func_decl)
495
- end
495
+ def get_domain_size(func_decl) #=> :uint
496
+ Z3::VeryLowLevel.Z3_get_domain_size(_ctx_pointer, func_decl._func_decl)
497
+ end
496
498
 
497
- def get_error_code
498
- Z3::VeryLowLevel.Z3_get_error_code(_ctx_pointer)
499
- end
499
+ def get_error_code #=> :uint
500
+ Z3::VeryLowLevel.Z3_get_error_code(_ctx_pointer)
501
+ end
500
502
 
501
- def get_func_decl_id(func_decl)
502
- Z3::VeryLowLevel.Z3_get_func_decl_id(_ctx_pointer, func_decl._func_decl)
503
- end
503
+ def get_func_decl_id(func_decl) #=> :uint
504
+ Z3::VeryLowLevel.Z3_get_func_decl_id(_ctx_pointer, func_decl._func_decl)
505
+ end
504
506
 
505
- def get_index_value(ast)
506
- Z3::VeryLowLevel.Z3_get_index_value(_ctx_pointer, ast._ast)
507
- end
507
+ def get_index_value(ast) #=> :uint
508
+ Z3::VeryLowLevel.Z3_get_index_value(_ctx_pointer, ast._ast)
509
+ end
508
510
 
509
- def get_interpolant(ast1, ast2, params)
510
- Z3::VeryLowLevel.Z3_get_interpolant(_ctx_pointer, ast1._ast, ast2._ast, params._params)
511
- end
511
+ def get_interpolant(ast1, ast2, params) #=> :ast_vector_pointer
512
+ Z3::VeryLowLevel.Z3_get_interpolant(_ctx_pointer, ast1._ast, ast2._ast, params._params)
513
+ end
512
514
 
513
- def get_num_probes
514
- Z3::VeryLowLevel.Z3_get_num_probes(_ctx_pointer)
515
- end
515
+ def get_num_probes #=> :uint
516
+ Z3::VeryLowLevel.Z3_get_num_probes(_ctx_pointer)
517
+ end
516
518
 
517
- def get_num_tactics
518
- Z3::VeryLowLevel.Z3_get_num_tactics(_ctx_pointer)
519
- end
519
+ def get_num_tactics #=> :uint
520
+ Z3::VeryLowLevel.Z3_get_num_tactics(_ctx_pointer)
521
+ end
520
522
 
521
- def get_numeral_decimal_string(ast, num)
522
- Z3::VeryLowLevel.Z3_get_numeral_decimal_string(_ctx_pointer, ast._ast, num)
523
- end
523
+ def get_numeral_decimal_string(ast, num) #=> :string
524
+ Z3::VeryLowLevel.Z3_get_numeral_decimal_string(_ctx_pointer, ast._ast, num)
525
+ end
524
526
 
525
- def get_numeral_string(ast)
526
- Z3::VeryLowLevel.Z3_get_numeral_string(_ctx_pointer, ast._ast)
527
- end
527
+ def get_numeral_string(ast) #=> :string
528
+ Z3::VeryLowLevel.Z3_get_numeral_string(_ctx_pointer, ast._ast)
529
+ end
528
530
 
529
- def get_numerator(ast)
530
- Z3::VeryLowLevel.Z3_get_numerator(_ctx_pointer, ast._ast)
531
- end
531
+ def get_numerator(ast) #=> :ast_pointer
532
+ Z3::VeryLowLevel.Z3_get_numerator(_ctx_pointer, ast._ast)
533
+ end
532
534
 
533
- def get_pattern(pattern, num)
534
- Z3::VeryLowLevel.Z3_get_pattern(_ctx_pointer, pattern._pattern, num)
535
- end
535
+ def get_pattern(pattern, num) #=> :ast_pointer
536
+ Z3::VeryLowLevel.Z3_get_pattern(_ctx_pointer, pattern._pattern, num)
537
+ end
536
538
 
537
- def get_pattern_num_terms(pattern)
538
- Z3::VeryLowLevel.Z3_get_pattern_num_terms(_ctx_pointer, pattern._pattern)
539
- end
539
+ def get_pattern_num_terms(pattern) #=> :uint
540
+ Z3::VeryLowLevel.Z3_get_pattern_num_terms(_ctx_pointer, pattern._pattern)
541
+ end
540
542
 
541
- def get_probe_name(num)
542
- Z3::VeryLowLevel.Z3_get_probe_name(_ctx_pointer, num)
543
- end
543
+ def get_probe_name(num) #=> :string
544
+ Z3::VeryLowLevel.Z3_get_probe_name(_ctx_pointer, num)
545
+ end
544
546
 
545
- def get_quantifier_body(ast)
546
- Z3::VeryLowLevel.Z3_get_quantifier_body(_ctx_pointer, ast._ast)
547
- end
547
+ def get_quantifier_body(ast) #=> :ast_pointer
548
+ Z3::VeryLowLevel.Z3_get_quantifier_body(_ctx_pointer, ast._ast)
549
+ end
548
550
 
549
- def get_quantifier_bound_name(ast, num)
550
- Z3::VeryLowLevel.Z3_get_quantifier_bound_name(_ctx_pointer, ast._ast, num)
551
- end
551
+ def get_quantifier_bound_name(ast, num) #=> :symbol_pointer
552
+ Z3::VeryLowLevel.Z3_get_quantifier_bound_name(_ctx_pointer, ast._ast, num)
553
+ end
552
554
 
553
- def get_quantifier_bound_sort(ast, num)
554
- Z3::VeryLowLevel.Z3_get_quantifier_bound_sort(_ctx_pointer, ast._ast, num)
555
- end
555
+ def get_quantifier_bound_sort(ast, num) #=> :sort_pointer
556
+ Z3::VeryLowLevel.Z3_get_quantifier_bound_sort(_ctx_pointer, ast._ast, num)
557
+ end
556
558
 
557
- def get_quantifier_no_pattern_ast(ast, num)
558
- Z3::VeryLowLevel.Z3_get_quantifier_no_pattern_ast(_ctx_pointer, ast._ast, num)
559
- end
559
+ def get_quantifier_no_pattern_ast(ast, num) #=> :ast_pointer
560
+ Z3::VeryLowLevel.Z3_get_quantifier_no_pattern_ast(_ctx_pointer, ast._ast, num)
561
+ end
560
562
 
561
- def get_quantifier_num_bound(ast)
562
- Z3::VeryLowLevel.Z3_get_quantifier_num_bound(_ctx_pointer, ast._ast)
563
- end
563
+ def get_quantifier_num_bound(ast) #=> :uint
564
+ Z3::VeryLowLevel.Z3_get_quantifier_num_bound(_ctx_pointer, ast._ast)
565
+ end
564
566
 
565
- def get_quantifier_num_no_patterns(ast)
566
- Z3::VeryLowLevel.Z3_get_quantifier_num_no_patterns(_ctx_pointer, ast._ast)
567
- end
567
+ def get_quantifier_num_no_patterns(ast) #=> :uint
568
+ Z3::VeryLowLevel.Z3_get_quantifier_num_no_patterns(_ctx_pointer, ast._ast)
569
+ end
568
570
 
569
- def get_quantifier_num_patterns(ast)
570
- Z3::VeryLowLevel.Z3_get_quantifier_num_patterns(_ctx_pointer, ast._ast)
571
- end
571
+ def get_quantifier_num_patterns(ast) #=> :uint
572
+ Z3::VeryLowLevel.Z3_get_quantifier_num_patterns(_ctx_pointer, ast._ast)
573
+ end
572
574
 
573
- def get_quantifier_pattern_ast(ast, num)
574
- Z3::VeryLowLevel.Z3_get_quantifier_pattern_ast(_ctx_pointer, ast._ast, num)
575
- end
575
+ def get_quantifier_pattern_ast(ast, num) #=> :pattern_pointer
576
+ Z3::VeryLowLevel.Z3_get_quantifier_pattern_ast(_ctx_pointer, ast._ast, num)
577
+ end
576
578
 
577
- def get_quantifier_weight(ast)
578
- Z3::VeryLowLevel.Z3_get_quantifier_weight(_ctx_pointer, ast._ast)
579
- end
579
+ def get_quantifier_weight(ast) #=> :uint
580
+ Z3::VeryLowLevel.Z3_get_quantifier_weight(_ctx_pointer, ast._ast)
581
+ end
580
582
 
581
- def get_range(func_decl)
582
- Z3::VeryLowLevel.Z3_get_range(_ctx_pointer, func_decl._func_decl)
583
- end
583
+ def get_range(func_decl) #=> :sort_pointer
584
+ Z3::VeryLowLevel.Z3_get_range(_ctx_pointer, func_decl._func_decl)
585
+ end
584
586
 
585
- def get_relation_arity(sort)
586
- Z3::VeryLowLevel.Z3_get_relation_arity(_ctx_pointer, sort._sort)
587
- end
587
+ def get_relation_arity(sort) #=> :uint
588
+ Z3::VeryLowLevel.Z3_get_relation_arity(_ctx_pointer, sort._sort)
589
+ end
588
590
 
589
- def get_relation_column(sort, num)
590
- Z3::VeryLowLevel.Z3_get_relation_column(_ctx_pointer, sort._sort, num)
591
- end
591
+ def get_relation_column(sort, num) #=> :sort_pointer
592
+ Z3::VeryLowLevel.Z3_get_relation_column(_ctx_pointer, sort._sort, num)
593
+ end
592
594
 
593
- def get_smtlib_assumption(num)
594
- Z3::VeryLowLevel.Z3_get_smtlib_assumption(_ctx_pointer, num)
595
- end
595
+ def get_smtlib_assumption(num) #=> :ast_pointer
596
+ Z3::VeryLowLevel.Z3_get_smtlib_assumption(_ctx_pointer, num)
597
+ end
596
598
 
597
- def get_smtlib_decl(num)
598
- Z3::VeryLowLevel.Z3_get_smtlib_decl(_ctx_pointer, num)
599
- end
599
+ def get_smtlib_decl(num) #=> :func_decl_pointer
600
+ Z3::VeryLowLevel.Z3_get_smtlib_decl(_ctx_pointer, num)
601
+ end
600
602
 
601
- def get_smtlib_error
602
- Z3::VeryLowLevel.Z3_get_smtlib_error(_ctx_pointer)
603
- end
603
+ def get_smtlib_error #=> :string
604
+ Z3::VeryLowLevel.Z3_get_smtlib_error(_ctx_pointer)
605
+ end
604
606
 
605
- def get_smtlib_formula(num)
606
- Z3::VeryLowLevel.Z3_get_smtlib_formula(_ctx_pointer, num)
607
- end
607
+ def get_smtlib_formula(num) #=> :ast_pointer
608
+ Z3::VeryLowLevel.Z3_get_smtlib_formula(_ctx_pointer, num)
609
+ end
608
610
 
609
- def get_smtlib_num_assumptions
610
- Z3::VeryLowLevel.Z3_get_smtlib_num_assumptions(_ctx_pointer)
611
- end
611
+ def get_smtlib_num_assumptions #=> :uint
612
+ Z3::VeryLowLevel.Z3_get_smtlib_num_assumptions(_ctx_pointer)
613
+ end
612
614
 
613
- def get_smtlib_num_decls
614
- Z3::VeryLowLevel.Z3_get_smtlib_num_decls(_ctx_pointer)
615
- end
615
+ def get_smtlib_num_decls #=> :uint
616
+ Z3::VeryLowLevel.Z3_get_smtlib_num_decls(_ctx_pointer)
617
+ end
616
618
 
617
- def get_smtlib_num_formulas
618
- Z3::VeryLowLevel.Z3_get_smtlib_num_formulas(_ctx_pointer)
619
- end
619
+ def get_smtlib_num_formulas #=> :uint
620
+ Z3::VeryLowLevel.Z3_get_smtlib_num_formulas(_ctx_pointer)
621
+ end
620
622
 
621
- def get_smtlib_num_sorts
622
- Z3::VeryLowLevel.Z3_get_smtlib_num_sorts(_ctx_pointer)
623
- end
623
+ def get_smtlib_num_sorts #=> :uint
624
+ Z3::VeryLowLevel.Z3_get_smtlib_num_sorts(_ctx_pointer)
625
+ end
624
626
 
625
- def get_smtlib_sort(num)
626
- Z3::VeryLowLevel.Z3_get_smtlib_sort(_ctx_pointer, num)
627
- end
627
+ def get_smtlib_sort(num) #=> :sort_pointer
628
+ Z3::VeryLowLevel.Z3_get_smtlib_sort(_ctx_pointer, num)
629
+ end
628
630
 
629
- def get_sort(ast)
630
- Z3::VeryLowLevel.Z3_get_sort(_ctx_pointer, ast._ast)
631
- end
631
+ def get_sort(ast) #=> :sort_pointer
632
+ Z3::VeryLowLevel.Z3_get_sort(_ctx_pointer, ast._ast)
633
+ end
632
634
 
633
- def get_sort_id(sort)
634
- Z3::VeryLowLevel.Z3_get_sort_id(_ctx_pointer, sort._sort)
635
- end
635
+ def get_sort_id(sort) #=> :uint
636
+ Z3::VeryLowLevel.Z3_get_sort_id(_ctx_pointer, sort._sort)
637
+ end
636
638
 
637
- def get_sort_kind(sort)
638
- Z3::VeryLowLevel.Z3_get_sort_kind(_ctx_pointer, sort._sort)
639
- end
639
+ def get_sort_kind(sort) #=> :uint
640
+ Z3::VeryLowLevel.Z3_get_sort_kind(_ctx_pointer, sort._sort)
641
+ end
640
642
 
641
- def get_sort_name(sort)
642
- Z3::VeryLowLevel.Z3_get_sort_name(_ctx_pointer, sort._sort)
643
- end
643
+ def get_sort_name(sort) #=> :symbol_pointer
644
+ Z3::VeryLowLevel.Z3_get_sort_name(_ctx_pointer, sort._sort)
645
+ end
644
646
 
645
- def get_symbol_int(sym)
646
- Z3::VeryLowLevel.Z3_get_symbol_int(_ctx_pointer, sym)
647
- end
647
+ def get_symbol_int(sym) #=> :int
648
+ Z3::VeryLowLevel.Z3_get_symbol_int(_ctx_pointer, sym)
649
+ end
648
650
 
649
- def get_symbol_kind(sym)
650
- Z3::VeryLowLevel.Z3_get_symbol_kind(_ctx_pointer, sym)
651
- end
651
+ def get_symbol_kind(sym) #=> :uint
652
+ Z3::VeryLowLevel.Z3_get_symbol_kind(_ctx_pointer, sym)
653
+ end
652
654
 
653
- def get_symbol_string(sym)
654
- Z3::VeryLowLevel.Z3_get_symbol_string(_ctx_pointer, sym)
655
- end
655
+ def get_symbol_string(sym) #=> :string
656
+ Z3::VeryLowLevel.Z3_get_symbol_string(_ctx_pointer, sym)
657
+ end
656
658
 
657
- def get_tactic_name(num)
658
- Z3::VeryLowLevel.Z3_get_tactic_name(_ctx_pointer, num)
659
- end
659
+ def get_tactic_name(num) #=> :string
660
+ Z3::VeryLowLevel.Z3_get_tactic_name(_ctx_pointer, num)
661
+ end
660
662
 
661
- def get_tuple_sort_field_decl(sort, num)
662
- Z3::VeryLowLevel.Z3_get_tuple_sort_field_decl(_ctx_pointer, sort._sort, num)
663
- end
663
+ def get_tuple_sort_field_decl(sort, num) #=> :func_decl_pointer
664
+ Z3::VeryLowLevel.Z3_get_tuple_sort_field_decl(_ctx_pointer, sort._sort, num)
665
+ end
664
666
 
665
- def get_tuple_sort_mk_decl(sort)
666
- Z3::VeryLowLevel.Z3_get_tuple_sort_mk_decl(_ctx_pointer, sort._sort)
667
- end
667
+ def get_tuple_sort_mk_decl(sort) #=> :func_decl_pointer
668
+ Z3::VeryLowLevel.Z3_get_tuple_sort_mk_decl(_ctx_pointer, sort._sort)
669
+ end
668
670
 
669
- def get_tuple_sort_num_fields(sort)
670
- Z3::VeryLowLevel.Z3_get_tuple_sort_num_fields(_ctx_pointer, sort._sort)
671
- end
671
+ def get_tuple_sort_num_fields(sort) #=> :uint
672
+ Z3::VeryLowLevel.Z3_get_tuple_sort_num_fields(_ctx_pointer, sort._sort)
673
+ end
672
674
 
673
- def global_param_reset_all
674
- Z3::VeryLowLevel.Z3_global_param_reset_all()
675
- end
675
+ def global_param_reset_all #=> :void
676
+ Z3::VeryLowLevel.Z3_global_param_reset_all()
677
+ end
676
678
 
677
- def global_param_set(str1, str2)
678
- Z3::VeryLowLevel.Z3_global_param_set(str1, str2)
679
- end
679
+ def global_param_set(str1, str2) #=> :void
680
+ Z3::VeryLowLevel.Z3_global_param_set(str1, str2)
681
+ end
680
682
 
681
- def goal_assert(goal, ast)
682
- Z3::VeryLowLevel.Z3_goal_assert(_ctx_pointer, goal._goal, ast._ast)
683
- end
683
+ def goal_assert(goal, ast) #=> :void
684
+ Z3::VeryLowLevel.Z3_goal_assert(_ctx_pointer, goal._goal, ast._ast)
685
+ end
684
686
 
685
- def goal_dec_ref(goal)
686
- Z3::VeryLowLevel.Z3_goal_dec_ref(_ctx_pointer, goal._goal)
687
- end
687
+ def goal_dec_ref(goal) #=> :void
688
+ Z3::VeryLowLevel.Z3_goal_dec_ref(_ctx_pointer, goal._goal)
689
+ end
688
690
 
689
- def goal_depth(goal)
690
- Z3::VeryLowLevel.Z3_goal_depth(_ctx_pointer, goal._goal)
691
- end
691
+ def goal_depth(goal) #=> :uint
692
+ Z3::VeryLowLevel.Z3_goal_depth(_ctx_pointer, goal._goal)
693
+ end
692
694
 
693
- def goal_formula(goal, num)
694
- Z3::VeryLowLevel.Z3_goal_formula(_ctx_pointer, goal._goal, num)
695
- end
695
+ def goal_formula(goal, num) #=> :ast_pointer
696
+ Z3::VeryLowLevel.Z3_goal_formula(_ctx_pointer, goal._goal, num)
697
+ end
696
698
 
697
- def goal_inc_ref(goal)
698
- Z3::VeryLowLevel.Z3_goal_inc_ref(_ctx_pointer, goal._goal)
699
- end
699
+ def goal_inc_ref(goal) #=> :void
700
+ Z3::VeryLowLevel.Z3_goal_inc_ref(_ctx_pointer, goal._goal)
701
+ end
700
702
 
701
- def goal_inconsistent(goal)
702
- Z3::VeryLowLevel.Z3_goal_inconsistent(_ctx_pointer, goal._goal)
703
- end
703
+ def goal_inconsistent(goal) #=> :bool
704
+ Z3::VeryLowLevel.Z3_goal_inconsistent(_ctx_pointer, goal._goal)
705
+ end
704
706
 
705
- def goal_is_decided_sat(goal)
706
- Z3::VeryLowLevel.Z3_goal_is_decided_sat(_ctx_pointer, goal._goal)
707
- end
707
+ def goal_is_decided_sat(goal) #=> :bool
708
+ Z3::VeryLowLevel.Z3_goal_is_decided_sat(_ctx_pointer, goal._goal)
709
+ end
708
710
 
709
- def goal_is_decided_unsat(goal)
710
- Z3::VeryLowLevel.Z3_goal_is_decided_unsat(_ctx_pointer, goal._goal)
711
- end
711
+ def goal_is_decided_unsat(goal) #=> :bool
712
+ Z3::VeryLowLevel.Z3_goal_is_decided_unsat(_ctx_pointer, goal._goal)
713
+ end
712
714
 
713
- def goal_num_exprs(goal)
714
- Z3::VeryLowLevel.Z3_goal_num_exprs(_ctx_pointer, goal._goal)
715
- end
715
+ def goal_num_exprs(goal) #=> :uint
716
+ Z3::VeryLowLevel.Z3_goal_num_exprs(_ctx_pointer, goal._goal)
717
+ end
716
718
 
717
- def goal_precision(goal)
718
- Z3::VeryLowLevel.Z3_goal_precision(_ctx_pointer, goal._goal)
719
- end
719
+ def goal_precision(goal) #=> :uint
720
+ Z3::VeryLowLevel.Z3_goal_precision(_ctx_pointer, goal._goal)
721
+ end
720
722
 
721
- def goal_reset(goal)
722
- Z3::VeryLowLevel.Z3_goal_reset(_ctx_pointer, goal._goal)
723
- end
723
+ def goal_reset(goal) #=> :void
724
+ Z3::VeryLowLevel.Z3_goal_reset(_ctx_pointer, goal._goal)
725
+ end
724
726
 
725
- def goal_size(goal)
726
- Z3::VeryLowLevel.Z3_goal_size(_ctx_pointer, goal._goal)
727
- end
727
+ def goal_size(goal) #=> :uint
728
+ Z3::VeryLowLevel.Z3_goal_size(_ctx_pointer, goal._goal)
729
+ end
728
730
 
729
- def goal_to_string(goal)
730
- Z3::VeryLowLevel.Z3_goal_to_string(_ctx_pointer, goal._goal)
731
- end
731
+ def goal_to_string(goal) #=> :string
732
+ Z3::VeryLowLevel.Z3_goal_to_string(_ctx_pointer, goal._goal)
733
+ end
732
734
 
733
- def goal_translate(goal, context)
734
- Z3::VeryLowLevel.Z3_goal_translate(_ctx_pointer, goal._goal, context._context)
735
- end
735
+ def goal_translate(goal, context) #=> :goal_pointer
736
+ Z3::VeryLowLevel.Z3_goal_translate(_ctx_pointer, goal._goal, context._context)
737
+ end
736
738
 
737
- def inc_ref(ast)
738
- Z3::VeryLowLevel.Z3_inc_ref(_ctx_pointer, ast._ast)
739
- end
739
+ def inc_ref(ast) #=> :void
740
+ Z3::VeryLowLevel.Z3_inc_ref(_ctx_pointer, ast._ast)
741
+ end
740
742
 
741
- def interpolation_profile
742
- Z3::VeryLowLevel.Z3_interpolation_profile(_ctx_pointer)
743
- end
743
+ def interpolation_profile #=> :string
744
+ Z3::VeryLowLevel.Z3_interpolation_profile(_ctx_pointer)
745
+ end
744
746
 
745
- def interrupt
746
- Z3::VeryLowLevel.Z3_interrupt(_ctx_pointer)
747
- end
747
+ def interrupt #=> :void
748
+ Z3::VeryLowLevel.Z3_interrupt(_ctx_pointer)
749
+ end
748
750
 
749
- def is_algebraic_number(ast)
750
- Z3::VeryLowLevel.Z3_is_algebraic_number(_ctx_pointer, ast._ast)
751
- end
751
+ def is_algebraic_number(ast) #=> :bool
752
+ Z3::VeryLowLevel.Z3_is_algebraic_number(_ctx_pointer, ast._ast)
753
+ end
752
754
 
753
- def is_app(ast)
754
- Z3::VeryLowLevel.Z3_is_app(_ctx_pointer, ast._ast)
755
- end
755
+ def is_app(ast) #=> :bool
756
+ Z3::VeryLowLevel.Z3_is_app(_ctx_pointer, ast._ast)
757
+ end
756
758
 
757
- def is_as_array(ast)
758
- Z3::VeryLowLevel.Z3_is_as_array(_ctx_pointer, ast._ast)
759
- end
759
+ def is_as_array(ast) #=> :bool
760
+ Z3::VeryLowLevel.Z3_is_as_array(_ctx_pointer, ast._ast)
761
+ end
760
762
 
761
- def is_eq_ast(ast1, ast2)
762
- Z3::VeryLowLevel.Z3_is_eq_ast(_ctx_pointer, ast1._ast, ast2._ast)
763
- end
763
+ def is_eq_ast(ast1, ast2) #=> :bool
764
+ Z3::VeryLowLevel.Z3_is_eq_ast(_ctx_pointer, ast1._ast, ast2._ast)
765
+ end
764
766
 
765
- def is_eq_func_decl(func_decl1, func_decl2)
766
- Z3::VeryLowLevel.Z3_is_eq_func_decl(_ctx_pointer, func_decl1._func_decl, func_decl2._func_decl)
767
- end
767
+ def is_eq_func_decl(func_decl1, func_decl2) #=> :bool
768
+ Z3::VeryLowLevel.Z3_is_eq_func_decl(_ctx_pointer, func_decl1._func_decl, func_decl2._func_decl)
769
+ end
768
770
 
769
- def is_eq_sort(sort1, sort2)
770
- Z3::VeryLowLevel.Z3_is_eq_sort(_ctx_pointer, sort1._sort, sort2._sort)
771
- end
771
+ def is_eq_sort(sort1, sort2) #=> :bool
772
+ Z3::VeryLowLevel.Z3_is_eq_sort(_ctx_pointer, sort1._sort, sort2._sort)
773
+ end
772
774
 
773
- def is_numeral_ast(ast)
774
- Z3::VeryLowLevel.Z3_is_numeral_ast(_ctx_pointer, ast._ast)
775
- end
775
+ def is_numeral_ast(ast) #=> :bool
776
+ Z3::VeryLowLevel.Z3_is_numeral_ast(_ctx_pointer, ast._ast)
777
+ end
776
778
 
777
- def is_quantifier_forall(ast)
778
- Z3::VeryLowLevel.Z3_is_quantifier_forall(_ctx_pointer, ast._ast)
779
- end
779
+ def is_quantifier_forall(ast) #=> :bool
780
+ Z3::VeryLowLevel.Z3_is_quantifier_forall(_ctx_pointer, ast._ast)
781
+ end
780
782
 
781
- def is_well_sorted(ast)
782
- Z3::VeryLowLevel.Z3_is_well_sorted(_ctx_pointer, ast._ast)
783
- end
783
+ def is_well_sorted(ast) #=> :bool
784
+ Z3::VeryLowLevel.Z3_is_well_sorted(_ctx_pointer, ast._ast)
785
+ end
784
786
 
785
- def mk_array_default(ast)
786
- Z3::VeryLowLevel.Z3_mk_array_default(_ctx_pointer, ast._ast)
787
- end
787
+ def mk_array_default(ast) #=> :ast_pointer
788
+ Z3::VeryLowLevel.Z3_mk_array_default(_ctx_pointer, ast._ast)
789
+ end
788
790
 
789
- def mk_array_sort(sort1, sort2)
790
- Z3::VeryLowLevel.Z3_mk_array_sort(_ctx_pointer, sort1._sort, sort2._sort)
791
- end
791
+ def mk_array_sort(sort1, sort2) #=> :sort_pointer
792
+ Z3::VeryLowLevel.Z3_mk_array_sort(_ctx_pointer, sort1._sort, sort2._sort)
793
+ end
792
794
 
793
- def mk_ast_map
794
- Z3::VeryLowLevel.Z3_mk_ast_map(_ctx_pointer)
795
- end
795
+ def mk_ast_map #=> :ast_map_pointer
796
+ Z3::VeryLowLevel.Z3_mk_ast_map(_ctx_pointer)
797
+ end
796
798
 
797
- def mk_ast_vector
798
- Z3::VeryLowLevel.Z3_mk_ast_vector(_ctx_pointer)
799
- end
799
+ def mk_ast_vector #=> :ast_vector_pointer
800
+ Z3::VeryLowLevel.Z3_mk_ast_vector(_ctx_pointer)
801
+ end
800
802
 
801
- def mk_bool_sort
802
- Z3::VeryLowLevel.Z3_mk_bool_sort(_ctx_pointer)
803
- end
803
+ def mk_bool_sort #=> :sort_pointer
804
+ Z3::VeryLowLevel.Z3_mk_bool_sort(_ctx_pointer)
805
+ end
804
806
 
805
- def mk_bound(num, sort)
806
- Z3::VeryLowLevel.Z3_mk_bound(_ctx_pointer, num, sort._sort)
807
- end
807
+ def mk_bound(num, sort) #=> :ast_pointer
808
+ Z3::VeryLowLevel.Z3_mk_bound(_ctx_pointer, num, sort._sort)
809
+ end
808
810
 
809
- def mk_bv2int(ast, bool)
810
- Z3::VeryLowLevel.Z3_mk_bv2int(_ctx_pointer, ast._ast, bool)
811
- end
811
+ def mk_bv2int(ast, bool) #=> :ast_pointer
812
+ Z3::VeryLowLevel.Z3_mk_bv2int(_ctx_pointer, ast._ast, bool)
813
+ end
812
814
 
813
- def mk_bv_sort(num)
814
- Z3::VeryLowLevel.Z3_mk_bv_sort(_ctx_pointer, num)
815
- end
815
+ def mk_bv_sort(num) #=> :sort_pointer
816
+ Z3::VeryLowLevel.Z3_mk_bv_sort(_ctx_pointer, num)
817
+ end
816
818
 
817
- def mk_bvadd(ast1, ast2)
818
- Z3::VeryLowLevel.Z3_mk_bvadd(_ctx_pointer, ast1._ast, ast2._ast)
819
- end
819
+ def mk_bvadd(ast1, ast2) #=> :ast_pointer
820
+ Z3::VeryLowLevel.Z3_mk_bvadd(_ctx_pointer, ast1._ast, ast2._ast)
821
+ end
820
822
 
821
- def mk_bvadd_no_overflow(ast1, ast2, bool)
822
- Z3::VeryLowLevel.Z3_mk_bvadd_no_overflow(_ctx_pointer, ast1._ast, ast2._ast, bool)
823
- end
823
+ def mk_bvadd_no_overflow(ast1, ast2, bool) #=> :ast_pointer
824
+ Z3::VeryLowLevel.Z3_mk_bvadd_no_overflow(_ctx_pointer, ast1._ast, ast2._ast, bool)
825
+ end
824
826
 
825
- def mk_bvadd_no_underflow(ast1, ast2)
826
- Z3::VeryLowLevel.Z3_mk_bvadd_no_underflow(_ctx_pointer, ast1._ast, ast2._ast)
827
- end
827
+ def mk_bvadd_no_underflow(ast1, ast2) #=> :ast_pointer
828
+ Z3::VeryLowLevel.Z3_mk_bvadd_no_underflow(_ctx_pointer, ast1._ast, ast2._ast)
829
+ end
828
830
 
829
- def mk_bvand(ast1, ast2)
830
- Z3::VeryLowLevel.Z3_mk_bvand(_ctx_pointer, ast1._ast, ast2._ast)
831
- end
831
+ def mk_bvand(ast1, ast2) #=> :ast_pointer
832
+ Z3::VeryLowLevel.Z3_mk_bvand(_ctx_pointer, ast1._ast, ast2._ast)
833
+ end
832
834
 
833
- def mk_bvashr(ast1, ast2)
834
- Z3::VeryLowLevel.Z3_mk_bvashr(_ctx_pointer, ast1._ast, ast2._ast)
835
- end
835
+ def mk_bvashr(ast1, ast2) #=> :ast_pointer
836
+ Z3::VeryLowLevel.Z3_mk_bvashr(_ctx_pointer, ast1._ast, ast2._ast)
837
+ end
836
838
 
837
- def mk_bvlshr(ast1, ast2)
838
- Z3::VeryLowLevel.Z3_mk_bvlshr(_ctx_pointer, ast1._ast, ast2._ast)
839
- end
839
+ def mk_bvlshr(ast1, ast2) #=> :ast_pointer
840
+ Z3::VeryLowLevel.Z3_mk_bvlshr(_ctx_pointer, ast1._ast, ast2._ast)
841
+ end
840
842
 
841
- def mk_bvmul(ast1, ast2)
842
- Z3::VeryLowLevel.Z3_mk_bvmul(_ctx_pointer, ast1._ast, ast2._ast)
843
- end
843
+ def mk_bvmul(ast1, ast2) #=> :ast_pointer
844
+ Z3::VeryLowLevel.Z3_mk_bvmul(_ctx_pointer, ast1._ast, ast2._ast)
845
+ end
844
846
 
845
- def mk_bvmul_no_overflow(ast1, ast2, bool)
846
- Z3::VeryLowLevel.Z3_mk_bvmul_no_overflow(_ctx_pointer, ast1._ast, ast2._ast, bool)
847
- end
847
+ def mk_bvmul_no_overflow(ast1, ast2, bool) #=> :ast_pointer
848
+ Z3::VeryLowLevel.Z3_mk_bvmul_no_overflow(_ctx_pointer, ast1._ast, ast2._ast, bool)
849
+ end
848
850
 
849
- def mk_bvmul_no_underflow(ast1, ast2)
850
- Z3::VeryLowLevel.Z3_mk_bvmul_no_underflow(_ctx_pointer, ast1._ast, ast2._ast)
851
- end
851
+ def mk_bvmul_no_underflow(ast1, ast2) #=> :ast_pointer
852
+ Z3::VeryLowLevel.Z3_mk_bvmul_no_underflow(_ctx_pointer, ast1._ast, ast2._ast)
853
+ end
852
854
 
853
- def mk_bvnand(ast1, ast2)
854
- Z3::VeryLowLevel.Z3_mk_bvnand(_ctx_pointer, ast1._ast, ast2._ast)
855
- end
855
+ def mk_bvnand(ast1, ast2) #=> :ast_pointer
856
+ Z3::VeryLowLevel.Z3_mk_bvnand(_ctx_pointer, ast1._ast, ast2._ast)
857
+ end
856
858
 
857
- def mk_bvneg(ast)
858
- Z3::VeryLowLevel.Z3_mk_bvneg(_ctx_pointer, ast._ast)
859
- end
859
+ def mk_bvneg(ast) #=> :ast_pointer
860
+ Z3::VeryLowLevel.Z3_mk_bvneg(_ctx_pointer, ast._ast)
861
+ end
860
862
 
861
- def mk_bvneg_no_overflow(ast)
862
- Z3::VeryLowLevel.Z3_mk_bvneg_no_overflow(_ctx_pointer, ast._ast)
863
- end
863
+ def mk_bvneg_no_overflow(ast) #=> :ast_pointer
864
+ Z3::VeryLowLevel.Z3_mk_bvneg_no_overflow(_ctx_pointer, ast._ast)
865
+ end
864
866
 
865
- def mk_bvnor(ast1, ast2)
866
- Z3::VeryLowLevel.Z3_mk_bvnor(_ctx_pointer, ast1._ast, ast2._ast)
867
- end
867
+ def mk_bvnor(ast1, ast2) #=> :ast_pointer
868
+ Z3::VeryLowLevel.Z3_mk_bvnor(_ctx_pointer, ast1._ast, ast2._ast)
869
+ end
868
870
 
869
- def mk_bvnot(ast)
870
- Z3::VeryLowLevel.Z3_mk_bvnot(_ctx_pointer, ast._ast)
871
- end
871
+ def mk_bvnot(ast) #=> :ast_pointer
872
+ Z3::VeryLowLevel.Z3_mk_bvnot(_ctx_pointer, ast._ast)
873
+ end
872
874
 
873
- def mk_bvor(ast1, ast2)
874
- Z3::VeryLowLevel.Z3_mk_bvor(_ctx_pointer, ast1._ast, ast2._ast)
875
- end
875
+ def mk_bvor(ast1, ast2) #=> :ast_pointer
876
+ Z3::VeryLowLevel.Z3_mk_bvor(_ctx_pointer, ast1._ast, ast2._ast)
877
+ end
876
878
 
877
- def mk_bvredand(ast)
878
- Z3::VeryLowLevel.Z3_mk_bvredand(_ctx_pointer, ast._ast)
879
- end
879
+ def mk_bvredand(ast) #=> :ast_pointer
880
+ Z3::VeryLowLevel.Z3_mk_bvredand(_ctx_pointer, ast._ast)
881
+ end
880
882
 
881
- def mk_bvredor(ast)
882
- Z3::VeryLowLevel.Z3_mk_bvredor(_ctx_pointer, ast._ast)
883
- end
883
+ def mk_bvredor(ast) #=> :ast_pointer
884
+ Z3::VeryLowLevel.Z3_mk_bvredor(_ctx_pointer, ast._ast)
885
+ end
884
886
 
885
- def mk_bvsdiv(ast1, ast2)
886
- Z3::VeryLowLevel.Z3_mk_bvsdiv(_ctx_pointer, ast1._ast, ast2._ast)
887
- end
887
+ def mk_bvsdiv(ast1, ast2) #=> :ast_pointer
888
+ Z3::VeryLowLevel.Z3_mk_bvsdiv(_ctx_pointer, ast1._ast, ast2._ast)
889
+ end
888
890
 
889
- def mk_bvsdiv_no_overflow(ast1, ast2)
890
- Z3::VeryLowLevel.Z3_mk_bvsdiv_no_overflow(_ctx_pointer, ast1._ast, ast2._ast)
891
- end
891
+ def mk_bvsdiv_no_overflow(ast1, ast2) #=> :ast_pointer
892
+ Z3::VeryLowLevel.Z3_mk_bvsdiv_no_overflow(_ctx_pointer, ast1._ast, ast2._ast)
893
+ end
892
894
 
893
- def mk_bvsge(ast1, ast2)
894
- Z3::VeryLowLevel.Z3_mk_bvsge(_ctx_pointer, ast1._ast, ast2._ast)
895
- end
895
+ def mk_bvsge(ast1, ast2) #=> :ast_pointer
896
+ Z3::VeryLowLevel.Z3_mk_bvsge(_ctx_pointer, ast1._ast, ast2._ast)
897
+ end
896
898
 
897
- def mk_bvsgt(ast1, ast2)
898
- Z3::VeryLowLevel.Z3_mk_bvsgt(_ctx_pointer, ast1._ast, ast2._ast)
899
- end
899
+ def mk_bvsgt(ast1, ast2) #=> :ast_pointer
900
+ Z3::VeryLowLevel.Z3_mk_bvsgt(_ctx_pointer, ast1._ast, ast2._ast)
901
+ end
900
902
 
901
- def mk_bvshl(ast1, ast2)
902
- Z3::VeryLowLevel.Z3_mk_bvshl(_ctx_pointer, ast1._ast, ast2._ast)
903
- end
903
+ def mk_bvshl(ast1, ast2) #=> :ast_pointer
904
+ Z3::VeryLowLevel.Z3_mk_bvshl(_ctx_pointer, ast1._ast, ast2._ast)
905
+ end
904
906
 
905
- def mk_bvsle(ast1, ast2)
906
- Z3::VeryLowLevel.Z3_mk_bvsle(_ctx_pointer, ast1._ast, ast2._ast)
907
- end
907
+ def mk_bvsle(ast1, ast2) #=> :ast_pointer
908
+ Z3::VeryLowLevel.Z3_mk_bvsle(_ctx_pointer, ast1._ast, ast2._ast)
909
+ end
908
910
 
909
- def mk_bvslt(ast1, ast2)
910
- Z3::VeryLowLevel.Z3_mk_bvslt(_ctx_pointer, ast1._ast, ast2._ast)
911
- end
911
+ def mk_bvslt(ast1, ast2) #=> :ast_pointer
912
+ Z3::VeryLowLevel.Z3_mk_bvslt(_ctx_pointer, ast1._ast, ast2._ast)
913
+ end
912
914
 
913
- def mk_bvsmod(ast1, ast2)
914
- Z3::VeryLowLevel.Z3_mk_bvsmod(_ctx_pointer, ast1._ast, ast2._ast)
915
- end
915
+ def mk_bvsmod(ast1, ast2) #=> :ast_pointer
916
+ Z3::VeryLowLevel.Z3_mk_bvsmod(_ctx_pointer, ast1._ast, ast2._ast)
917
+ end
916
918
 
917
- def mk_bvsrem(ast1, ast2)
918
- Z3::VeryLowLevel.Z3_mk_bvsrem(_ctx_pointer, ast1._ast, ast2._ast)
919
- end
919
+ def mk_bvsrem(ast1, ast2) #=> :ast_pointer
920
+ Z3::VeryLowLevel.Z3_mk_bvsrem(_ctx_pointer, ast1._ast, ast2._ast)
921
+ end
920
922
 
921
- def mk_bvsub(ast1, ast2)
922
- Z3::VeryLowLevel.Z3_mk_bvsub(_ctx_pointer, ast1._ast, ast2._ast)
923
- end
923
+ def mk_bvsub(ast1, ast2) #=> :ast_pointer
924
+ Z3::VeryLowLevel.Z3_mk_bvsub(_ctx_pointer, ast1._ast, ast2._ast)
925
+ end
924
926
 
925
- def mk_bvsub_no_overflow(ast1, ast2)
926
- Z3::VeryLowLevel.Z3_mk_bvsub_no_overflow(_ctx_pointer, ast1._ast, ast2._ast)
927
- end
927
+ def mk_bvsub_no_overflow(ast1, ast2) #=> :ast_pointer
928
+ Z3::VeryLowLevel.Z3_mk_bvsub_no_overflow(_ctx_pointer, ast1._ast, ast2._ast)
929
+ end
928
930
 
929
- def mk_bvsub_no_underflow(ast1, ast2, bool)
930
- Z3::VeryLowLevel.Z3_mk_bvsub_no_underflow(_ctx_pointer, ast1._ast, ast2._ast, bool)
931
- end
931
+ def mk_bvsub_no_underflow(ast1, ast2, bool) #=> :ast_pointer
932
+ Z3::VeryLowLevel.Z3_mk_bvsub_no_underflow(_ctx_pointer, ast1._ast, ast2._ast, bool)
933
+ end
932
934
 
933
- def mk_bvudiv(ast1, ast2)
934
- Z3::VeryLowLevel.Z3_mk_bvudiv(_ctx_pointer, ast1._ast, ast2._ast)
935
- end
935
+ def mk_bvudiv(ast1, ast2) #=> :ast_pointer
936
+ Z3::VeryLowLevel.Z3_mk_bvudiv(_ctx_pointer, ast1._ast, ast2._ast)
937
+ end
936
938
 
937
- def mk_bvuge(ast1, ast2)
938
- Z3::VeryLowLevel.Z3_mk_bvuge(_ctx_pointer, ast1._ast, ast2._ast)
939
- end
939
+ def mk_bvuge(ast1, ast2) #=> :ast_pointer
940
+ Z3::VeryLowLevel.Z3_mk_bvuge(_ctx_pointer, ast1._ast, ast2._ast)
941
+ end
940
942
 
941
- def mk_bvugt(ast1, ast2)
942
- Z3::VeryLowLevel.Z3_mk_bvugt(_ctx_pointer, ast1._ast, ast2._ast)
943
- end
943
+ def mk_bvugt(ast1, ast2) #=> :ast_pointer
944
+ Z3::VeryLowLevel.Z3_mk_bvugt(_ctx_pointer, ast1._ast, ast2._ast)
945
+ end
944
946
 
945
- def mk_bvule(ast1, ast2)
946
- Z3::VeryLowLevel.Z3_mk_bvule(_ctx_pointer, ast1._ast, ast2._ast)
947
- end
947
+ def mk_bvule(ast1, ast2) #=> :ast_pointer
948
+ Z3::VeryLowLevel.Z3_mk_bvule(_ctx_pointer, ast1._ast, ast2._ast)
949
+ end
948
950
 
949
- def mk_bvult(ast1, ast2)
950
- Z3::VeryLowLevel.Z3_mk_bvult(_ctx_pointer, ast1._ast, ast2._ast)
951
- end
951
+ def mk_bvult(ast1, ast2) #=> :ast_pointer
952
+ Z3::VeryLowLevel.Z3_mk_bvult(_ctx_pointer, ast1._ast, ast2._ast)
953
+ end
952
954
 
953
- def mk_bvurem(ast1, ast2)
954
- Z3::VeryLowLevel.Z3_mk_bvurem(_ctx_pointer, ast1._ast, ast2._ast)
955
- end
955
+ def mk_bvurem(ast1, ast2) #=> :ast_pointer
956
+ Z3::VeryLowLevel.Z3_mk_bvurem(_ctx_pointer, ast1._ast, ast2._ast)
957
+ end
956
958
 
957
- def mk_bvxnor(ast1, ast2)
958
- Z3::VeryLowLevel.Z3_mk_bvxnor(_ctx_pointer, ast1._ast, ast2._ast)
959
- end
959
+ def mk_bvxnor(ast1, ast2) #=> :ast_pointer
960
+ Z3::VeryLowLevel.Z3_mk_bvxnor(_ctx_pointer, ast1._ast, ast2._ast)
961
+ end
960
962
 
961
- def mk_bvxor(ast1, ast2)
962
- Z3::VeryLowLevel.Z3_mk_bvxor(_ctx_pointer, ast1._ast, ast2._ast)
963
- end
963
+ def mk_bvxor(ast1, ast2) #=> :ast_pointer
964
+ Z3::VeryLowLevel.Z3_mk_bvxor(_ctx_pointer, ast1._ast, ast2._ast)
965
+ end
964
966
 
965
- def mk_concat(ast1, ast2)
966
- Z3::VeryLowLevel.Z3_mk_concat(_ctx_pointer, ast1._ast, ast2._ast)
967
- end
967
+ def mk_concat(ast1, ast2) #=> :ast_pointer
968
+ Z3::VeryLowLevel.Z3_mk_concat(_ctx_pointer, ast1._ast, ast2._ast)
969
+ end
968
970
 
969
- def mk_config
970
- Z3::VeryLowLevel.Z3_mk_config()
971
- end
971
+ def mk_config #=> :config_pointer
972
+ Z3::VeryLowLevel.Z3_mk_config()
973
+ end
972
974
 
973
- def mk_const(sym, sort)
974
- Z3::VeryLowLevel.Z3_mk_const(_ctx_pointer, sym, sort._sort)
975
- end
975
+ def mk_const(sym, sort) #=> :ast_pointer
976
+ Z3::VeryLowLevel.Z3_mk_const(_ctx_pointer, sym, sort._sort)
977
+ end
976
978
 
977
- def mk_const_array(sort, ast)
978
- Z3::VeryLowLevel.Z3_mk_const_array(_ctx_pointer, sort._sort, ast._ast)
979
- end
979
+ def mk_const_array(sort, ast) #=> :ast_pointer
980
+ Z3::VeryLowLevel.Z3_mk_const_array(_ctx_pointer, sort._sort, ast._ast)
981
+ end
980
982
 
981
- def mk_context_rc(config)
982
- Z3::VeryLowLevel.Z3_mk_context_rc(config._config)
983
- end
983
+ def mk_context_rc(config) #=> :ctx_pointer
984
+ Z3::VeryLowLevel.Z3_mk_context_rc(config._config)
985
+ end
984
986
 
985
- def mk_div(ast1, ast2)
986
- Z3::VeryLowLevel.Z3_mk_div(_ctx_pointer, ast1._ast, ast2._ast)
987
- end
987
+ def mk_div(ast1, ast2) #=> :ast_pointer
988
+ Z3::VeryLowLevel.Z3_mk_div(_ctx_pointer, ast1._ast, ast2._ast)
989
+ end
988
990
 
989
- def mk_empty_set(sort)
990
- Z3::VeryLowLevel.Z3_mk_empty_set(_ctx_pointer, sort._sort)
991
- end
991
+ def mk_empty_set(sort) #=> :ast_pointer
992
+ Z3::VeryLowLevel.Z3_mk_empty_set(_ctx_pointer, sort._sort)
993
+ end
992
994
 
993
- def mk_eq(ast1, ast2)
994
- Z3::VeryLowLevel.Z3_mk_eq(_ctx_pointer, ast1._ast, ast2._ast)
995
- end
995
+ def mk_eq(ast1, ast2) #=> :ast_pointer
996
+ Z3::VeryLowLevel.Z3_mk_eq(_ctx_pointer, ast1._ast, ast2._ast)
997
+ end
996
998
 
997
- def mk_ext_rotate_left(ast1, ast2)
998
- Z3::VeryLowLevel.Z3_mk_ext_rotate_left(_ctx_pointer, ast1._ast, ast2._ast)
999
- end
999
+ def mk_ext_rotate_left(ast1, ast2) #=> :ast_pointer
1000
+ Z3::VeryLowLevel.Z3_mk_ext_rotate_left(_ctx_pointer, ast1._ast, ast2._ast)
1001
+ end
1000
1002
 
1001
- def mk_ext_rotate_right(ast1, ast2)
1002
- Z3::VeryLowLevel.Z3_mk_ext_rotate_right(_ctx_pointer, ast1._ast, ast2._ast)
1003
- end
1003
+ def mk_ext_rotate_right(ast1, ast2) #=> :ast_pointer
1004
+ Z3::VeryLowLevel.Z3_mk_ext_rotate_right(_ctx_pointer, ast1._ast, ast2._ast)
1005
+ end
1004
1006
 
1005
- def mk_extract(num1, num2, ast)
1006
- Z3::VeryLowLevel.Z3_mk_extract(_ctx_pointer, num1, num2, ast._ast)
1007
- end
1007
+ def mk_extract(num1, num2, ast) #=> :ast_pointer
1008
+ Z3::VeryLowLevel.Z3_mk_extract(_ctx_pointer, num1, num2, ast._ast)
1009
+ end
1008
1010
 
1009
- def mk_false
1010
- Z3::VeryLowLevel.Z3_mk_false(_ctx_pointer)
1011
- end
1011
+ def mk_false #=> :ast_pointer
1012
+ Z3::VeryLowLevel.Z3_mk_false(_ctx_pointer)
1013
+ end
1012
1014
 
1013
- def mk_finite_domain_sort(sym, num)
1014
- Z3::VeryLowLevel.Z3_mk_finite_domain_sort(_ctx_pointer, sym, num)
1015
- end
1015
+ def mk_finite_domain_sort(sym, num) #=> :sort_pointer
1016
+ Z3::VeryLowLevel.Z3_mk_finite_domain_sort(_ctx_pointer, sym, num)
1017
+ end
1016
1018
 
1017
- def mk_fixedpoint
1018
- Z3::VeryLowLevel.Z3_mk_fixedpoint(_ctx_pointer)
1019
- end
1019
+ def mk_fixedpoint #=> :fixedpoint_pointer
1020
+ Z3::VeryLowLevel.Z3_mk_fixedpoint(_ctx_pointer)
1021
+ end
1020
1022
 
1021
- def mk_fpa_abs(ast)
1022
- Z3::VeryLowLevel.Z3_mk_fpa_abs(_ctx_pointer, ast._ast)
1023
- end
1023
+ def mk_fpa_abs(ast) #=> :ast_pointer
1024
+ Z3::VeryLowLevel.Z3_mk_fpa_abs(_ctx_pointer, ast._ast)
1025
+ end
1024
1026
 
1025
- def mk_fpa_add(ast1, ast2, ast3)
1026
- Z3::VeryLowLevel.Z3_mk_fpa_add(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1027
- end
1027
+ def mk_fpa_add(ast1, ast2, ast3) #=> :ast_pointer
1028
+ Z3::VeryLowLevel.Z3_mk_fpa_add(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1029
+ end
1028
1030
 
1029
- def mk_fpa_div(ast1, ast2, ast3)
1030
- Z3::VeryLowLevel.Z3_mk_fpa_div(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1031
- end
1031
+ def mk_fpa_div(ast1, ast2, ast3) #=> :ast_pointer
1032
+ Z3::VeryLowLevel.Z3_mk_fpa_div(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1033
+ end
1032
1034
 
1033
- def mk_fpa_eq(ast1, ast2)
1034
- Z3::VeryLowLevel.Z3_mk_fpa_eq(_ctx_pointer, ast1._ast, ast2._ast)
1035
- end
1035
+ def mk_fpa_eq(ast1, ast2) #=> :ast_pointer
1036
+ Z3::VeryLowLevel.Z3_mk_fpa_eq(_ctx_pointer, ast1._ast, ast2._ast)
1037
+ end
1036
1038
 
1037
- def mk_fpa_fma(ast1, ast2, ast3, ast4)
1038
- Z3::VeryLowLevel.Z3_mk_fpa_fma(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast, ast4._ast)
1039
- end
1039
+ def mk_fpa_fma(ast1, ast2, ast3, ast4) #=> :ast_pointer
1040
+ Z3::VeryLowLevel.Z3_mk_fpa_fma(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast, ast4._ast)
1041
+ end
1040
1042
 
1041
- def mk_fpa_fp(ast1, ast2, ast3)
1042
- Z3::VeryLowLevel.Z3_mk_fpa_fp(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1043
- end
1043
+ def mk_fpa_fp(ast1, ast2, ast3) #=> :ast_pointer
1044
+ Z3::VeryLowLevel.Z3_mk_fpa_fp(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1045
+ end
1044
1046
 
1045
- def mk_fpa_geq(ast1, ast2)
1046
- Z3::VeryLowLevel.Z3_mk_fpa_geq(_ctx_pointer, ast1._ast, ast2._ast)
1047
- end
1047
+ def mk_fpa_geq(ast1, ast2) #=> :ast_pointer
1048
+ Z3::VeryLowLevel.Z3_mk_fpa_geq(_ctx_pointer, ast1._ast, ast2._ast)
1049
+ end
1048
1050
 
1049
- def mk_fpa_gt(ast1, ast2)
1050
- Z3::VeryLowLevel.Z3_mk_fpa_gt(_ctx_pointer, ast1._ast, ast2._ast)
1051
- end
1051
+ def mk_fpa_gt(ast1, ast2) #=> :ast_pointer
1052
+ Z3::VeryLowLevel.Z3_mk_fpa_gt(_ctx_pointer, ast1._ast, ast2._ast)
1053
+ end
1052
1054
 
1053
- def mk_fpa_inf(sort, bool)
1054
- Z3::VeryLowLevel.Z3_mk_fpa_inf(_ctx_pointer, sort._sort, bool)
1055
- end
1055
+ def mk_fpa_inf(sort, bool) #=> :ast_pointer
1056
+ Z3::VeryLowLevel.Z3_mk_fpa_inf(_ctx_pointer, sort._sort, bool)
1057
+ end
1056
1058
 
1057
- def mk_fpa_is_infinite(ast)
1058
- Z3::VeryLowLevel.Z3_mk_fpa_is_infinite(_ctx_pointer, ast._ast)
1059
- end
1059
+ def mk_fpa_is_infinite(ast) #=> :ast_pointer
1060
+ Z3::VeryLowLevel.Z3_mk_fpa_is_infinite(_ctx_pointer, ast._ast)
1061
+ end
1060
1062
 
1061
- def mk_fpa_is_nan(ast)
1062
- Z3::VeryLowLevel.Z3_mk_fpa_is_nan(_ctx_pointer, ast._ast)
1063
- end
1063
+ def mk_fpa_is_nan(ast) #=> :ast_pointer
1064
+ Z3::VeryLowLevel.Z3_mk_fpa_is_nan(_ctx_pointer, ast._ast)
1065
+ end
1064
1066
 
1065
- def mk_fpa_is_negative(ast)
1066
- Z3::VeryLowLevel.Z3_mk_fpa_is_negative(_ctx_pointer, ast._ast)
1067
- end
1067
+ def mk_fpa_is_negative(ast) #=> :ast_pointer
1068
+ Z3::VeryLowLevel.Z3_mk_fpa_is_negative(_ctx_pointer, ast._ast)
1069
+ end
1068
1070
 
1069
- def mk_fpa_is_normal(ast)
1070
- Z3::VeryLowLevel.Z3_mk_fpa_is_normal(_ctx_pointer, ast._ast)
1071
- end
1071
+ def mk_fpa_is_normal(ast) #=> :ast_pointer
1072
+ Z3::VeryLowLevel.Z3_mk_fpa_is_normal(_ctx_pointer, ast._ast)
1073
+ end
1072
1074
 
1073
- def mk_fpa_is_positive(ast)
1074
- Z3::VeryLowLevel.Z3_mk_fpa_is_positive(_ctx_pointer, ast._ast)
1075
- end
1075
+ def mk_fpa_is_positive(ast) #=> :ast_pointer
1076
+ Z3::VeryLowLevel.Z3_mk_fpa_is_positive(_ctx_pointer, ast._ast)
1077
+ end
1076
1078
 
1077
- def mk_fpa_is_subnormal(ast)
1078
- Z3::VeryLowLevel.Z3_mk_fpa_is_subnormal(_ctx_pointer, ast._ast)
1079
- end
1079
+ def mk_fpa_is_subnormal(ast) #=> :ast_pointer
1080
+ Z3::VeryLowLevel.Z3_mk_fpa_is_subnormal(_ctx_pointer, ast._ast)
1081
+ end
1080
1082
 
1081
- def mk_fpa_is_zero(ast)
1082
- Z3::VeryLowLevel.Z3_mk_fpa_is_zero(_ctx_pointer, ast._ast)
1083
- end
1083
+ def mk_fpa_is_zero(ast) #=> :ast_pointer
1084
+ Z3::VeryLowLevel.Z3_mk_fpa_is_zero(_ctx_pointer, ast._ast)
1085
+ end
1084
1086
 
1085
- def mk_fpa_leq(ast1, ast2)
1086
- Z3::VeryLowLevel.Z3_mk_fpa_leq(_ctx_pointer, ast1._ast, ast2._ast)
1087
- end
1087
+ def mk_fpa_leq(ast1, ast2) #=> :ast_pointer
1088
+ Z3::VeryLowLevel.Z3_mk_fpa_leq(_ctx_pointer, ast1._ast, ast2._ast)
1089
+ end
1088
1090
 
1089
- def mk_fpa_lt(ast1, ast2)
1090
- Z3::VeryLowLevel.Z3_mk_fpa_lt(_ctx_pointer, ast1._ast, ast2._ast)
1091
- end
1091
+ def mk_fpa_lt(ast1, ast2) #=> :ast_pointer
1092
+ Z3::VeryLowLevel.Z3_mk_fpa_lt(_ctx_pointer, ast1._ast, ast2._ast)
1093
+ end
1092
1094
 
1093
- def mk_fpa_max(ast1, ast2)
1094
- Z3::VeryLowLevel.Z3_mk_fpa_max(_ctx_pointer, ast1._ast, ast2._ast)
1095
- end
1095
+ def mk_fpa_max(ast1, ast2) #=> :ast_pointer
1096
+ Z3::VeryLowLevel.Z3_mk_fpa_max(_ctx_pointer, ast1._ast, ast2._ast)
1097
+ end
1096
1098
 
1097
- def mk_fpa_min(ast1, ast2)
1098
- Z3::VeryLowLevel.Z3_mk_fpa_min(_ctx_pointer, ast1._ast, ast2._ast)
1099
- end
1099
+ def mk_fpa_min(ast1, ast2) #=> :ast_pointer
1100
+ Z3::VeryLowLevel.Z3_mk_fpa_min(_ctx_pointer, ast1._ast, ast2._ast)
1101
+ end
1100
1102
 
1101
- def mk_fpa_mul(ast1, ast2, ast3)
1102
- Z3::VeryLowLevel.Z3_mk_fpa_mul(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1103
- end
1103
+ def mk_fpa_mul(ast1, ast2, ast3) #=> :ast_pointer
1104
+ Z3::VeryLowLevel.Z3_mk_fpa_mul(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1105
+ end
1104
1106
 
1105
- def mk_fpa_nan(sort)
1106
- Z3::VeryLowLevel.Z3_mk_fpa_nan(_ctx_pointer, sort._sort)
1107
- end
1107
+ def mk_fpa_nan(sort) #=> :ast_pointer
1108
+ Z3::VeryLowLevel.Z3_mk_fpa_nan(_ctx_pointer, sort._sort)
1109
+ end
1108
1110
 
1109
- def mk_fpa_neg(ast)
1110
- Z3::VeryLowLevel.Z3_mk_fpa_neg(_ctx_pointer, ast._ast)
1111
- end
1111
+ def mk_fpa_neg(ast) #=> :ast_pointer
1112
+ Z3::VeryLowLevel.Z3_mk_fpa_neg(_ctx_pointer, ast._ast)
1113
+ end
1112
1114
 
1113
- def mk_fpa_numeral_double(double, sort)
1114
- Z3::VeryLowLevel.Z3_mk_fpa_numeral_double(_ctx_pointer, double, sort._sort)
1115
- end
1115
+ def mk_fpa_numeral_double(double, sort) #=> :ast_pointer
1116
+ Z3::VeryLowLevel.Z3_mk_fpa_numeral_double(_ctx_pointer, double, sort._sort)
1117
+ end
1116
1118
 
1117
- def mk_fpa_numeral_float(float, sort)
1118
- Z3::VeryLowLevel.Z3_mk_fpa_numeral_float(_ctx_pointer, float, sort._sort)
1119
- end
1119
+ def mk_fpa_numeral_float(float, sort) #=> :ast_pointer
1120
+ Z3::VeryLowLevel.Z3_mk_fpa_numeral_float(_ctx_pointer, float, sort._sort)
1121
+ end
1120
1122
 
1121
- def mk_fpa_numeral_int(num, sort)
1122
- Z3::VeryLowLevel.Z3_mk_fpa_numeral_int(_ctx_pointer, num, sort._sort)
1123
- end
1123
+ def mk_fpa_numeral_int(num, sort) #=> :ast_pointer
1124
+ Z3::VeryLowLevel.Z3_mk_fpa_numeral_int(_ctx_pointer, num, sort._sort)
1125
+ end
1124
1126
 
1125
- def mk_fpa_numeral_int64_uint64(bool, num1, num2, sort)
1126
- Z3::VeryLowLevel.Z3_mk_fpa_numeral_int64_uint64(_ctx_pointer, bool, num1, num2, sort._sort)
1127
- end
1127
+ def mk_fpa_numeral_int64_uint64(bool, num1, num2, sort) #=> :ast_pointer
1128
+ Z3::VeryLowLevel.Z3_mk_fpa_numeral_int64_uint64(_ctx_pointer, bool, num1, num2, sort._sort)
1129
+ end
1128
1130
 
1129
- def mk_fpa_numeral_int_uint(bool, num1, num2, sort)
1130
- Z3::VeryLowLevel.Z3_mk_fpa_numeral_int_uint(_ctx_pointer, bool, num1, num2, sort._sort)
1131
- end
1131
+ def mk_fpa_numeral_int_uint(bool, num1, num2, sort) #=> :ast_pointer
1132
+ Z3::VeryLowLevel.Z3_mk_fpa_numeral_int_uint(_ctx_pointer, bool, num1, num2, sort._sort)
1133
+ end
1132
1134
 
1133
- def mk_fpa_rem(ast1, ast2)
1134
- Z3::VeryLowLevel.Z3_mk_fpa_rem(_ctx_pointer, ast1._ast, ast2._ast)
1135
- end
1135
+ def mk_fpa_rem(ast1, ast2) #=> :ast_pointer
1136
+ Z3::VeryLowLevel.Z3_mk_fpa_rem(_ctx_pointer, ast1._ast, ast2._ast)
1137
+ end
1136
1138
 
1137
- def mk_fpa_rna
1138
- Z3::VeryLowLevel.Z3_mk_fpa_rna(_ctx_pointer)
1139
- end
1139
+ def mk_fpa_rna #=> :ast_pointer
1140
+ Z3::VeryLowLevel.Z3_mk_fpa_rna(_ctx_pointer)
1141
+ end
1140
1142
 
1141
- def mk_fpa_rne
1142
- Z3::VeryLowLevel.Z3_mk_fpa_rne(_ctx_pointer)
1143
- end
1143
+ def mk_fpa_rne #=> :ast_pointer
1144
+ Z3::VeryLowLevel.Z3_mk_fpa_rne(_ctx_pointer)
1145
+ end
1144
1146
 
1145
- def mk_fpa_round_nearest_ties_to_away
1146
- Z3::VeryLowLevel.Z3_mk_fpa_round_nearest_ties_to_away(_ctx_pointer)
1147
- end
1147
+ def mk_fpa_round_nearest_ties_to_away #=> :ast_pointer
1148
+ Z3::VeryLowLevel.Z3_mk_fpa_round_nearest_ties_to_away(_ctx_pointer)
1149
+ end
1148
1150
 
1149
- def mk_fpa_round_nearest_ties_to_even
1150
- Z3::VeryLowLevel.Z3_mk_fpa_round_nearest_ties_to_even(_ctx_pointer)
1151
- end
1151
+ def mk_fpa_round_nearest_ties_to_even #=> :ast_pointer
1152
+ Z3::VeryLowLevel.Z3_mk_fpa_round_nearest_ties_to_even(_ctx_pointer)
1153
+ end
1152
1154
 
1153
- def mk_fpa_round_to_integral(ast1, ast2)
1154
- Z3::VeryLowLevel.Z3_mk_fpa_round_to_integral(_ctx_pointer, ast1._ast, ast2._ast)
1155
- end
1155
+ def mk_fpa_round_to_integral(ast1, ast2) #=> :ast_pointer
1156
+ Z3::VeryLowLevel.Z3_mk_fpa_round_to_integral(_ctx_pointer, ast1._ast, ast2._ast)
1157
+ end
1156
1158
 
1157
- def mk_fpa_round_toward_negative
1158
- Z3::VeryLowLevel.Z3_mk_fpa_round_toward_negative(_ctx_pointer)
1159
- end
1159
+ def mk_fpa_round_toward_negative #=> :ast_pointer
1160
+ Z3::VeryLowLevel.Z3_mk_fpa_round_toward_negative(_ctx_pointer)
1161
+ end
1160
1162
 
1161
- def mk_fpa_round_toward_positive
1162
- Z3::VeryLowLevel.Z3_mk_fpa_round_toward_positive(_ctx_pointer)
1163
- end
1163
+ def mk_fpa_round_toward_positive #=> :ast_pointer
1164
+ Z3::VeryLowLevel.Z3_mk_fpa_round_toward_positive(_ctx_pointer)
1165
+ end
1164
1166
 
1165
- def mk_fpa_round_toward_zero
1166
- Z3::VeryLowLevel.Z3_mk_fpa_round_toward_zero(_ctx_pointer)
1167
- end
1167
+ def mk_fpa_round_toward_zero #=> :ast_pointer
1168
+ Z3::VeryLowLevel.Z3_mk_fpa_round_toward_zero(_ctx_pointer)
1169
+ end
1168
1170
 
1169
- def mk_fpa_rounding_mode_sort
1170
- Z3::VeryLowLevel.Z3_mk_fpa_rounding_mode_sort(_ctx_pointer)
1171
- end
1171
+ def mk_fpa_rounding_mode_sort #=> :sort_pointer
1172
+ Z3::VeryLowLevel.Z3_mk_fpa_rounding_mode_sort(_ctx_pointer)
1173
+ end
1172
1174
 
1173
- def mk_fpa_rtn
1174
- Z3::VeryLowLevel.Z3_mk_fpa_rtn(_ctx_pointer)
1175
- end
1175
+ def mk_fpa_rtn #=> :ast_pointer
1176
+ Z3::VeryLowLevel.Z3_mk_fpa_rtn(_ctx_pointer)
1177
+ end
1176
1178
 
1177
- def mk_fpa_rtp
1178
- Z3::VeryLowLevel.Z3_mk_fpa_rtp(_ctx_pointer)
1179
- end
1179
+ def mk_fpa_rtp #=> :ast_pointer
1180
+ Z3::VeryLowLevel.Z3_mk_fpa_rtp(_ctx_pointer)
1181
+ end
1180
1182
 
1181
- def mk_fpa_rtz
1182
- Z3::VeryLowLevel.Z3_mk_fpa_rtz(_ctx_pointer)
1183
- end
1183
+ def mk_fpa_rtz #=> :ast_pointer
1184
+ Z3::VeryLowLevel.Z3_mk_fpa_rtz(_ctx_pointer)
1185
+ end
1184
1186
 
1185
- def mk_fpa_sort(num1, num2)
1186
- Z3::VeryLowLevel.Z3_mk_fpa_sort(_ctx_pointer, num1, num2)
1187
- end
1187
+ def mk_fpa_sort(num1, num2) #=> :sort_pointer
1188
+ Z3::VeryLowLevel.Z3_mk_fpa_sort(_ctx_pointer, num1, num2)
1189
+ end
1188
1190
 
1189
- def mk_fpa_sort_128
1190
- Z3::VeryLowLevel.Z3_mk_fpa_sort_128(_ctx_pointer)
1191
- end
1191
+ def mk_fpa_sort_128 #=> :sort_pointer
1192
+ Z3::VeryLowLevel.Z3_mk_fpa_sort_128(_ctx_pointer)
1193
+ end
1192
1194
 
1193
- def mk_fpa_sort_16
1194
- Z3::VeryLowLevel.Z3_mk_fpa_sort_16(_ctx_pointer)
1195
- end
1195
+ def mk_fpa_sort_16 #=> :sort_pointer
1196
+ Z3::VeryLowLevel.Z3_mk_fpa_sort_16(_ctx_pointer)
1197
+ end
1196
1198
 
1197
- def mk_fpa_sort_32
1198
- Z3::VeryLowLevel.Z3_mk_fpa_sort_32(_ctx_pointer)
1199
- end
1199
+ def mk_fpa_sort_32 #=> :sort_pointer
1200
+ Z3::VeryLowLevel.Z3_mk_fpa_sort_32(_ctx_pointer)
1201
+ end
1200
1202
 
1201
- def mk_fpa_sort_64
1202
- Z3::VeryLowLevel.Z3_mk_fpa_sort_64(_ctx_pointer)
1203
- end
1203
+ def mk_fpa_sort_64 #=> :sort_pointer
1204
+ Z3::VeryLowLevel.Z3_mk_fpa_sort_64(_ctx_pointer)
1205
+ end
1204
1206
 
1205
- def mk_fpa_sort_double
1206
- Z3::VeryLowLevel.Z3_mk_fpa_sort_double(_ctx_pointer)
1207
- end
1207
+ def mk_fpa_sort_double #=> :sort_pointer
1208
+ Z3::VeryLowLevel.Z3_mk_fpa_sort_double(_ctx_pointer)
1209
+ end
1208
1210
 
1209
- def mk_fpa_sort_half
1210
- Z3::VeryLowLevel.Z3_mk_fpa_sort_half(_ctx_pointer)
1211
- end
1211
+ def mk_fpa_sort_half #=> :sort_pointer
1212
+ Z3::VeryLowLevel.Z3_mk_fpa_sort_half(_ctx_pointer)
1213
+ end
1212
1214
 
1213
- def mk_fpa_sort_quadruple
1214
- Z3::VeryLowLevel.Z3_mk_fpa_sort_quadruple(_ctx_pointer)
1215
- end
1215
+ def mk_fpa_sort_quadruple #=> :sort_pointer
1216
+ Z3::VeryLowLevel.Z3_mk_fpa_sort_quadruple(_ctx_pointer)
1217
+ end
1216
1218
 
1217
- def mk_fpa_sort_single
1218
- Z3::VeryLowLevel.Z3_mk_fpa_sort_single(_ctx_pointer)
1219
- end
1219
+ def mk_fpa_sort_single #=> :sort_pointer
1220
+ Z3::VeryLowLevel.Z3_mk_fpa_sort_single(_ctx_pointer)
1221
+ end
1220
1222
 
1221
- def mk_fpa_sqrt(ast1, ast2)
1222
- Z3::VeryLowLevel.Z3_mk_fpa_sqrt(_ctx_pointer, ast1._ast, ast2._ast)
1223
- end
1223
+ def mk_fpa_sqrt(ast1, ast2) #=> :ast_pointer
1224
+ Z3::VeryLowLevel.Z3_mk_fpa_sqrt(_ctx_pointer, ast1._ast, ast2._ast)
1225
+ end
1224
1226
 
1225
- def mk_fpa_sub(ast1, ast2, ast3)
1226
- Z3::VeryLowLevel.Z3_mk_fpa_sub(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1227
- end
1227
+ def mk_fpa_sub(ast1, ast2, ast3) #=> :ast_pointer
1228
+ Z3::VeryLowLevel.Z3_mk_fpa_sub(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1229
+ end
1228
1230
 
1229
- def mk_fpa_to_fp_bv(ast, sort)
1230
- Z3::VeryLowLevel.Z3_mk_fpa_to_fp_bv(_ctx_pointer, ast._ast, sort._sort)
1231
- end
1231
+ def mk_fpa_to_fp_bv(ast, sort) #=> :ast_pointer
1232
+ Z3::VeryLowLevel.Z3_mk_fpa_to_fp_bv(_ctx_pointer, ast._ast, sort._sort)
1233
+ end
1232
1234
 
1233
- def mk_fpa_to_fp_float(ast1, ast2, sort)
1234
- Z3::VeryLowLevel.Z3_mk_fpa_to_fp_float(_ctx_pointer, ast1._ast, ast2._ast, sort._sort)
1235
- end
1235
+ def mk_fpa_to_fp_float(ast1, ast2, sort) #=> :ast_pointer
1236
+ Z3::VeryLowLevel.Z3_mk_fpa_to_fp_float(_ctx_pointer, ast1._ast, ast2._ast, sort._sort)
1237
+ end
1236
1238
 
1237
- def mk_fpa_to_fp_int_real(ast1, ast2, ast3, sort)
1238
- Z3::VeryLowLevel.Z3_mk_fpa_to_fp_int_real(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast, sort._sort)
1239
- end
1239
+ def mk_fpa_to_fp_int_real(ast1, ast2, ast3, sort) #=> :ast_pointer
1240
+ Z3::VeryLowLevel.Z3_mk_fpa_to_fp_int_real(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast, sort._sort)
1241
+ end
1240
1242
 
1241
- def mk_fpa_to_fp_real(ast1, ast2, sort)
1242
- Z3::VeryLowLevel.Z3_mk_fpa_to_fp_real(_ctx_pointer, ast1._ast, ast2._ast, sort._sort)
1243
- end
1243
+ def mk_fpa_to_fp_real(ast1, ast2, sort) #=> :ast_pointer
1244
+ Z3::VeryLowLevel.Z3_mk_fpa_to_fp_real(_ctx_pointer, ast1._ast, ast2._ast, sort._sort)
1245
+ end
1244
1246
 
1245
- def mk_fpa_to_fp_signed(ast1, ast2, sort)
1246
- Z3::VeryLowLevel.Z3_mk_fpa_to_fp_signed(_ctx_pointer, ast1._ast, ast2._ast, sort._sort)
1247
- end
1247
+ def mk_fpa_to_fp_signed(ast1, ast2, sort) #=> :ast_pointer
1248
+ Z3::VeryLowLevel.Z3_mk_fpa_to_fp_signed(_ctx_pointer, ast1._ast, ast2._ast, sort._sort)
1249
+ end
1248
1250
 
1249
- def mk_fpa_to_fp_unsigned(ast1, ast2, sort)
1250
- Z3::VeryLowLevel.Z3_mk_fpa_to_fp_unsigned(_ctx_pointer, ast1._ast, ast2._ast, sort._sort)
1251
- end
1251
+ def mk_fpa_to_fp_unsigned(ast1, ast2, sort) #=> :ast_pointer
1252
+ Z3::VeryLowLevel.Z3_mk_fpa_to_fp_unsigned(_ctx_pointer, ast1._ast, ast2._ast, sort._sort)
1253
+ end
1252
1254
 
1253
- def mk_fpa_to_ieee_bv(ast)
1254
- Z3::VeryLowLevel.Z3_mk_fpa_to_ieee_bv(_ctx_pointer, ast._ast)
1255
- end
1255
+ def mk_fpa_to_ieee_bv(ast) #=> :ast_pointer
1256
+ Z3::VeryLowLevel.Z3_mk_fpa_to_ieee_bv(_ctx_pointer, ast._ast)
1257
+ end
1256
1258
 
1257
- def mk_fpa_to_real(ast)
1258
- Z3::VeryLowLevel.Z3_mk_fpa_to_real(_ctx_pointer, ast._ast)
1259
- end
1259
+ def mk_fpa_to_real(ast) #=> :ast_pointer
1260
+ Z3::VeryLowLevel.Z3_mk_fpa_to_real(_ctx_pointer, ast._ast)
1261
+ end
1260
1262
 
1261
- def mk_fpa_to_sbv(ast1, ast2, num)
1262
- Z3::VeryLowLevel.Z3_mk_fpa_to_sbv(_ctx_pointer, ast1._ast, ast2._ast, num)
1263
- end
1263
+ def mk_fpa_to_sbv(ast1, ast2, num) #=> :ast_pointer
1264
+ Z3::VeryLowLevel.Z3_mk_fpa_to_sbv(_ctx_pointer, ast1._ast, ast2._ast, num)
1265
+ end
1264
1266
 
1265
- def mk_fpa_to_ubv(ast1, ast2, num)
1266
- Z3::VeryLowLevel.Z3_mk_fpa_to_ubv(_ctx_pointer, ast1._ast, ast2._ast, num)
1267
- end
1267
+ def mk_fpa_to_ubv(ast1, ast2, num) #=> :ast_pointer
1268
+ Z3::VeryLowLevel.Z3_mk_fpa_to_ubv(_ctx_pointer, ast1._ast, ast2._ast, num)
1269
+ end
1268
1270
 
1269
- def mk_fpa_zero(sort, bool)
1270
- Z3::VeryLowLevel.Z3_mk_fpa_zero(_ctx_pointer, sort._sort, bool)
1271
- end
1271
+ def mk_fpa_zero(sort, bool) #=> :ast_pointer
1272
+ Z3::VeryLowLevel.Z3_mk_fpa_zero(_ctx_pointer, sort._sort, bool)
1273
+ end
1272
1274
 
1273
- def mk_fresh_const(str, sort)
1274
- Z3::VeryLowLevel.Z3_mk_fresh_const(_ctx_pointer, str, sort._sort)
1275
- end
1275
+ def mk_fresh_const(str, sort) #=> :ast_pointer
1276
+ Z3::VeryLowLevel.Z3_mk_fresh_const(_ctx_pointer, str, sort._sort)
1277
+ end
1276
1278
 
1277
- def mk_full_set(sort)
1278
- Z3::VeryLowLevel.Z3_mk_full_set(_ctx_pointer, sort._sort)
1279
- end
1279
+ def mk_full_set(sort) #=> :ast_pointer
1280
+ Z3::VeryLowLevel.Z3_mk_full_set(_ctx_pointer, sort._sort)
1281
+ end
1280
1282
 
1281
- def mk_ge(ast1, ast2)
1282
- Z3::VeryLowLevel.Z3_mk_ge(_ctx_pointer, ast1._ast, ast2._ast)
1283
- end
1283
+ def mk_ge(ast1, ast2) #=> :ast_pointer
1284
+ Z3::VeryLowLevel.Z3_mk_ge(_ctx_pointer, ast1._ast, ast2._ast)
1285
+ end
1284
1286
 
1285
- def mk_goal(bool1, bool2, bool3)
1286
- Z3::VeryLowLevel.Z3_mk_goal(_ctx_pointer, bool1, bool2, bool3)
1287
- end
1287
+ def mk_goal(bool1, bool2, bool3) #=> :goal_pointer
1288
+ Z3::VeryLowLevel.Z3_mk_goal(_ctx_pointer, bool1, bool2, bool3)
1289
+ end
1288
1290
 
1289
- def mk_gt(ast1, ast2)
1290
- Z3::VeryLowLevel.Z3_mk_gt(_ctx_pointer, ast1._ast, ast2._ast)
1291
- end
1291
+ def mk_gt(ast1, ast2) #=> :ast_pointer
1292
+ Z3::VeryLowLevel.Z3_mk_gt(_ctx_pointer, ast1._ast, ast2._ast)
1293
+ end
1292
1294
 
1293
- def mk_iff(ast1, ast2)
1294
- Z3::VeryLowLevel.Z3_mk_iff(_ctx_pointer, ast1._ast, ast2._ast)
1295
- end
1295
+ def mk_iff(ast1, ast2) #=> :ast_pointer
1296
+ Z3::VeryLowLevel.Z3_mk_iff(_ctx_pointer, ast1._ast, ast2._ast)
1297
+ end
1296
1298
 
1297
- def mk_implies(ast1, ast2)
1298
- Z3::VeryLowLevel.Z3_mk_implies(_ctx_pointer, ast1._ast, ast2._ast)
1299
- end
1299
+ def mk_implies(ast1, ast2) #=> :ast_pointer
1300
+ Z3::VeryLowLevel.Z3_mk_implies(_ctx_pointer, ast1._ast, ast2._ast)
1301
+ end
1300
1302
 
1301
- def mk_int(num, sort)
1302
- Z3::VeryLowLevel.Z3_mk_int(_ctx_pointer, num, sort._sort)
1303
- end
1303
+ def mk_int(num, sort) #=> :ast_pointer
1304
+ Z3::VeryLowLevel.Z3_mk_int(_ctx_pointer, num, sort._sort)
1305
+ end
1304
1306
 
1305
- def mk_int2bv(num, ast)
1306
- Z3::VeryLowLevel.Z3_mk_int2bv(_ctx_pointer, num, ast._ast)
1307
- end
1307
+ def mk_int2bv(num, ast) #=> :ast_pointer
1308
+ Z3::VeryLowLevel.Z3_mk_int2bv(_ctx_pointer, num, ast._ast)
1309
+ end
1308
1310
 
1309
- def mk_int2real(ast)
1310
- Z3::VeryLowLevel.Z3_mk_int2real(_ctx_pointer, ast._ast)
1311
- end
1311
+ def mk_int2real(ast) #=> :ast_pointer
1312
+ Z3::VeryLowLevel.Z3_mk_int2real(_ctx_pointer, ast._ast)
1313
+ end
1312
1314
 
1313
- def mk_int64(num, sort)
1314
- Z3::VeryLowLevel.Z3_mk_int64(_ctx_pointer, num, sort._sort)
1315
- end
1315
+ def mk_int64(num, sort) #=> :ast_pointer
1316
+ Z3::VeryLowLevel.Z3_mk_int64(_ctx_pointer, num, sort._sort)
1317
+ end
1316
1318
 
1317
- def mk_int_sort
1318
- Z3::VeryLowLevel.Z3_mk_int_sort(_ctx_pointer)
1319
- end
1319
+ def mk_int_sort #=> :sort_pointer
1320
+ Z3::VeryLowLevel.Z3_mk_int_sort(_ctx_pointer)
1321
+ end
1320
1322
 
1321
- def mk_int_symbol(num)
1322
- Z3::VeryLowLevel.Z3_mk_int_symbol(_ctx_pointer, num)
1323
- end
1323
+ def mk_int_symbol(num) #=> :symbol_pointer
1324
+ Z3::VeryLowLevel.Z3_mk_int_symbol(_ctx_pointer, num)
1325
+ end
1324
1326
 
1325
- def mk_interpolant(ast)
1326
- Z3::VeryLowLevel.Z3_mk_interpolant(_ctx_pointer, ast._ast)
1327
- end
1327
+ def mk_interpolant(ast) #=> :ast_pointer
1328
+ Z3::VeryLowLevel.Z3_mk_interpolant(_ctx_pointer, ast._ast)
1329
+ end
1328
1330
 
1329
- def mk_interpolation_context(config)
1330
- Z3::VeryLowLevel.Z3_mk_interpolation_context(config._config)
1331
- end
1331
+ def mk_interpolation_context(config) #=> :ctx_pointer
1332
+ Z3::VeryLowLevel.Z3_mk_interpolation_context(config._config)
1333
+ end
1332
1334
 
1333
- def mk_is_int(ast)
1334
- Z3::VeryLowLevel.Z3_mk_is_int(_ctx_pointer, ast._ast)
1335
- end
1335
+ def mk_is_int(ast) #=> :ast_pointer
1336
+ Z3::VeryLowLevel.Z3_mk_is_int(_ctx_pointer, ast._ast)
1337
+ end
1336
1338
 
1337
- def mk_ite(ast1, ast2, ast3)
1338
- Z3::VeryLowLevel.Z3_mk_ite(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1339
- end
1339
+ def mk_ite(ast1, ast2, ast3) #=> :ast_pointer
1340
+ Z3::VeryLowLevel.Z3_mk_ite(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1341
+ end
1340
1342
 
1341
- def mk_le(ast1, ast2)
1342
- Z3::VeryLowLevel.Z3_mk_le(_ctx_pointer, ast1._ast, ast2._ast)
1343
- end
1343
+ def mk_le(ast1, ast2) #=> :ast_pointer
1344
+ Z3::VeryLowLevel.Z3_mk_le(_ctx_pointer, ast1._ast, ast2._ast)
1345
+ end
1344
1346
 
1345
- def mk_lt(ast1, ast2)
1346
- Z3::VeryLowLevel.Z3_mk_lt(_ctx_pointer, ast1._ast, ast2._ast)
1347
- end
1347
+ def mk_lt(ast1, ast2) #=> :ast_pointer
1348
+ Z3::VeryLowLevel.Z3_mk_lt(_ctx_pointer, ast1._ast, ast2._ast)
1349
+ end
1348
1350
 
1349
- def mk_mod(ast1, ast2)
1350
- Z3::VeryLowLevel.Z3_mk_mod(_ctx_pointer, ast1._ast, ast2._ast)
1351
- end
1351
+ def mk_mod(ast1, ast2) #=> :ast_pointer
1352
+ Z3::VeryLowLevel.Z3_mk_mod(_ctx_pointer, ast1._ast, ast2._ast)
1353
+ end
1352
1354
 
1353
- def mk_not(ast)
1354
- Z3::VeryLowLevel.Z3_mk_not(_ctx_pointer, ast._ast)
1355
- end
1355
+ def mk_not(ast) #=> :ast_pointer
1356
+ Z3::VeryLowLevel.Z3_mk_not(_ctx_pointer, ast._ast)
1357
+ end
1356
1358
 
1357
- def mk_numeral(str, sort)
1358
- Z3::VeryLowLevel.Z3_mk_numeral(_ctx_pointer, str, sort._sort)
1359
- end
1359
+ def mk_numeral(str, sort) #=> :ast_pointer
1360
+ Z3::VeryLowLevel.Z3_mk_numeral(_ctx_pointer, str, sort._sort)
1361
+ end
1360
1362
 
1361
- def mk_optimize
1362
- Z3::VeryLowLevel.Z3_mk_optimize(_ctx_pointer)
1363
- end
1363
+ def mk_optimize #=> :optimize_pointer
1364
+ Z3::VeryLowLevel.Z3_mk_optimize(_ctx_pointer)
1365
+ end
1364
1366
 
1365
- def mk_params
1366
- Z3::VeryLowLevel.Z3_mk_params(_ctx_pointer)
1367
- end
1367
+ def mk_params #=> :params_pointer
1368
+ Z3::VeryLowLevel.Z3_mk_params(_ctx_pointer)
1369
+ end
1368
1370
 
1369
- def mk_power(ast1, ast2)
1370
- Z3::VeryLowLevel.Z3_mk_power(_ctx_pointer, ast1._ast, ast2._ast)
1371
- end
1371
+ def mk_power(ast1, ast2) #=> :ast_pointer
1372
+ Z3::VeryLowLevel.Z3_mk_power(_ctx_pointer, ast1._ast, ast2._ast)
1373
+ end
1372
1374
 
1373
- def mk_probe(str)
1374
- Z3::VeryLowLevel.Z3_mk_probe(_ctx_pointer, str)
1375
- end
1375
+ def mk_probe(str) #=> :probe_pointer
1376
+ Z3::VeryLowLevel.Z3_mk_probe(_ctx_pointer, str)
1377
+ end
1376
1378
 
1377
- def mk_real(num1, num2)
1378
- Z3::VeryLowLevel.Z3_mk_real(_ctx_pointer, num1, num2)
1379
- end
1379
+ def mk_real(num1, num2) #=> :ast_pointer
1380
+ Z3::VeryLowLevel.Z3_mk_real(_ctx_pointer, num1, num2)
1381
+ end
1380
1382
 
1381
- def mk_real2int(ast)
1382
- Z3::VeryLowLevel.Z3_mk_real2int(_ctx_pointer, ast._ast)
1383
- end
1383
+ def mk_real2int(ast) #=> :ast_pointer
1384
+ Z3::VeryLowLevel.Z3_mk_real2int(_ctx_pointer, ast._ast)
1385
+ end
1384
1386
 
1385
- def mk_real_sort
1386
- Z3::VeryLowLevel.Z3_mk_real_sort(_ctx_pointer)
1387
- end
1387
+ def mk_real_sort #=> :sort_pointer
1388
+ Z3::VeryLowLevel.Z3_mk_real_sort(_ctx_pointer)
1389
+ end
1388
1390
 
1389
- def mk_rem(ast1, ast2)
1390
- Z3::VeryLowLevel.Z3_mk_rem(_ctx_pointer, ast1._ast, ast2._ast)
1391
- end
1391
+ def mk_rem(ast1, ast2) #=> :ast_pointer
1392
+ Z3::VeryLowLevel.Z3_mk_rem(_ctx_pointer, ast1._ast, ast2._ast)
1393
+ end
1392
1394
 
1393
- def mk_repeat(num, ast)
1394
- Z3::VeryLowLevel.Z3_mk_repeat(_ctx_pointer, num, ast._ast)
1395
- end
1395
+ def mk_repeat(num, ast) #=> :ast_pointer
1396
+ Z3::VeryLowLevel.Z3_mk_repeat(_ctx_pointer, num, ast._ast)
1397
+ end
1396
1398
 
1397
- def mk_rotate_left(num, ast)
1398
- Z3::VeryLowLevel.Z3_mk_rotate_left(_ctx_pointer, num, ast._ast)
1399
- end
1399
+ def mk_rotate_left(num, ast) #=> :ast_pointer
1400
+ Z3::VeryLowLevel.Z3_mk_rotate_left(_ctx_pointer, num, ast._ast)
1401
+ end
1400
1402
 
1401
- def mk_rotate_right(num, ast)
1402
- Z3::VeryLowLevel.Z3_mk_rotate_right(_ctx_pointer, num, ast._ast)
1403
- end
1403
+ def mk_rotate_right(num, ast) #=> :ast_pointer
1404
+ Z3::VeryLowLevel.Z3_mk_rotate_right(_ctx_pointer, num, ast._ast)
1405
+ end
1404
1406
 
1405
- def mk_select(ast1, ast2)
1406
- Z3::VeryLowLevel.Z3_mk_select(_ctx_pointer, ast1._ast, ast2._ast)
1407
- end
1407
+ def mk_select(ast1, ast2) #=> :ast_pointer
1408
+ Z3::VeryLowLevel.Z3_mk_select(_ctx_pointer, ast1._ast, ast2._ast)
1409
+ end
1408
1410
 
1409
- def mk_set_add(ast1, ast2)
1410
- Z3::VeryLowLevel.Z3_mk_set_add(_ctx_pointer, ast1._ast, ast2._ast)
1411
- end
1411
+ def mk_set_add(ast1, ast2) #=> :ast_pointer
1412
+ Z3::VeryLowLevel.Z3_mk_set_add(_ctx_pointer, ast1._ast, ast2._ast)
1413
+ end
1412
1414
 
1413
- def mk_set_complement(ast)
1414
- Z3::VeryLowLevel.Z3_mk_set_complement(_ctx_pointer, ast._ast)
1415
- end
1415
+ def mk_set_complement(ast) #=> :ast_pointer
1416
+ Z3::VeryLowLevel.Z3_mk_set_complement(_ctx_pointer, ast._ast)
1417
+ end
1416
1418
 
1417
- def mk_set_del(ast1, ast2)
1418
- Z3::VeryLowLevel.Z3_mk_set_del(_ctx_pointer, ast1._ast, ast2._ast)
1419
- end
1419
+ def mk_set_del(ast1, ast2) #=> :ast_pointer
1420
+ Z3::VeryLowLevel.Z3_mk_set_del(_ctx_pointer, ast1._ast, ast2._ast)
1421
+ end
1420
1422
 
1421
- def mk_set_difference(ast1, ast2)
1422
- Z3::VeryLowLevel.Z3_mk_set_difference(_ctx_pointer, ast1._ast, ast2._ast)
1423
- end
1423
+ def mk_set_difference(ast1, ast2) #=> :ast_pointer
1424
+ Z3::VeryLowLevel.Z3_mk_set_difference(_ctx_pointer, ast1._ast, ast2._ast)
1425
+ end
1424
1426
 
1425
- def mk_set_member(ast1, ast2)
1426
- Z3::VeryLowLevel.Z3_mk_set_member(_ctx_pointer, ast1._ast, ast2._ast)
1427
- end
1427
+ def mk_set_member(ast1, ast2) #=> :ast_pointer
1428
+ Z3::VeryLowLevel.Z3_mk_set_member(_ctx_pointer, ast1._ast, ast2._ast)
1429
+ end
1428
1430
 
1429
- def mk_set_sort(sort)
1430
- Z3::VeryLowLevel.Z3_mk_set_sort(_ctx_pointer, sort._sort)
1431
- end
1431
+ def mk_set_sort(sort) #=> :sort_pointer
1432
+ Z3::VeryLowLevel.Z3_mk_set_sort(_ctx_pointer, sort._sort)
1433
+ end
1432
1434
 
1433
- def mk_set_subset(ast1, ast2)
1434
- Z3::VeryLowLevel.Z3_mk_set_subset(_ctx_pointer, ast1._ast, ast2._ast)
1435
- end
1435
+ def mk_set_subset(ast1, ast2) #=> :ast_pointer
1436
+ Z3::VeryLowLevel.Z3_mk_set_subset(_ctx_pointer, ast1._ast, ast2._ast)
1437
+ end
1436
1438
 
1437
- def mk_sign_ext(num, ast)
1438
- Z3::VeryLowLevel.Z3_mk_sign_ext(_ctx_pointer, num, ast._ast)
1439
- end
1439
+ def mk_sign_ext(num, ast) #=> :ast_pointer
1440
+ Z3::VeryLowLevel.Z3_mk_sign_ext(_ctx_pointer, num, ast._ast)
1441
+ end
1440
1442
 
1441
- def mk_simple_solver
1442
- Z3::VeryLowLevel.Z3_mk_simple_solver(_ctx_pointer)
1443
- end
1443
+ def mk_simple_solver #=> :solver_pointer
1444
+ Z3::VeryLowLevel.Z3_mk_simple_solver(_ctx_pointer)
1445
+ end
1444
1446
 
1445
- def mk_solver
1446
- Z3::VeryLowLevel.Z3_mk_solver(_ctx_pointer)
1447
- end
1447
+ def mk_solver #=> :solver_pointer
1448
+ Z3::VeryLowLevel.Z3_mk_solver(_ctx_pointer)
1449
+ end
1448
1450
 
1449
- def mk_solver_for_logic(sym)
1450
- Z3::VeryLowLevel.Z3_mk_solver_for_logic(_ctx_pointer, sym)
1451
- end
1451
+ def mk_solver_for_logic(sym) #=> :solver_pointer
1452
+ Z3::VeryLowLevel.Z3_mk_solver_for_logic(_ctx_pointer, sym)
1453
+ end
1452
1454
 
1453
- def mk_solver_from_tactic(tactic)
1454
- Z3::VeryLowLevel.Z3_mk_solver_from_tactic(_ctx_pointer, tactic._tactic)
1455
- end
1455
+ def mk_solver_from_tactic(tactic) #=> :solver_pointer
1456
+ Z3::VeryLowLevel.Z3_mk_solver_from_tactic(_ctx_pointer, tactic._tactic)
1457
+ end
1456
1458
 
1457
- def mk_store(ast1, ast2, ast3)
1458
- Z3::VeryLowLevel.Z3_mk_store(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1459
- end
1459
+ def mk_store(ast1, ast2, ast3) #=> :ast_pointer
1460
+ Z3::VeryLowLevel.Z3_mk_store(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1461
+ end
1460
1462
 
1461
- def mk_string_symbol(str)
1462
- Z3::VeryLowLevel.Z3_mk_string_symbol(_ctx_pointer, str)
1463
- end
1463
+ def mk_string_symbol(str) #=> :symbol_pointer
1464
+ Z3::VeryLowLevel.Z3_mk_string_symbol(_ctx_pointer, str)
1465
+ end
1464
1466
 
1465
- def mk_tactic(str)
1466
- Z3::VeryLowLevel.Z3_mk_tactic(_ctx_pointer, str)
1467
- end
1467
+ def mk_tactic(str) #=> :tactic_pointer
1468
+ Z3::VeryLowLevel.Z3_mk_tactic(_ctx_pointer, str)
1469
+ end
1468
1470
 
1469
- def mk_true
1470
- Z3::VeryLowLevel.Z3_mk_true(_ctx_pointer)
1471
- end
1471
+ def mk_true #=> :ast_pointer
1472
+ Z3::VeryLowLevel.Z3_mk_true(_ctx_pointer)
1473
+ end
1472
1474
 
1473
- def mk_unary_minus(ast)
1474
- Z3::VeryLowLevel.Z3_mk_unary_minus(_ctx_pointer, ast._ast)
1475
- end
1475
+ def mk_unary_minus(ast) #=> :ast_pointer
1476
+ Z3::VeryLowLevel.Z3_mk_unary_minus(_ctx_pointer, ast._ast)
1477
+ end
1476
1478
 
1477
- def mk_uninterpreted_sort(sym)
1478
- Z3::VeryLowLevel.Z3_mk_uninterpreted_sort(_ctx_pointer, sym)
1479
- end
1479
+ def mk_uninterpreted_sort(sym) #=> :sort_pointer
1480
+ Z3::VeryLowLevel.Z3_mk_uninterpreted_sort(_ctx_pointer, sym)
1481
+ end
1480
1482
 
1481
- def mk_unsigned_int(num, sort)
1482
- Z3::VeryLowLevel.Z3_mk_unsigned_int(_ctx_pointer, num, sort._sort)
1483
- end
1483
+ def mk_unsigned_int(num, sort) #=> :ast_pointer
1484
+ Z3::VeryLowLevel.Z3_mk_unsigned_int(_ctx_pointer, num, sort._sort)
1485
+ end
1484
1486
 
1485
- def mk_unsigned_int64(num, sort)
1486
- Z3::VeryLowLevel.Z3_mk_unsigned_int64(_ctx_pointer, num, sort._sort)
1487
- end
1487
+ def mk_unsigned_int64(num, sort) #=> :ast_pointer
1488
+ Z3::VeryLowLevel.Z3_mk_unsigned_int64(_ctx_pointer, num, sort._sort)
1489
+ end
1488
1490
 
1489
- def mk_xor(ast1, ast2)
1490
- Z3::VeryLowLevel.Z3_mk_xor(_ctx_pointer, ast1._ast, ast2._ast)
1491
- end
1491
+ def mk_xor(ast1, ast2) #=> :ast_pointer
1492
+ Z3::VeryLowLevel.Z3_mk_xor(_ctx_pointer, ast1._ast, ast2._ast)
1493
+ end
1492
1494
 
1493
- def mk_zero_ext(num, ast)
1494
- Z3::VeryLowLevel.Z3_mk_zero_ext(_ctx_pointer, num, ast._ast)
1495
- end
1495
+ def mk_zero_ext(num, ast) #=> :ast_pointer
1496
+ Z3::VeryLowLevel.Z3_mk_zero_ext(_ctx_pointer, num, ast._ast)
1497
+ end
1496
1498
 
1497
- def model_dec_ref(model)
1498
- Z3::VeryLowLevel.Z3_model_dec_ref(_ctx_pointer, model._model)
1499
- end
1499
+ def model_dec_ref(model) #=> :void
1500
+ Z3::VeryLowLevel.Z3_model_dec_ref(_ctx_pointer, model._model)
1501
+ end
1500
1502
 
1501
- def model_get_const_decl(model, num)
1502
- Z3::VeryLowLevel.Z3_model_get_const_decl(_ctx_pointer, model._model, num)
1503
- end
1503
+ def model_get_const_decl(model, num) #=> :func_decl_pointer
1504
+ Z3::VeryLowLevel.Z3_model_get_const_decl(_ctx_pointer, model._model, num)
1505
+ end
1504
1506
 
1505
- def model_get_const_interp(model, func_decl)
1506
- Z3::VeryLowLevel.Z3_model_get_const_interp(_ctx_pointer, model._model, func_decl._func_decl)
1507
- end
1507
+ def model_get_const_interp(model, func_decl) #=> :ast_pointer
1508
+ Z3::VeryLowLevel.Z3_model_get_const_interp(_ctx_pointer, model._model, func_decl._func_decl)
1509
+ end
1508
1510
 
1509
- def model_get_func_decl(model, num)
1510
- Z3::VeryLowLevel.Z3_model_get_func_decl(_ctx_pointer, model._model, num)
1511
- end
1511
+ def model_get_func_decl(model, num) #=> :func_decl_pointer
1512
+ Z3::VeryLowLevel.Z3_model_get_func_decl(_ctx_pointer, model._model, num)
1513
+ end
1512
1514
 
1513
- def model_get_func_interp(model, func_decl)
1514
- Z3::VeryLowLevel.Z3_model_get_func_interp(_ctx_pointer, model._model, func_decl._func_decl)
1515
- end
1515
+ def model_get_func_interp(model, func_decl) #=> :func_interp_pointer
1516
+ Z3::VeryLowLevel.Z3_model_get_func_interp(_ctx_pointer, model._model, func_decl._func_decl)
1517
+ end
1516
1518
 
1517
- def model_get_num_consts(model)
1518
- Z3::VeryLowLevel.Z3_model_get_num_consts(_ctx_pointer, model._model)
1519
- end
1519
+ def model_get_num_consts(model) #=> :uint
1520
+ Z3::VeryLowLevel.Z3_model_get_num_consts(_ctx_pointer, model._model)
1521
+ end
1520
1522
 
1521
- def model_get_num_funcs(model)
1522
- Z3::VeryLowLevel.Z3_model_get_num_funcs(_ctx_pointer, model._model)
1523
- end
1523
+ def model_get_num_funcs(model) #=> :uint
1524
+ Z3::VeryLowLevel.Z3_model_get_num_funcs(_ctx_pointer, model._model)
1525
+ end
1524
1526
 
1525
- def model_get_num_sorts(model)
1526
- Z3::VeryLowLevel.Z3_model_get_num_sorts(_ctx_pointer, model._model)
1527
- end
1527
+ def model_get_num_sorts(model) #=> :uint
1528
+ Z3::VeryLowLevel.Z3_model_get_num_sorts(_ctx_pointer, model._model)
1529
+ end
1528
1530
 
1529
- def model_get_sort(model, num)
1530
- Z3::VeryLowLevel.Z3_model_get_sort(_ctx_pointer, model._model, num)
1531
- end
1531
+ def model_get_sort(model, num) #=> :sort_pointer
1532
+ Z3::VeryLowLevel.Z3_model_get_sort(_ctx_pointer, model._model, num)
1533
+ end
1532
1534
 
1533
- def model_get_sort_universe(model, sort)
1534
- Z3::VeryLowLevel.Z3_model_get_sort_universe(_ctx_pointer, model._model, sort._sort)
1535
- end
1535
+ def model_get_sort_universe(model, sort) #=> :ast_vector_pointer
1536
+ Z3::VeryLowLevel.Z3_model_get_sort_universe(_ctx_pointer, model._model, sort._sort)
1537
+ end
1536
1538
 
1537
- def model_has_interp(model, func_decl)
1538
- Z3::VeryLowLevel.Z3_model_has_interp(_ctx_pointer, model._model, func_decl._func_decl)
1539
- end
1539
+ def model_has_interp(model, func_decl) #=> :bool
1540
+ Z3::VeryLowLevel.Z3_model_has_interp(_ctx_pointer, model._model, func_decl._func_decl)
1541
+ end
1540
1542
 
1541
- def model_inc_ref(model)
1542
- Z3::VeryLowLevel.Z3_model_inc_ref(_ctx_pointer, model._model)
1543
- end
1543
+ def model_inc_ref(model) #=> :void
1544
+ Z3::VeryLowLevel.Z3_model_inc_ref(_ctx_pointer, model._model)
1545
+ end
1544
1546
 
1545
- def model_to_string(model)
1546
- Z3::VeryLowLevel.Z3_model_to_string(_ctx_pointer, model._model)
1547
- end
1547
+ def model_to_string(model) #=> :string
1548
+ Z3::VeryLowLevel.Z3_model_to_string(_ctx_pointer, model._model)
1549
+ end
1548
1550
 
1549
- def optimize_assert(optimize, ast)
1550
- Z3::VeryLowLevel.Z3_optimize_assert(_ctx_pointer, optimize._optimize, ast._ast)
1551
- end
1551
+ def optimize_assert(optimize, ast) #=> :void
1552
+ Z3::VeryLowLevel.Z3_optimize_assert(_ctx_pointer, optimize._optimize, ast._ast)
1553
+ end
1552
1554
 
1553
- def optimize_assert_soft(optimize, ast, str, sym)
1554
- Z3::VeryLowLevel.Z3_optimize_assert_soft(_ctx_pointer, optimize._optimize, ast._ast, str, sym)
1555
- end
1555
+ def optimize_assert_soft(optimize, ast, str, sym) #=> :uint
1556
+ Z3::VeryLowLevel.Z3_optimize_assert_soft(_ctx_pointer, optimize._optimize, ast._ast, str, sym)
1557
+ end
1556
1558
 
1557
- def optimize_check(optimize)
1558
- Z3::VeryLowLevel.Z3_optimize_check(_ctx_pointer, optimize._optimize)
1559
- end
1559
+ def optimize_check(optimize) #=> :int
1560
+ Z3::VeryLowLevel.Z3_optimize_check(_ctx_pointer, optimize._optimize)
1561
+ end
1560
1562
 
1561
- def optimize_dec_ref(optimize)
1562
- Z3::VeryLowLevel.Z3_optimize_dec_ref(_ctx_pointer, optimize._optimize)
1563
- end
1563
+ def optimize_dec_ref(optimize) #=> :void
1564
+ Z3::VeryLowLevel.Z3_optimize_dec_ref(_ctx_pointer, optimize._optimize)
1565
+ end
1564
1566
 
1565
- def optimize_get_help(optimize)
1566
- Z3::VeryLowLevel.Z3_optimize_get_help(_ctx_pointer, optimize._optimize)
1567
- end
1567
+ def optimize_get_help(optimize) #=> :string
1568
+ Z3::VeryLowLevel.Z3_optimize_get_help(_ctx_pointer, optimize._optimize)
1569
+ end
1568
1570
 
1569
- def optimize_get_lower(optimize, num)
1570
- Z3::VeryLowLevel.Z3_optimize_get_lower(_ctx_pointer, optimize._optimize, num)
1571
- end
1571
+ def optimize_get_lower(optimize, num) #=> :ast_pointer
1572
+ Z3::VeryLowLevel.Z3_optimize_get_lower(_ctx_pointer, optimize._optimize, num)
1573
+ end
1572
1574
 
1573
- def optimize_get_model(optimize)
1574
- Z3::VeryLowLevel.Z3_optimize_get_model(_ctx_pointer, optimize._optimize)
1575
- end
1575
+ def optimize_get_model(optimize) #=> :model_pointer
1576
+ Z3::VeryLowLevel.Z3_optimize_get_model(_ctx_pointer, optimize._optimize)
1577
+ end
1576
1578
 
1577
- def optimize_get_param_descrs(optimize)
1578
- Z3::VeryLowLevel.Z3_optimize_get_param_descrs(_ctx_pointer, optimize._optimize)
1579
- end
1579
+ def optimize_get_param_descrs(optimize) #=> :param_descrs_pointer
1580
+ Z3::VeryLowLevel.Z3_optimize_get_param_descrs(_ctx_pointer, optimize._optimize)
1581
+ end
1580
1582
 
1581
- def optimize_get_reason_unknown(optimize)
1582
- Z3::VeryLowLevel.Z3_optimize_get_reason_unknown(_ctx_pointer, optimize._optimize)
1583
- end
1583
+ def optimize_get_reason_unknown(optimize) #=> :string
1584
+ Z3::VeryLowLevel.Z3_optimize_get_reason_unknown(_ctx_pointer, optimize._optimize)
1585
+ end
1584
1586
 
1585
- def optimize_get_statistics(optimize)
1586
- Z3::VeryLowLevel.Z3_optimize_get_statistics(_ctx_pointer, optimize._optimize)
1587
- end
1587
+ def optimize_get_statistics(optimize) #=> :stats_pointer
1588
+ Z3::VeryLowLevel.Z3_optimize_get_statistics(_ctx_pointer, optimize._optimize)
1589
+ end
1588
1590
 
1589
- def optimize_get_upper(optimize, num)
1590
- Z3::VeryLowLevel.Z3_optimize_get_upper(_ctx_pointer, optimize._optimize, num)
1591
- end
1591
+ def optimize_get_upper(optimize, num) #=> :ast_pointer
1592
+ Z3::VeryLowLevel.Z3_optimize_get_upper(_ctx_pointer, optimize._optimize, num)
1593
+ end
1592
1594
 
1593
- def optimize_inc_ref(optimize)
1594
- Z3::VeryLowLevel.Z3_optimize_inc_ref(_ctx_pointer, optimize._optimize)
1595
- end
1595
+ def optimize_inc_ref(optimize) #=> :void
1596
+ Z3::VeryLowLevel.Z3_optimize_inc_ref(_ctx_pointer, optimize._optimize)
1597
+ end
1596
1598
 
1597
- def optimize_maximize(optimize, ast)
1598
- Z3::VeryLowLevel.Z3_optimize_maximize(_ctx_pointer, optimize._optimize, ast._ast)
1599
- end
1599
+ def optimize_maximize(optimize, ast) #=> :uint
1600
+ Z3::VeryLowLevel.Z3_optimize_maximize(_ctx_pointer, optimize._optimize, ast._ast)
1601
+ end
1600
1602
 
1601
- def optimize_minimize(optimize, ast)
1602
- Z3::VeryLowLevel.Z3_optimize_minimize(_ctx_pointer, optimize._optimize, ast._ast)
1603
- end
1603
+ def optimize_minimize(optimize, ast) #=> :uint
1604
+ Z3::VeryLowLevel.Z3_optimize_minimize(_ctx_pointer, optimize._optimize, ast._ast)
1605
+ end
1604
1606
 
1605
- def optimize_pop(optimize)
1606
- Z3::VeryLowLevel.Z3_optimize_pop(_ctx_pointer, optimize._optimize)
1607
- end
1607
+ def optimize_pop(optimize) #=> :void
1608
+ Z3::VeryLowLevel.Z3_optimize_pop(_ctx_pointer, optimize._optimize)
1609
+ end
1608
1610
 
1609
- def optimize_push(optimize)
1610
- Z3::VeryLowLevel.Z3_optimize_push(_ctx_pointer, optimize._optimize)
1611
- end
1611
+ def optimize_push(optimize) #=> :void
1612
+ Z3::VeryLowLevel.Z3_optimize_push(_ctx_pointer, optimize._optimize)
1613
+ end
1612
1614
 
1613
- def optimize_set_params(optimize, params)
1614
- Z3::VeryLowLevel.Z3_optimize_set_params(_ctx_pointer, optimize._optimize, params._params)
1615
- end
1615
+ def optimize_set_params(optimize, params) #=> :void
1616
+ Z3::VeryLowLevel.Z3_optimize_set_params(_ctx_pointer, optimize._optimize, params._params)
1617
+ end
1616
1618
 
1617
- def optimize_to_string(optimize)
1618
- Z3::VeryLowLevel.Z3_optimize_to_string(_ctx_pointer, optimize._optimize)
1619
- end
1619
+ def optimize_to_string(optimize) #=> :string
1620
+ Z3::VeryLowLevel.Z3_optimize_to_string(_ctx_pointer, optimize._optimize)
1621
+ end
1620
1622
 
1621
- def param_descrs_dec_ref(param_descrs)
1622
- Z3::VeryLowLevel.Z3_param_descrs_dec_ref(_ctx_pointer, param_descrs._param_descrs)
1623
- end
1623
+ def param_descrs_dec_ref(param_descrs) #=> :void
1624
+ Z3::VeryLowLevel.Z3_param_descrs_dec_ref(_ctx_pointer, param_descrs._param_descrs)
1625
+ end
1624
1626
 
1625
- def param_descrs_get_kind(param_descrs, sym)
1626
- Z3::VeryLowLevel.Z3_param_descrs_get_kind(_ctx_pointer, param_descrs._param_descrs, sym)
1627
- end
1627
+ def param_descrs_get_kind(param_descrs, sym) #=> :uint
1628
+ Z3::VeryLowLevel.Z3_param_descrs_get_kind(_ctx_pointer, param_descrs._param_descrs, sym)
1629
+ end
1628
1630
 
1629
- def param_descrs_get_name(param_descrs, num)
1630
- Z3::VeryLowLevel.Z3_param_descrs_get_name(_ctx_pointer, param_descrs._param_descrs, num)
1631
- end
1631
+ def param_descrs_get_name(param_descrs, num) #=> :symbol_pointer
1632
+ Z3::VeryLowLevel.Z3_param_descrs_get_name(_ctx_pointer, param_descrs._param_descrs, num)
1633
+ end
1632
1634
 
1633
- def param_descrs_inc_ref(param_descrs)
1634
- Z3::VeryLowLevel.Z3_param_descrs_inc_ref(_ctx_pointer, param_descrs._param_descrs)
1635
- end
1635
+ def param_descrs_inc_ref(param_descrs) #=> :void
1636
+ Z3::VeryLowLevel.Z3_param_descrs_inc_ref(_ctx_pointer, param_descrs._param_descrs)
1637
+ end
1636
1638
 
1637
- def param_descrs_size(param_descrs)
1638
- Z3::VeryLowLevel.Z3_param_descrs_size(_ctx_pointer, param_descrs._param_descrs)
1639
- end
1639
+ def param_descrs_size(param_descrs) #=> :uint
1640
+ Z3::VeryLowLevel.Z3_param_descrs_size(_ctx_pointer, param_descrs._param_descrs)
1641
+ end
1640
1642
 
1641
- def param_descrs_to_string(param_descrs)
1642
- Z3::VeryLowLevel.Z3_param_descrs_to_string(_ctx_pointer, param_descrs._param_descrs)
1643
- end
1643
+ def param_descrs_to_string(param_descrs) #=> :string
1644
+ Z3::VeryLowLevel.Z3_param_descrs_to_string(_ctx_pointer, param_descrs._param_descrs)
1645
+ end
1644
1646
 
1645
- def params_dec_ref(params)
1646
- Z3::VeryLowLevel.Z3_params_dec_ref(_ctx_pointer, params._params)
1647
- end
1647
+ def params_dec_ref(params) #=> :void
1648
+ Z3::VeryLowLevel.Z3_params_dec_ref(_ctx_pointer, params._params)
1649
+ end
1648
1650
 
1649
- def params_inc_ref(params)
1650
- Z3::VeryLowLevel.Z3_params_inc_ref(_ctx_pointer, params._params)
1651
- end
1651
+ def params_inc_ref(params) #=> :void
1652
+ Z3::VeryLowLevel.Z3_params_inc_ref(_ctx_pointer, params._params)
1653
+ end
1652
1654
 
1653
- def params_set_bool(params, sym, bool)
1654
- Z3::VeryLowLevel.Z3_params_set_bool(_ctx_pointer, params._params, sym, bool)
1655
- end
1655
+ def params_set_bool(params, sym, bool) #=> :void
1656
+ Z3::VeryLowLevel.Z3_params_set_bool(_ctx_pointer, params._params, sym, bool)
1657
+ end
1656
1658
 
1657
- def params_set_double(params, sym, double)
1658
- Z3::VeryLowLevel.Z3_params_set_double(_ctx_pointer, params._params, sym, double)
1659
- end
1659
+ def params_set_double(params, sym, double) #=> :void
1660
+ Z3::VeryLowLevel.Z3_params_set_double(_ctx_pointer, params._params, sym, double)
1661
+ end
1660
1662
 
1661
- def params_set_symbol(params, sym1, sym2)
1662
- Z3::VeryLowLevel.Z3_params_set_symbol(_ctx_pointer, params._params, sym1, sym2)
1663
- end
1663
+ def params_set_symbol(params, sym1, sym2) #=> :void
1664
+ Z3::VeryLowLevel.Z3_params_set_symbol(_ctx_pointer, params._params, sym1, sym2)
1665
+ end
1664
1666
 
1665
- def params_set_uint(params, sym, num)
1666
- Z3::VeryLowLevel.Z3_params_set_uint(_ctx_pointer, params._params, sym, num)
1667
- end
1667
+ def params_set_uint(params, sym, num) #=> :void
1668
+ Z3::VeryLowLevel.Z3_params_set_uint(_ctx_pointer, params._params, sym, num)
1669
+ end
1668
1670
 
1669
- def params_to_string(params)
1670
- Z3::VeryLowLevel.Z3_params_to_string(_ctx_pointer, params._params)
1671
- end
1671
+ def params_to_string(params) #=> :string
1672
+ Z3::VeryLowLevel.Z3_params_to_string(_ctx_pointer, params._params)
1673
+ end
1672
1674
 
1673
- def params_validate(params, param_descrs)
1674
- Z3::VeryLowLevel.Z3_params_validate(_ctx_pointer, params._params, param_descrs._param_descrs)
1675
- end
1675
+ def params_validate(params, param_descrs) #=> :void
1676
+ Z3::VeryLowLevel.Z3_params_validate(_ctx_pointer, params._params, param_descrs._param_descrs)
1677
+ end
1676
1678
 
1677
- def pattern_to_ast(pattern)
1678
- Z3::VeryLowLevel.Z3_pattern_to_ast(_ctx_pointer, pattern._pattern)
1679
- end
1679
+ def pattern_to_ast(pattern) #=> :ast_pointer
1680
+ Z3::VeryLowLevel.Z3_pattern_to_ast(_ctx_pointer, pattern._pattern)
1681
+ end
1680
1682
 
1681
- def pattern_to_string(pattern)
1682
- Z3::VeryLowLevel.Z3_pattern_to_string(_ctx_pointer, pattern._pattern)
1683
- end
1683
+ def pattern_to_string(pattern) #=> :string
1684
+ Z3::VeryLowLevel.Z3_pattern_to_string(_ctx_pointer, pattern._pattern)
1685
+ end
1684
1686
 
1685
- def polynomial_subresultants(ast1, ast2, ast3)
1686
- Z3::VeryLowLevel.Z3_polynomial_subresultants(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1687
- end
1687
+ def polynomial_subresultants(ast1, ast2, ast3) #=> :ast_vector_pointer
1688
+ Z3::VeryLowLevel.Z3_polynomial_subresultants(_ctx_pointer, ast1._ast, ast2._ast, ast3._ast)
1689
+ end
1688
1690
 
1689
- def probe_and(probe1, probe2)
1690
- Z3::VeryLowLevel.Z3_probe_and(_ctx_pointer, probe1._probe, probe2._probe)
1691
- end
1691
+ def probe_and(probe1, probe2) #=> :probe_pointer
1692
+ Z3::VeryLowLevel.Z3_probe_and(_ctx_pointer, probe1._probe, probe2._probe)
1693
+ end
1692
1694
 
1693
- def probe_apply(probe, goal)
1694
- Z3::VeryLowLevel.Z3_probe_apply(_ctx_pointer, probe._probe, goal._goal)
1695
- end
1695
+ def probe_apply(probe, goal) #=> :double
1696
+ Z3::VeryLowLevel.Z3_probe_apply(_ctx_pointer, probe._probe, goal._goal)
1697
+ end
1696
1698
 
1697
- def probe_const(double)
1698
- Z3::VeryLowLevel.Z3_probe_const(_ctx_pointer, double)
1699
- end
1699
+ def probe_const(double) #=> :probe_pointer
1700
+ Z3::VeryLowLevel.Z3_probe_const(_ctx_pointer, double)
1701
+ end
1700
1702
 
1701
- def probe_dec_ref(probe)
1702
- Z3::VeryLowLevel.Z3_probe_dec_ref(_ctx_pointer, probe._probe)
1703
- end
1703
+ def probe_dec_ref(probe) #=> :void
1704
+ Z3::VeryLowLevel.Z3_probe_dec_ref(_ctx_pointer, probe._probe)
1705
+ end
1704
1706
 
1705
- def probe_eq(probe1, probe2)
1706
- Z3::VeryLowLevel.Z3_probe_eq(_ctx_pointer, probe1._probe, probe2._probe)
1707
- end
1707
+ def probe_eq(probe1, probe2) #=> :probe_pointer
1708
+ Z3::VeryLowLevel.Z3_probe_eq(_ctx_pointer, probe1._probe, probe2._probe)
1709
+ end
1708
1710
 
1709
- def probe_ge(probe1, probe2)
1710
- Z3::VeryLowLevel.Z3_probe_ge(_ctx_pointer, probe1._probe, probe2._probe)
1711
- end
1711
+ def probe_ge(probe1, probe2) #=> :probe_pointer
1712
+ Z3::VeryLowLevel.Z3_probe_ge(_ctx_pointer, probe1._probe, probe2._probe)
1713
+ end
1712
1714
 
1713
- def probe_get_descr(str)
1714
- Z3::VeryLowLevel.Z3_probe_get_descr(_ctx_pointer, str)
1715
- end
1715
+ def probe_get_descr(str) #=> :string
1716
+ Z3::VeryLowLevel.Z3_probe_get_descr(_ctx_pointer, str)
1717
+ end
1716
1718
 
1717
- def probe_gt(probe1, probe2)
1718
- Z3::VeryLowLevel.Z3_probe_gt(_ctx_pointer, probe1._probe, probe2._probe)
1719
- end
1719
+ def probe_gt(probe1, probe2) #=> :probe_pointer
1720
+ Z3::VeryLowLevel.Z3_probe_gt(_ctx_pointer, probe1._probe, probe2._probe)
1721
+ end
1720
1722
 
1721
- def probe_inc_ref(probe)
1722
- Z3::VeryLowLevel.Z3_probe_inc_ref(_ctx_pointer, probe._probe)
1723
- end
1723
+ def probe_inc_ref(probe) #=> :void
1724
+ Z3::VeryLowLevel.Z3_probe_inc_ref(_ctx_pointer, probe._probe)
1725
+ end
1724
1726
 
1725
- def probe_le(probe1, probe2)
1726
- Z3::VeryLowLevel.Z3_probe_le(_ctx_pointer, probe1._probe, probe2._probe)
1727
- end
1727
+ def probe_le(probe1, probe2) #=> :probe_pointer
1728
+ Z3::VeryLowLevel.Z3_probe_le(_ctx_pointer, probe1._probe, probe2._probe)
1729
+ end
1728
1730
 
1729
- def probe_lt(probe1, probe2)
1730
- Z3::VeryLowLevel.Z3_probe_lt(_ctx_pointer, probe1._probe, probe2._probe)
1731
- end
1731
+ def probe_lt(probe1, probe2) #=> :probe_pointer
1732
+ Z3::VeryLowLevel.Z3_probe_lt(_ctx_pointer, probe1._probe, probe2._probe)
1733
+ end
1732
1734
 
1733
- def probe_not(probe)
1734
- Z3::VeryLowLevel.Z3_probe_not(_ctx_pointer, probe._probe)
1735
- end
1735
+ def probe_not(probe) #=> :probe_pointer
1736
+ Z3::VeryLowLevel.Z3_probe_not(_ctx_pointer, probe._probe)
1737
+ end
1736
1738
 
1737
- def probe_or(probe1, probe2)
1738
- Z3::VeryLowLevel.Z3_probe_or(_ctx_pointer, probe1._probe, probe2._probe)
1739
- end
1739
+ def probe_or(probe1, probe2) #=> :probe_pointer
1740
+ Z3::VeryLowLevel.Z3_probe_or(_ctx_pointer, probe1._probe, probe2._probe)
1741
+ end
1740
1742
 
1741
- def rcf_add(num1, num2)
1742
- Z3::VeryLowLevel.Z3_rcf_add(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1743
- end
1743
+ def rcf_add(num1, num2) #=> :rcf_num_pointer
1744
+ Z3::VeryLowLevel.Z3_rcf_add(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1745
+ end
1744
1746
 
1745
- def rcf_del(num)
1746
- Z3::VeryLowLevel.Z3_rcf_del(_ctx_pointer, num._rcf_num)
1747
- end
1747
+ def rcf_del(num) #=> :void
1748
+ Z3::VeryLowLevel.Z3_rcf_del(_ctx_pointer, num._rcf_num)
1749
+ end
1748
1750
 
1749
- def rcf_div(num1, num2)
1750
- Z3::VeryLowLevel.Z3_rcf_div(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1751
- end
1751
+ def rcf_div(num1, num2) #=> :rcf_num_pointer
1752
+ Z3::VeryLowLevel.Z3_rcf_div(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1753
+ end
1752
1754
 
1753
- def rcf_eq(num1, num2)
1754
- Z3::VeryLowLevel.Z3_rcf_eq(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1755
- end
1755
+ def rcf_eq(num1, num2) #=> :bool
1756
+ Z3::VeryLowLevel.Z3_rcf_eq(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1757
+ end
1756
1758
 
1757
- def rcf_ge(num1, num2)
1758
- Z3::VeryLowLevel.Z3_rcf_ge(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1759
- end
1759
+ def rcf_ge(num1, num2) #=> :bool
1760
+ Z3::VeryLowLevel.Z3_rcf_ge(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1761
+ end
1760
1762
 
1761
- def rcf_gt(num1, num2)
1762
- Z3::VeryLowLevel.Z3_rcf_gt(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1763
- end
1763
+ def rcf_gt(num1, num2) #=> :bool
1764
+ Z3::VeryLowLevel.Z3_rcf_gt(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1765
+ end
1764
1766
 
1765
- def rcf_inv(num)
1766
- Z3::VeryLowLevel.Z3_rcf_inv(_ctx_pointer, num._rcf_num)
1767
- end
1767
+ def rcf_inv(num) #=> :rcf_num_pointer
1768
+ Z3::VeryLowLevel.Z3_rcf_inv(_ctx_pointer, num._rcf_num)
1769
+ end
1768
1770
 
1769
- def rcf_le(num1, num2)
1770
- Z3::VeryLowLevel.Z3_rcf_le(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1771
- end
1771
+ def rcf_le(num1, num2) #=> :bool
1772
+ Z3::VeryLowLevel.Z3_rcf_le(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1773
+ end
1772
1774
 
1773
- def rcf_lt(num1, num2)
1774
- Z3::VeryLowLevel.Z3_rcf_lt(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1775
- end
1775
+ def rcf_lt(num1, num2) #=> :bool
1776
+ Z3::VeryLowLevel.Z3_rcf_lt(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1777
+ end
1776
1778
 
1777
- def rcf_mk_e
1778
- Z3::VeryLowLevel.Z3_rcf_mk_e(_ctx_pointer)
1779
- end
1779
+ def rcf_mk_e #=> :rcf_num_pointer
1780
+ Z3::VeryLowLevel.Z3_rcf_mk_e(_ctx_pointer)
1781
+ end
1780
1782
 
1781
- def rcf_mk_infinitesimal
1782
- Z3::VeryLowLevel.Z3_rcf_mk_infinitesimal(_ctx_pointer)
1783
- end
1783
+ def rcf_mk_infinitesimal #=> :rcf_num_pointer
1784
+ Z3::VeryLowLevel.Z3_rcf_mk_infinitesimal(_ctx_pointer)
1785
+ end
1784
1786
 
1785
- def rcf_mk_pi
1786
- Z3::VeryLowLevel.Z3_rcf_mk_pi(_ctx_pointer)
1787
- end
1787
+ def rcf_mk_pi #=> :rcf_num_pointer
1788
+ Z3::VeryLowLevel.Z3_rcf_mk_pi(_ctx_pointer)
1789
+ end
1788
1790
 
1789
- def rcf_mk_rational(str)
1790
- Z3::VeryLowLevel.Z3_rcf_mk_rational(_ctx_pointer, str)
1791
- end
1791
+ def rcf_mk_rational(str) #=> :rcf_num_pointer
1792
+ Z3::VeryLowLevel.Z3_rcf_mk_rational(_ctx_pointer, str)
1793
+ end
1792
1794
 
1793
- def rcf_mk_small_int(num)
1794
- Z3::VeryLowLevel.Z3_rcf_mk_small_int(_ctx_pointer, num)
1795
- end
1795
+ def rcf_mk_small_int(num) #=> :rcf_num_pointer
1796
+ Z3::VeryLowLevel.Z3_rcf_mk_small_int(_ctx_pointer, num)
1797
+ end
1796
1798
 
1797
- def rcf_mul(num1, num2)
1798
- Z3::VeryLowLevel.Z3_rcf_mul(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1799
- end
1799
+ def rcf_mul(num1, num2) #=> :rcf_num_pointer
1800
+ Z3::VeryLowLevel.Z3_rcf_mul(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1801
+ end
1800
1802
 
1801
- def rcf_neg(num)
1802
- Z3::VeryLowLevel.Z3_rcf_neg(_ctx_pointer, num._rcf_num)
1803
- end
1803
+ def rcf_neg(num) #=> :rcf_num_pointer
1804
+ Z3::VeryLowLevel.Z3_rcf_neg(_ctx_pointer, num._rcf_num)
1805
+ end
1804
1806
 
1805
- def rcf_neq(num1, num2)
1806
- Z3::VeryLowLevel.Z3_rcf_neq(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1807
- end
1807
+ def rcf_neq(num1, num2) #=> :bool
1808
+ Z3::VeryLowLevel.Z3_rcf_neq(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1809
+ end
1808
1810
 
1809
- def rcf_num_to_decimal_string(num1, num2)
1810
- Z3::VeryLowLevel.Z3_rcf_num_to_decimal_string(_ctx_pointer, num1._rcf_num, num2)
1811
- end
1811
+ def rcf_num_to_decimal_string(num1, num2) #=> :string
1812
+ Z3::VeryLowLevel.Z3_rcf_num_to_decimal_string(_ctx_pointer, num1._rcf_num, num2)
1813
+ end
1812
1814
 
1813
- def rcf_num_to_string(num, bool1, bool2)
1814
- Z3::VeryLowLevel.Z3_rcf_num_to_string(_ctx_pointer, num._rcf_num, bool1, bool2)
1815
- end
1815
+ def rcf_num_to_string(num, bool1, bool2) #=> :string
1816
+ Z3::VeryLowLevel.Z3_rcf_num_to_string(_ctx_pointer, num._rcf_num, bool1, bool2)
1817
+ end
1816
1818
 
1817
- def rcf_power(num1, num2)
1818
- Z3::VeryLowLevel.Z3_rcf_power(_ctx_pointer, num1._rcf_num, num2)
1819
- end
1819
+ def rcf_power(num1, num2) #=> :rcf_num_pointer
1820
+ Z3::VeryLowLevel.Z3_rcf_power(_ctx_pointer, num1._rcf_num, num2)
1821
+ end
1820
1822
 
1821
- def rcf_sub(num1, num2)
1822
- Z3::VeryLowLevel.Z3_rcf_sub(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1823
- end
1823
+ def rcf_sub(num1, num2) #=> :rcf_num_pointer
1824
+ Z3::VeryLowLevel.Z3_rcf_sub(_ctx_pointer, num1._rcf_num, num2._rcf_num)
1825
+ end
1824
1826
 
1825
- def reset_memory
1826
- Z3::VeryLowLevel.Z3_reset_memory()
1827
- end
1827
+ def reset_memory #=> :void
1828
+ Z3::VeryLowLevel.Z3_reset_memory()
1829
+ end
1828
1830
 
1829
- def set_param_value(config, str1, str2)
1830
- Z3::VeryLowLevel.Z3_set_param_value(config._config, str1, str2)
1831
- end
1831
+ def set_param_value(config, str1, str2) #=> :void
1832
+ Z3::VeryLowLevel.Z3_set_param_value(config._config, str1, str2)
1833
+ end
1832
1834
 
1833
- def simplify(ast)
1834
- Z3::VeryLowLevel.Z3_simplify(_ctx_pointer, ast._ast)
1835
- end
1835
+ def simplify(ast) #=> :ast_pointer
1836
+ Z3::VeryLowLevel.Z3_simplify(_ctx_pointer, ast._ast)
1837
+ end
1836
1838
 
1837
- def simplify_ex(ast, params)
1838
- Z3::VeryLowLevel.Z3_simplify_ex(_ctx_pointer, ast._ast, params._params)
1839
- end
1839
+ def simplify_ex(ast, params) #=> :ast_pointer
1840
+ Z3::VeryLowLevel.Z3_simplify_ex(_ctx_pointer, ast._ast, params._params)
1841
+ end
1840
1842
 
1841
- def simplify_get_help
1842
- Z3::VeryLowLevel.Z3_simplify_get_help(_ctx_pointer)
1843
- end
1843
+ def simplify_get_help #=> :string
1844
+ Z3::VeryLowLevel.Z3_simplify_get_help(_ctx_pointer)
1845
+ end
1844
1846
 
1845
- def simplify_get_param_descrs
1846
- Z3::VeryLowLevel.Z3_simplify_get_param_descrs(_ctx_pointer)
1847
- end
1847
+ def simplify_get_param_descrs #=> :param_descrs_pointer
1848
+ Z3::VeryLowLevel.Z3_simplify_get_param_descrs(_ctx_pointer)
1849
+ end
1848
1850
 
1849
- def solver_assert(solver, ast)
1850
- Z3::VeryLowLevel.Z3_solver_assert(_ctx_pointer, solver._solver, ast._ast)
1851
- end
1851
+ def solver_assert(solver, ast) #=> :void
1852
+ Z3::VeryLowLevel.Z3_solver_assert(_ctx_pointer, solver._solver, ast._ast)
1853
+ end
1852
1854
 
1853
- def solver_assert_and_track(solver, ast1, ast2)
1854
- Z3::VeryLowLevel.Z3_solver_assert_and_track(_ctx_pointer, solver._solver, ast1._ast, ast2._ast)
1855
- end
1855
+ def solver_assert_and_track(solver, ast1, ast2) #=> :void
1856
+ Z3::VeryLowLevel.Z3_solver_assert_and_track(_ctx_pointer, solver._solver, ast1._ast, ast2._ast)
1857
+ end
1856
1858
 
1857
- def solver_check(solver)
1858
- Z3::VeryLowLevel.Z3_solver_check(_ctx_pointer, solver._solver)
1859
- end
1859
+ def solver_check(solver) #=> :int
1860
+ Z3::VeryLowLevel.Z3_solver_check(_ctx_pointer, solver._solver)
1861
+ end
1860
1862
 
1861
- def solver_dec_ref(solver)
1862
- Z3::VeryLowLevel.Z3_solver_dec_ref(_ctx_pointer, solver._solver)
1863
- end
1863
+ def solver_dec_ref(solver) #=> :void
1864
+ Z3::VeryLowLevel.Z3_solver_dec_ref(_ctx_pointer, solver._solver)
1865
+ end
1864
1866
 
1865
- def solver_get_assertions(solver)
1866
- Z3::VeryLowLevel.Z3_solver_get_assertions(_ctx_pointer, solver._solver)
1867
- end
1867
+ def solver_get_assertions(solver) #=> :ast_vector_pointer
1868
+ Z3::VeryLowLevel.Z3_solver_get_assertions(_ctx_pointer, solver._solver)
1869
+ end
1868
1870
 
1869
- def solver_get_help(solver)
1870
- Z3::VeryLowLevel.Z3_solver_get_help(_ctx_pointer, solver._solver)
1871
- end
1871
+ def solver_get_help(solver) #=> :string
1872
+ Z3::VeryLowLevel.Z3_solver_get_help(_ctx_pointer, solver._solver)
1873
+ end
1872
1874
 
1873
- def solver_get_model(solver)
1874
- Z3::VeryLowLevel.Z3_solver_get_model(_ctx_pointer, solver._solver)
1875
- end
1875
+ def solver_get_model(solver) #=> :model_pointer
1876
+ Z3::VeryLowLevel.Z3_solver_get_model(_ctx_pointer, solver._solver)
1877
+ end
1876
1878
 
1877
- def solver_get_num_scopes(solver)
1878
- Z3::VeryLowLevel.Z3_solver_get_num_scopes(_ctx_pointer, solver._solver)
1879
- end
1879
+ def solver_get_num_scopes(solver) #=> :uint
1880
+ Z3::VeryLowLevel.Z3_solver_get_num_scopes(_ctx_pointer, solver._solver)
1881
+ end
1880
1882
 
1881
- def solver_get_param_descrs(solver)
1882
- Z3::VeryLowLevel.Z3_solver_get_param_descrs(_ctx_pointer, solver._solver)
1883
- end
1883
+ def solver_get_param_descrs(solver) #=> :param_descrs_pointer
1884
+ Z3::VeryLowLevel.Z3_solver_get_param_descrs(_ctx_pointer, solver._solver)
1885
+ end
1884
1886
 
1885
- def solver_get_proof(solver)
1886
- Z3::VeryLowLevel.Z3_solver_get_proof(_ctx_pointer, solver._solver)
1887
- end
1887
+ def solver_get_proof(solver) #=> :ast_pointer
1888
+ Z3::VeryLowLevel.Z3_solver_get_proof(_ctx_pointer, solver._solver)
1889
+ end
1888
1890
 
1889
- def solver_get_reason_unknown(solver)
1890
- Z3::VeryLowLevel.Z3_solver_get_reason_unknown(_ctx_pointer, solver._solver)
1891
- end
1891
+ def solver_get_reason_unknown(solver) #=> :string
1892
+ Z3::VeryLowLevel.Z3_solver_get_reason_unknown(_ctx_pointer, solver._solver)
1893
+ end
1892
1894
 
1893
- def solver_get_statistics(solver)
1894
- Z3::VeryLowLevel.Z3_solver_get_statistics(_ctx_pointer, solver._solver)
1895
- end
1895
+ def solver_get_statistics(solver) #=> :stats_pointer
1896
+ Z3::VeryLowLevel.Z3_solver_get_statistics(_ctx_pointer, solver._solver)
1897
+ end
1896
1898
 
1897
- def solver_get_unsat_core(solver)
1898
- Z3::VeryLowLevel.Z3_solver_get_unsat_core(_ctx_pointer, solver._solver)
1899
- end
1899
+ def solver_get_unsat_core(solver) #=> :ast_vector_pointer
1900
+ Z3::VeryLowLevel.Z3_solver_get_unsat_core(_ctx_pointer, solver._solver)
1901
+ end
1900
1902
 
1901
- def solver_inc_ref(solver)
1902
- Z3::VeryLowLevel.Z3_solver_inc_ref(_ctx_pointer, solver._solver)
1903
- end
1903
+ def solver_inc_ref(solver) #=> :void
1904
+ Z3::VeryLowLevel.Z3_solver_inc_ref(_ctx_pointer, solver._solver)
1905
+ end
1904
1906
 
1905
- def solver_pop(solver, num)
1906
- Z3::VeryLowLevel.Z3_solver_pop(_ctx_pointer, solver._solver, num)
1907
- end
1907
+ def solver_pop(solver, num) #=> :void
1908
+ Z3::VeryLowLevel.Z3_solver_pop(_ctx_pointer, solver._solver, num)
1909
+ end
1908
1910
 
1909
- def solver_push(solver)
1910
- Z3::VeryLowLevel.Z3_solver_push(_ctx_pointer, solver._solver)
1911
- end
1911
+ def solver_push(solver) #=> :void
1912
+ Z3::VeryLowLevel.Z3_solver_push(_ctx_pointer, solver._solver)
1913
+ end
1912
1914
 
1913
- def solver_reset(solver)
1914
- Z3::VeryLowLevel.Z3_solver_reset(_ctx_pointer, solver._solver)
1915
- end
1915
+ def solver_reset(solver) #=> :void
1916
+ Z3::VeryLowLevel.Z3_solver_reset(_ctx_pointer, solver._solver)
1917
+ end
1916
1918
 
1917
- def solver_set_params(solver, params)
1918
- Z3::VeryLowLevel.Z3_solver_set_params(_ctx_pointer, solver._solver, params._params)
1919
- end
1919
+ def solver_set_params(solver, params) #=> :void
1920
+ Z3::VeryLowLevel.Z3_solver_set_params(_ctx_pointer, solver._solver, params._params)
1921
+ end
1920
1922
 
1921
- def solver_to_string(solver)
1922
- Z3::VeryLowLevel.Z3_solver_to_string(_ctx_pointer, solver._solver)
1923
- end
1923
+ def solver_to_string(solver) #=> :string
1924
+ Z3::VeryLowLevel.Z3_solver_to_string(_ctx_pointer, solver._solver)
1925
+ end
1924
1926
 
1925
- def sort_to_ast(sort)
1926
- Z3::VeryLowLevel.Z3_sort_to_ast(_ctx_pointer, sort._sort)
1927
- end
1927
+ def sort_to_ast(sort) #=> :ast_pointer
1928
+ Z3::VeryLowLevel.Z3_sort_to_ast(_ctx_pointer, sort._sort)
1929
+ end
1928
1930
 
1929
- def sort_to_string(sort)
1930
- Z3::VeryLowLevel.Z3_sort_to_string(_ctx_pointer, sort._sort)
1931
- end
1931
+ def sort_to_string(sort) #=> :string
1932
+ Z3::VeryLowLevel.Z3_sort_to_string(_ctx_pointer, sort._sort)
1933
+ end
1932
1934
 
1933
- def stats_dec_ref(stats)
1934
- Z3::VeryLowLevel.Z3_stats_dec_ref(_ctx_pointer, stats._stats)
1935
- end
1935
+ def stats_dec_ref(stats) #=> :void
1936
+ Z3::VeryLowLevel.Z3_stats_dec_ref(_ctx_pointer, stats._stats)
1937
+ end
1936
1938
 
1937
- def stats_get_double_value(stats, num)
1938
- Z3::VeryLowLevel.Z3_stats_get_double_value(_ctx_pointer, stats._stats, num)
1939
- end
1939
+ def stats_get_double_value(stats, num) #=> :double
1940
+ Z3::VeryLowLevel.Z3_stats_get_double_value(_ctx_pointer, stats._stats, num)
1941
+ end
1940
1942
 
1941
- def stats_get_key(stats, num)
1942
- Z3::VeryLowLevel.Z3_stats_get_key(_ctx_pointer, stats._stats, num)
1943
- end
1943
+ def stats_get_key(stats, num) #=> :string
1944
+ Z3::VeryLowLevel.Z3_stats_get_key(_ctx_pointer, stats._stats, num)
1945
+ end
1944
1946
 
1945
- def stats_get_uint_value(stats, num)
1946
- Z3::VeryLowLevel.Z3_stats_get_uint_value(_ctx_pointer, stats._stats, num)
1947
- end
1947
+ def stats_get_uint_value(stats, num) #=> :uint
1948
+ Z3::VeryLowLevel.Z3_stats_get_uint_value(_ctx_pointer, stats._stats, num)
1949
+ end
1948
1950
 
1949
- def stats_inc_ref(stats)
1950
- Z3::VeryLowLevel.Z3_stats_inc_ref(_ctx_pointer, stats._stats)
1951
- end
1951
+ def stats_inc_ref(stats) #=> :void
1952
+ Z3::VeryLowLevel.Z3_stats_inc_ref(_ctx_pointer, stats._stats)
1953
+ end
1952
1954
 
1953
- def stats_is_double(stats, num)
1954
- Z3::VeryLowLevel.Z3_stats_is_double(_ctx_pointer, stats._stats, num)
1955
- end
1955
+ def stats_is_double(stats, num) #=> :bool
1956
+ Z3::VeryLowLevel.Z3_stats_is_double(_ctx_pointer, stats._stats, num)
1957
+ end
1956
1958
 
1957
- def stats_is_uint(stats, num)
1958
- Z3::VeryLowLevel.Z3_stats_is_uint(_ctx_pointer, stats._stats, num)
1959
- end
1959
+ def stats_is_uint(stats, num) #=> :bool
1960
+ Z3::VeryLowLevel.Z3_stats_is_uint(_ctx_pointer, stats._stats, num)
1961
+ end
1960
1962
 
1961
- def stats_size(stats)
1962
- Z3::VeryLowLevel.Z3_stats_size(_ctx_pointer, stats._stats)
1963
- end
1963
+ def stats_size(stats) #=> :uint
1964
+ Z3::VeryLowLevel.Z3_stats_size(_ctx_pointer, stats._stats)
1965
+ end
1964
1966
 
1965
- def stats_to_string(stats)
1966
- Z3::VeryLowLevel.Z3_stats_to_string(_ctx_pointer, stats._stats)
1967
- end
1967
+ def stats_to_string(stats) #=> :string
1968
+ Z3::VeryLowLevel.Z3_stats_to_string(_ctx_pointer, stats._stats)
1969
+ end
1968
1970
 
1969
- def tactic_and_then(tactic1, tactic2)
1970
- Z3::VeryLowLevel.Z3_tactic_and_then(_ctx_pointer, tactic1._tactic, tactic2._tactic)
1971
- end
1971
+ def tactic_and_then(tactic1, tactic2) #=> :tactic_pointer
1972
+ Z3::VeryLowLevel.Z3_tactic_and_then(_ctx_pointer, tactic1._tactic, tactic2._tactic)
1973
+ end
1972
1974
 
1973
- def tactic_apply(tactic, goal)
1974
- Z3::VeryLowLevel.Z3_tactic_apply(_ctx_pointer, tactic._tactic, goal._goal)
1975
- end
1975
+ def tactic_apply(tactic, goal) #=> :apply_result_pointer
1976
+ Z3::VeryLowLevel.Z3_tactic_apply(_ctx_pointer, tactic._tactic, goal._goal)
1977
+ end
1976
1978
 
1977
- def tactic_apply_ex(tactic, goal, params)
1978
- Z3::VeryLowLevel.Z3_tactic_apply_ex(_ctx_pointer, tactic._tactic, goal._goal, params._params)
1979
- end
1979
+ def tactic_apply_ex(tactic, goal, params) #=> :apply_result_pointer
1980
+ Z3::VeryLowLevel.Z3_tactic_apply_ex(_ctx_pointer, tactic._tactic, goal._goal, params._params)
1981
+ end
1980
1982
 
1981
- def tactic_cond(probe, tactic1, tactic2)
1982
- Z3::VeryLowLevel.Z3_tactic_cond(_ctx_pointer, probe._probe, tactic1._tactic, tactic2._tactic)
1983
- end
1983
+ def tactic_cond(probe, tactic1, tactic2) #=> :tactic_pointer
1984
+ Z3::VeryLowLevel.Z3_tactic_cond(_ctx_pointer, probe._probe, tactic1._tactic, tactic2._tactic)
1985
+ end
1984
1986
 
1985
- def tactic_dec_ref(tactic)
1986
- Z3::VeryLowLevel.Z3_tactic_dec_ref(_ctx_pointer, tactic._tactic)
1987
- end
1987
+ def tactic_dec_ref(tactic) #=> :void
1988
+ Z3::VeryLowLevel.Z3_tactic_dec_ref(_ctx_pointer, tactic._tactic)
1989
+ end
1988
1990
 
1989
- def tactic_fail
1990
- Z3::VeryLowLevel.Z3_tactic_fail(_ctx_pointer)
1991
- end
1991
+ def tactic_fail #=> :tactic_pointer
1992
+ Z3::VeryLowLevel.Z3_tactic_fail(_ctx_pointer)
1993
+ end
1992
1994
 
1993
- def tactic_fail_if(probe)
1994
- Z3::VeryLowLevel.Z3_tactic_fail_if(_ctx_pointer, probe._probe)
1995
- end
1995
+ def tactic_fail_if(probe) #=> :tactic_pointer
1996
+ Z3::VeryLowLevel.Z3_tactic_fail_if(_ctx_pointer, probe._probe)
1997
+ end
1996
1998
 
1997
- def tactic_fail_if_not_decided
1998
- Z3::VeryLowLevel.Z3_tactic_fail_if_not_decided(_ctx_pointer)
1999
- end
1999
+ def tactic_fail_if_not_decided #=> :tactic_pointer
2000
+ Z3::VeryLowLevel.Z3_tactic_fail_if_not_decided(_ctx_pointer)
2001
+ end
2000
2002
 
2001
- def tactic_get_descr(str)
2002
- Z3::VeryLowLevel.Z3_tactic_get_descr(_ctx_pointer, str)
2003
- end
2003
+ def tactic_get_descr(str) #=> :string
2004
+ Z3::VeryLowLevel.Z3_tactic_get_descr(_ctx_pointer, str)
2005
+ end
2004
2006
 
2005
- def tactic_get_help(tactic)
2006
- Z3::VeryLowLevel.Z3_tactic_get_help(_ctx_pointer, tactic._tactic)
2007
- end
2007
+ def tactic_get_help(tactic) #=> :string
2008
+ Z3::VeryLowLevel.Z3_tactic_get_help(_ctx_pointer, tactic._tactic)
2009
+ end
2008
2010
 
2009
- def tactic_get_param_descrs(tactic)
2010
- Z3::VeryLowLevel.Z3_tactic_get_param_descrs(_ctx_pointer, tactic._tactic)
2011
- end
2011
+ def tactic_get_param_descrs(tactic) #=> :param_descrs_pointer
2012
+ Z3::VeryLowLevel.Z3_tactic_get_param_descrs(_ctx_pointer, tactic._tactic)
2013
+ end
2012
2014
 
2013
- def tactic_inc_ref(tactic)
2014
- Z3::VeryLowLevel.Z3_tactic_inc_ref(_ctx_pointer, tactic._tactic)
2015
- end
2015
+ def tactic_inc_ref(tactic) #=> :void
2016
+ Z3::VeryLowLevel.Z3_tactic_inc_ref(_ctx_pointer, tactic._tactic)
2017
+ end
2016
2018
 
2017
- def tactic_or_else(tactic1, tactic2)
2018
- Z3::VeryLowLevel.Z3_tactic_or_else(_ctx_pointer, tactic1._tactic, tactic2._tactic)
2019
- end
2019
+ def tactic_or_else(tactic1, tactic2) #=> :tactic_pointer
2020
+ Z3::VeryLowLevel.Z3_tactic_or_else(_ctx_pointer, tactic1._tactic, tactic2._tactic)
2021
+ end
2020
2022
 
2021
- def tactic_par_and_then(tactic1, tactic2)
2022
- Z3::VeryLowLevel.Z3_tactic_par_and_then(_ctx_pointer, tactic1._tactic, tactic2._tactic)
2023
- end
2023
+ def tactic_par_and_then(tactic1, tactic2) #=> :tactic_pointer
2024
+ Z3::VeryLowLevel.Z3_tactic_par_and_then(_ctx_pointer, tactic1._tactic, tactic2._tactic)
2025
+ end
2024
2026
 
2025
- def tactic_repeat(tactic, num)
2026
- Z3::VeryLowLevel.Z3_tactic_repeat(_ctx_pointer, tactic._tactic, num)
2027
- end
2027
+ def tactic_repeat(tactic, num) #=> :tactic_pointer
2028
+ Z3::VeryLowLevel.Z3_tactic_repeat(_ctx_pointer, tactic._tactic, num)
2029
+ end
2028
2030
 
2029
- def tactic_skip
2030
- Z3::VeryLowLevel.Z3_tactic_skip(_ctx_pointer)
2031
- end
2031
+ def tactic_skip #=> :tactic_pointer
2032
+ Z3::VeryLowLevel.Z3_tactic_skip(_ctx_pointer)
2033
+ end
2032
2034
 
2033
- def tactic_try_for(tactic, num)
2034
- Z3::VeryLowLevel.Z3_tactic_try_for(_ctx_pointer, tactic._tactic, num)
2035
- end
2035
+ def tactic_try_for(tactic, num) #=> :tactic_pointer
2036
+ Z3::VeryLowLevel.Z3_tactic_try_for(_ctx_pointer, tactic._tactic, num)
2037
+ end
2036
2038
 
2037
- def tactic_using_params(tactic, params)
2038
- Z3::VeryLowLevel.Z3_tactic_using_params(_ctx_pointer, tactic._tactic, params._params)
2039
- end
2039
+ def tactic_using_params(tactic, params) #=> :tactic_pointer
2040
+ Z3::VeryLowLevel.Z3_tactic_using_params(_ctx_pointer, tactic._tactic, params._params)
2041
+ end
2040
2042
 
2041
- def tactic_when(probe, tactic)
2042
- Z3::VeryLowLevel.Z3_tactic_when(_ctx_pointer, probe._probe, tactic._tactic)
2043
- end
2043
+ def tactic_when(probe, tactic) #=> :tactic_pointer
2044
+ Z3::VeryLowLevel.Z3_tactic_when(_ctx_pointer, probe._probe, tactic._tactic)
2045
+ end
2044
2046
 
2045
- def to_app(ast)
2046
- Z3::VeryLowLevel.Z3_to_app(_ctx_pointer, ast._ast)
2047
- end
2047
+ def to_app(ast) #=> :app_pointer
2048
+ Z3::VeryLowLevel.Z3_to_app(_ctx_pointer, ast._ast)
2049
+ end
2048
2050
 
2049
- def to_func_decl(ast)
2050
- Z3::VeryLowLevel.Z3_to_func_decl(_ctx_pointer, ast._ast)
2051
- end
2051
+ def to_func_decl(ast) #=> :func_decl_pointer
2052
+ Z3::VeryLowLevel.Z3_to_func_decl(_ctx_pointer, ast._ast)
2053
+ end
2052
2054
 
2053
- def toggle_warning_messages(bool)
2054
- Z3::VeryLowLevel.Z3_toggle_warning_messages(bool)
2055
- end
2055
+ def toggle_warning_messages(bool) #=> :void
2056
+ Z3::VeryLowLevel.Z3_toggle_warning_messages(bool)
2057
+ end
2056
2058
 
2057
- def translate(ast, context)
2058
- Z3::VeryLowLevel.Z3_translate(_ctx_pointer, ast._ast, context._context)
2059
- end
2059
+ def translate(ast, context) #=> :ast_pointer
2060
+ Z3::VeryLowLevel.Z3_translate(_ctx_pointer, ast._ast, context._context)
2061
+ end
2060
2062
 
2061
- def update_param_value(str1, str2)
2062
- Z3::VeryLowLevel.Z3_update_param_value(_ctx_pointer, str1, str2)
2063
+ def update_param_value(str1, str2) #=> :void
2064
+ Z3::VeryLowLevel.Z3_update_param_value(_ctx_pointer, str1, str2)
2065
+ end
2066
+ end
2063
2067
  end