1use alloc::vec;
2
3use jvm::{ClassInstanceRef, Jvm, Result};
4use jvm_class_proto::{JavaFieldProto, JavaMethodProto};
5use jvm_types::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
6
7use crate::{RuntimeClassProto, RuntimeContext, classes::java::util::Random};
8
9pub struct Math;
11
12impl Math {
13 pub fn as_proto() -> RuntimeClassProto {
14 RuntimeClassProto {
15 name: "java/lang/Math",
16 parent_class: Some("java/lang/Object"),
17 interfaces: vec![],
18 methods: vec![
19 JavaMethodProto::new("<clinit>", "()V", Self::clinit, MethodAccessFlags::STATIC),
20 JavaMethodProto::new("abs", "(I)I", Self::abs, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
21 JavaMethodProto::new("abs", "(J)J", Self::abs_long, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
22 JavaMethodProto::new("abs", "(F)F", Self::abs_float, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
23 JavaMethodProto::new("abs", "(D)D", Self::abs_double, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
24 JavaMethodProto::new("ceil", "(D)D", Self::ceil, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
25 JavaMethodProto::new("floor", "(D)D", Self::floor, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
26 JavaMethodProto::new("sqrt", "(D)D", Self::sqrt, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
27 JavaMethodProto::new("sin", "(D)D", Self::sin, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
28 JavaMethodProto::new("cos", "(D)D", Self::cos, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
29 JavaMethodProto::new("tan", "(D)D", Self::tan, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
30 JavaMethodProto::new(
31 "toDegrees",
32 "(D)D",
33 Self::to_degrees,
34 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
35 ),
36 JavaMethodProto::new(
37 "toRadians",
38 "(D)D",
39 Self::to_radians,
40 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
41 ),
42 JavaMethodProto::new("max", "(II)I", Self::max, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
43 JavaMethodProto::new("max", "(JJ)J", Self::max_long, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
44 JavaMethodProto::new("max", "(FF)F", Self::max_float, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
45 JavaMethodProto::new("max", "(DD)D", Self::max_double, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
46 JavaMethodProto::new("min", "(II)I", Self::min, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
47 JavaMethodProto::new("min", "(JJ)J", Self::min_long, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
48 JavaMethodProto::new("min", "(FF)F", Self::min_float, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
49 JavaMethodProto::new("min", "(DD)D", Self::min_double, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
50 JavaMethodProto::new("acos", "(D)D", Self::acos, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
51 JavaMethodProto::new("asin", "(D)D", Self::asin, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
52 JavaMethodProto::new("atan", "(D)D", Self::atan, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
53 JavaMethodProto::new("atan2", "(DD)D", Self::atan2, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
54 JavaMethodProto::new("exp", "(D)D", Self::exp, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
55 JavaMethodProto::new("log", "(D)D", Self::log, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
56 JavaMethodProto::new("pow", "(DD)D", Self::pow, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
57 JavaMethodProto::new("rint", "(D)D", Self::rint, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
58 JavaMethodProto::new(
59 "IEEEremainder",
60 "(DD)D",
61 Self::ieee_remainder,
62 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC,
63 ),
64 JavaMethodProto::new("round", "(F)I", Self::round_float, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
65 JavaMethodProto::new("round", "(D)J", Self::round_double, MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC),
66 JavaMethodProto::new(
67 "random",
68 "()D",
69 Self::random,
70 MethodAccessFlags::PUBLIC | MethodAccessFlags::STATIC | MethodAccessFlags::SYNCHRONIZED,
71 ),
72 ],
73 fields: vec![
74 JavaFieldProto::new("E", "D", FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL),
75 JavaFieldProto::new("PI", "D", FieldAccessFlags::PUBLIC | FieldAccessFlags::STATIC | FieldAccessFlags::FINAL),
76 JavaFieldProto::new(
77 "randomNumberGenerator",
78 "Ljava/util/Random;",
79 FieldAccessFlags::PRIVATE | FieldAccessFlags::STATIC,
80 ),
81 ],
82 access_flags: ClassAccessFlags::PUBLIC | ClassAccessFlags::FINAL,
83 }
84 }
85
86 async fn clinit(jvm: &Jvm, _: &mut RuntimeContext) -> Result<()> {
87 jvm.put_static_field("java/lang/Math", "E", "D", core::f64::consts::E).await?;
88 jvm.put_static_field("java/lang/Math", "PI", "D", core::f64::consts::PI).await
89 }
90
91 async fn abs(_: &Jvm, _: &mut RuntimeContext, x: i32) -> Result<i32> {
92 tracing::debug!("java.lang.Math::abs({x:?})");
93 Ok(x.wrapping_abs())
94 }
95
96 async fn abs_long(_: &Jvm, _: &mut RuntimeContext, x: i64) -> Result<i64> {
97 tracing::debug!("java.lang.Math::abs({x:?})");
98 Ok(x.wrapping_abs())
99 }
100
101 async fn abs_float(_: &Jvm, _: &mut RuntimeContext, x: f32) -> Result<f32> {
102 tracing::debug!("java.lang.Math::abs({x:?})");
103 Ok(libm::fabsf(x))
104 }
105
106 async fn abs_double(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
107 tracing::debug!("java.lang.Math::abs({x:?})");
108 Ok(libm::fabs(x))
109 }
110
111 async fn ceil(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
112 tracing::debug!("java.lang.Math::ceil({x:?})");
113 Ok(libm::ceil(x))
114 }
115
116 async fn floor(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
117 tracing::debug!("java.lang.Math::floor({x:?})");
118 Ok(libm::floor(x))
119 }
120
121 async fn sqrt(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
122 tracing::debug!("java.lang.Math::sqrt({x:?})");
123 Ok(libm::sqrt(x))
124 }
125
126 async fn sin(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
127 tracing::debug!("java.lang.Math::sin({x:?})");
128 Ok(libm::sin(x))
129 }
130
131 async fn cos(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
132 tracing::debug!("java.lang.Math::cos({x:?})");
133 Ok(libm::cos(x))
134 }
135
136 async fn tan(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
137 tracing::debug!("java.lang.Math::tan({x:?})");
138 Ok(libm::tan(x))
139 }
140
141 async fn to_degrees(_: &Jvm, _: &mut RuntimeContext, radians: f64) -> Result<f64> {
142 tracing::debug!("java.lang.Math::toDegrees({radians:?})");
143 Ok(radians * 180.0 / core::f64::consts::PI)
144 }
145
146 async fn to_radians(_: &Jvm, _: &mut RuntimeContext, degrees: f64) -> Result<f64> {
147 tracing::debug!("java.lang.Math::toRadians({degrees:?})");
148 Ok(degrees / 180.0 * core::f64::consts::PI)
149 }
150
151 async fn max(_: &Jvm, _: &mut RuntimeContext, x: i32, y: i32) -> Result<i32> {
152 tracing::debug!("java.lang.Math::max({x:?}, {y:?})");
153 Ok(x.max(y))
154 }
155
156 async fn max_long(_: &Jvm, _: &mut RuntimeContext, x: i64, y: i64) -> Result<i64> {
157 tracing::debug!("java.lang.Math::max({x:?}, {y:?})");
158 Ok(x.max(y))
159 }
160
161 async fn max_float(_: &Jvm, _: &mut RuntimeContext, x: f32, y: f32) -> Result<f32> {
162 tracing::debug!("java.lang.Math::max({x:?}, {y:?})");
163
164 if x.is_nan() {
165 return Ok(x);
166 }
167 if y.is_nan() {
168 return Ok(y);
169 }
170 if x == 0.0 && y == 0.0 {
171 return Ok(if x.is_sign_positive() || y.is_sign_positive() { 0.0 } else { -0.0 });
172 }
173 Ok(if x >= y { x } else { y })
174 }
175
176 async fn max_double(_: &Jvm, _: &mut RuntimeContext, x: f64, y: f64) -> Result<f64> {
177 tracing::debug!("java.lang.Math::max({x:?}, {y:?})");
178
179 if x.is_nan() {
180 return Ok(x);
181 }
182 if y.is_nan() {
183 return Ok(y);
184 }
185 if x == 0.0 && y == 0.0 {
186 return Ok(if x.is_sign_positive() || y.is_sign_positive() { 0.0 } else { -0.0 });
187 }
188 Ok(if x >= y { x } else { y })
189 }
190
191 async fn min(_: &Jvm, _: &mut RuntimeContext, x: i32, y: i32) -> Result<i32> {
192 tracing::debug!("java.lang.Math::min({x:?}, {y:?})");
193 Ok(x.min(y))
194 }
195
196 async fn min_long(_: &Jvm, _: &mut RuntimeContext, x: i64, y: i64) -> Result<i64> {
197 tracing::debug!("java.lang.Math::min({x:?}, {y:?})");
198 Ok(x.min(y))
199 }
200
201 async fn min_float(_: &Jvm, _: &mut RuntimeContext, x: f32, y: f32) -> Result<f32> {
202 tracing::debug!("java.lang.Math::min({x:?}, {y:?})");
203
204 if x.is_nan() {
205 return Ok(x);
206 }
207 if y.is_nan() {
208 return Ok(y);
209 }
210 if x == 0.0 && y == 0.0 {
211 return Ok(if x.is_sign_negative() || y.is_sign_negative() { -0.0 } else { 0.0 });
212 }
213 Ok(if x <= y { x } else { y })
214 }
215
216 async fn min_double(_: &Jvm, _: &mut RuntimeContext, x: f64, y: f64) -> Result<f64> {
217 tracing::debug!("java.lang.Math::min({x:?}, {y:?})");
218
219 if x.is_nan() {
220 return Ok(x);
221 }
222 if y.is_nan() {
223 return Ok(y);
224 }
225 if x == 0.0 && y == 0.0 {
226 return Ok(if x.is_sign_negative() || y.is_sign_negative() { -0.0 } else { 0.0 });
227 }
228 Ok(if x <= y { x } else { y })
229 }
230
231 async fn acos(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
232 tracing::debug!("java.lang.Math::acos({x:?})");
233 Ok(libm::acos(x))
234 }
235
236 async fn asin(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
237 tracing::debug!("java.lang.Math::asin({x:?})");
238 Ok(libm::asin(x))
239 }
240
241 async fn atan(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
242 tracing::debug!("java.lang.Math::atan({x:?})");
243 Ok(libm::atan(x))
244 }
245
246 async fn atan2(_: &Jvm, _: &mut RuntimeContext, y: f64, x: f64) -> Result<f64> {
247 tracing::debug!("java.lang.Math::atan2({y:?}, {x:?})");
248 Ok(libm::atan2(y, x))
249 }
250
251 async fn exp(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
252 tracing::debug!("java.lang.Math::exp({x:?})");
253 Ok(libm::exp(x))
254 }
255
256 async fn log(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
257 tracing::debug!("java.lang.Math::log({x:?})");
258 Ok(libm::log(x))
259 }
260
261 async fn pow(_: &Jvm, _: &mut RuntimeContext, x: f64, y: f64) -> Result<f64> {
262 tracing::debug!("java.lang.Math::pow({x:?}, {y:?})");
263
264 if y == 0.0 {
265 return Ok(1.0);
266 }
267 if y.is_nan() {
268 return Ok(f64::NAN);
269 }
270 if (x == 1.0 || x == -1.0) && y.is_infinite() {
271 return Ok(f64::NAN);
272 }
273 Ok(libm::pow(x, y))
274 }
275
276 async fn rint(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<f64> {
277 tracing::debug!("java.lang.Math::rint({x:?})");
278 Ok(libm::rint(x))
279 }
280
281 async fn ieee_remainder(_: &Jvm, _: &mut RuntimeContext, x: f64, y: f64) -> Result<f64> {
282 tracing::debug!("java.lang.Math::IEEEremainder({x:?}, {y:?})");
283 Ok(libm::remainder(x, y))
284 }
285
286 async fn round_float(_: &Jvm, _: &mut RuntimeContext, x: f32) -> Result<i32> {
287 tracing::debug!("java.lang.Math::round({x:?})");
288
289 if x.is_nan() {
290 return Ok(0);
291 }
292 if x >= i32::MAX as f32 {
293 return Ok(i32::MAX);
294 }
295 if x <= i32::MIN as f32 {
296 return Ok(i32::MIN);
297 }
298 Ok(libm::floorf(x + 0.5) as i32)
299 }
300
301 async fn round_double(_: &Jvm, _: &mut RuntimeContext, x: f64) -> Result<i64> {
302 tracing::debug!("java.lang.Math::round({x:?})");
303
304 if x.is_nan() {
305 return Ok(0);
306 }
307 if x >= i64::MAX as f64 {
308 return Ok(i64::MAX);
309 }
310 if x <= i64::MIN as f64 {
311 return Ok(i64::MIN);
312 }
313 Ok(libm::floor(x + 0.5) as i64)
314 }
315
316 async fn random(jvm: &Jvm, _: &mut RuntimeContext) -> Result<f64> {
317 tracing::debug!("java.lang.Math::random()");
318
319 let mut random: ClassInstanceRef<Random> = jvm
320 .get_static_field("java/lang/Math", "randomNumberGenerator", "Ljava/util/Random;")
321 .await?;
322 if random.is_null() {
323 random = jvm.new_class("java/util/Random", "()V", ()).await?.into();
324 jvm.put_static_field("java/lang/Math", "randomNumberGenerator", "Ljava/util/Random;", random.clone())
325 .await?;
326 }
327 jvm.invoke_virtual(&random, "java/util/Random", "nextDouble", "()D", ()).await
328 }
329}