Skip to main content

rustjava_runtime/classes/java/lang/
math.rs

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
9// public final class java.lang.Math
10pub 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}