vox_geometry_rust/isize2.rs
1/*
2 * // Copyright (c) 2021 Feng Yang
3 * //
4 * // I am making my contributions/submissions to this project solely in my
5 * // personal capacity and am not conveying any rights to any intellectual
6 * // property of any third parties.
7 */
8
9use std::ops::{Index, IndexMut, AddAssign, SubAssign, MulAssign, DivAssign, Add, Sub, Mul, Div};
10use std::fmt::{Debug, Formatter, Result};
11
12///
13/// # 2-D size class.
14///
15/// This class defines simple 2-D size data.
16///
17/// - tparam T - Type of the element
18///
19pub struct ISize2 {
20 /// X (or the first) component of the size.
21 pub x: isize,
22
23 /// Y (or the second) component of the size.
24 pub y: isize,
25}
26
27/// # Constructors
28impl ISize2 {
29 /// Constructs default size (0, 0).
30 /// ```
31 /// use vox_geometry_rust::isize2::ISize2;
32 /// let vec = ISize2::new_default();
33 /// assert_eq!(0, vec.x);
34 /// assert_eq!(0, vec.y);
35 /// ```
36 pub fn new_default() -> ISize2 {
37 return ISize2 {
38 x: 0,
39 y: 0,
40 };
41 }
42
43 /// Constructs size with given parameters \p x_ and \p y_.
44 /// ```
45 /// use vox_geometry_rust::isize2::ISize2;
46 /// let vec2 = ISize2::new(5, 3);
47 /// assert_eq!(5, vec2.x);
48 /// assert_eq!(3, vec2.y);
49 /// ```
50 pub fn new(x_: isize, y_: isize) -> ISize2 {
51 return ISize2 {
52 x: x_,
53 y: y_,
54 };
55 }
56
57 /// Constructs size with initializer list.
58 /// ```
59 /// use vox_geometry_rust::isize2::ISize2;
60 /// let vec5 = ISize2::new_lst([7, 6]);
61 /// assert_eq!(7, vec5.x);
62 /// assert_eq!(6, vec5.y);
63 /// ```
64 pub fn new_lst(lst: [isize; 2]) -> ISize2 {
65 return ISize2 {
66 x: lst[0],
67 y: lst[1],
68 };
69 }
70}
71
72/// # Basic setters
73impl ISize2 {
74 /// Set both x and y components to **s**.
75 pub fn set_scalar(&mut self, s: isize) {
76 self.x = s;
77 self.y = s;
78 }
79
80 /// Set x and y components with given parameters.
81 /// ```
82 /// use vox_geometry_rust::isize2::ISize2;
83 /// let mut vec = ISize2::new_default();
84 /// vec.set_scalar2(4, 2);
85 /// assert_eq!(4, vec.x);
86 /// assert_eq!(2, vec.y);
87 /// ```
88 pub fn set_scalar2(&mut self, x: isize, y: isize) {
89 self.x = x;
90 self.y = y;
91 }
92
93 /// Set x and y components with given initializer list.
94 /// ```
95 /// use vox_geometry_rust::isize2::ISize2;
96 /// let mut vec = ISize2::new_default();
97 /// let lst = [0, 5];
98 /// vec.set_lst(lst);
99 /// assert_eq!(0, vec.x);
100 /// assert_eq!(5, vec.y);
101 /// ```
102 pub fn set_lst(&mut self, lst: [isize; 2]) {
103 self.x = lst[0];
104 self.y = lst[1];
105 }
106
107 /// Set x and y with other size **pt**.
108 /// ```
109 /// use vox_geometry_rust::isize2::ISize2;
110 /// let mut vec = ISize2::new_default();
111 /// vec.set_self(ISize2::new(9, 8));
112 /// assert_eq!(9, vec.x);
113 /// assert_eq!(8, vec.y);
114 /// ```
115 pub fn set_self(&mut self, pt: ISize2) {
116 self.x = pt.x;
117 self.y = pt.y;
118 }
119
120 /// Set both x and y to zero.
121 /// ```
122 /// use vox_geometry_rust::isize2::ISize2;
123 /// let mut vec = ISize2::new(3, 9);
124 /// vec.set_zero();
125 /// assert_eq!(0, vec.x);
126 /// assert_eq!(0, vec.y);
127 /// ```
128 pub fn set_zero(&mut self) {
129 self.x = 0;
130 self.y = 0;
131 }
132}
133
134/// # Binary operations: new instance = this (+) v
135impl ISize2 {
136 /// Computes self + (v, v).
137 /// ```
138 /// use vox_geometry_rust::isize2::ISize2;
139 /// let mut vec = ISize2::new(3, 9);
140 /// vec = vec.add_scalar(4);
141 /// assert_eq!(7, vec.x);
142 /// assert_eq!(13, vec.y);
143 /// ```
144 pub fn add_scalar(&self, v: isize) -> ISize2 {
145 return ISize2::new(self.x + v, self.y + v);
146 }
147
148 /// Computes self + (v.x, v.y).
149 /// ```
150 /// use vox_geometry_rust::isize2::ISize2;
151 /// let mut vec = ISize2::new(3, 9);
152 /// vec = vec.add_scalar(4);
153 /// vec = vec.add_vec(ISize2::new(2, 1));
154 /// assert_eq!(9, vec.x);
155 /// assert_eq!(14, vec.y);
156 /// ```
157 pub fn add_vec(&self, v: ISize2) -> ISize2 {
158 return ISize2::new(self.x + v.x, self.y + v.y);
159 }
160
161 /// Computes self - (v, v).
162 /// ```
163 /// use vox_geometry_rust::isize2::ISize2;
164 /// let mut vec = ISize2::new(3, 9);
165 /// vec = vec.add_scalar(4);
166 /// vec = vec.add_vec(ISize2::new(2, 1));
167 /// vec = vec.sub_scalar(8);
168 /// assert_eq!(1, vec.x);
169 /// assert_eq!(6, vec.y);
170 /// ```
171 pub fn sub_scalar(&self, v: isize) -> ISize2 {
172 return ISize2::new(self.x - v, self.y - v);
173 }
174
175 /// Computes self - (v.x, v.y).
176 /// ```
177 /// use vox_geometry_rust::isize2::ISize2;
178 /// let mut vec = ISize2::new(3, 9);
179 /// vec = vec.add_scalar(4);
180 /// vec = vec.add_vec(ISize2::new(2, 1));
181 /// vec = vec.sub_scalar(8);
182 /// vec = vec.sub_vec(ISize2::new(1, 3));
183 /// assert_eq!(0, vec.x);
184 /// assert_eq!(3, vec.y);
185 /// ```
186 pub fn sub_vec(&self, v: ISize2) -> ISize2 {
187 return ISize2::new(self.x - v.x, self.y - v.y);
188 }
189
190 /// Computes self * (v, v).
191 /// ```
192 /// use vox_geometry_rust::isize2::ISize2;
193 /// let mut vec = ISize2::new(3, 9);
194 /// vec = vec.add_scalar(4);
195 /// vec = vec.add_vec(ISize2::new(2, 1));
196 /// vec = vec.sub_scalar(8);
197 /// vec = vec.sub_vec(ISize2::new(1, 3));
198 /// vec = vec.mul_scalar(2);
199 /// assert_eq!(0, vec.x);
200 /// assert_eq!(6, vec.y);
201 /// ```
202 pub fn mul_scalar(&self, v: isize) -> ISize2 {
203 return ISize2::new(self.x * v, self.y * v);
204 }
205
206 /// Computes self * (v.x, v.y).
207 /// ```
208 /// use vox_geometry_rust::isize2::ISize2;
209 /// let mut vec = ISize2::new(3, 9);
210 /// vec = vec.add_scalar(4);
211 /// vec = vec.add_vec(ISize2::new(2, 1));
212 /// vec = vec.sub_scalar(8);
213 /// vec = vec.sub_vec(ISize2::new(1, 3));
214 /// vec = vec.mul_scalar(2);
215 /// vec = vec.mul_vec(ISize2::new(3, 2));
216 /// assert_eq!(0, vec.x);
217 /// assert_eq!(12, vec.y);
218 /// ```
219 pub fn mul_vec(&self, v: ISize2) -> ISize2 {
220 return ISize2::new(self.x * v.x, self.y * v.y);
221 }
222
223 /// Computes self / (v, v).
224 /// ```
225 /// use vox_geometry_rust::isize2::ISize2;
226 /// let mut vec = ISize2::new(3, 9);
227 /// vec = vec.add_scalar(4);
228 /// vec = vec.add_vec(ISize2::new(2, 1));
229 /// vec = vec.sub_scalar(8);
230 /// vec = vec.sub_vec(ISize2::new(1, 3));
231 /// vec = vec.mul_scalar(2);
232 /// vec = vec.mul_vec(ISize2::new(3, 2));
233 /// vec = vec.div_scalar(4);
234 /// assert_eq!(0, vec.x);
235 /// assert_eq!(3, vec.y);
236 /// ```
237 pub fn div_scalar(&self, v: isize) -> ISize2 {
238 return ISize2::new(self.x / v, self.y / v);
239 }
240
241 /// Computes self / (v.x, v.y).
242 /// ```
243 /// use vox_geometry_rust::isize2::ISize2;
244 /// let mut vec = ISize2::new(3, 9);
245 /// vec = vec.add_scalar(4);
246 /// vec = vec.add_vec(ISize2::new(2, 1));
247 /// vec = vec.sub_scalar(8);
248 /// vec = vec.sub_vec(ISize2::new(1, 3));
249 /// vec = vec.mul_scalar(2);
250 /// vec = vec.mul_vec(ISize2::new(3, 2));
251 /// vec = vec.div_scalar(4);
252 /// vec = vec.div_vec(ISize2::new(3, 1));
253 /// assert_eq!(0, vec.x);
254 /// assert_eq!(3, vec.y);
255 /// ```
256 pub fn div_vec(&self, v: ISize2) -> ISize2 {
257 return ISize2::new(self.x / v.x, self.y / v.y);
258 }
259}
260
261/// # Binary operations: new instance = v (+) this
262impl ISize2 {
263 /// Computes (v, v) - self.
264 /// ```
265 /// use vox_geometry_rust::isize2::ISize2;
266 /// let mut vec = ISize2::new(3, 9);
267 /// vec = vec.rsub_scalar(9);
268 /// assert_eq!(6, vec.x);
269 /// assert_eq!(0, vec.y);
270 /// ```
271 pub fn rsub_scalar(&self, v: isize) -> ISize2 {
272 return ISize2::new(v - self.x, v - self.y);
273 }
274
275 /// Computes (v.x, v.y) - self.
276 /// ```
277 /// use vox_geometry_rust::isize2::ISize2;
278 /// let mut vec = ISize2::new(3, 9);
279 /// vec = vec.rsub_scalar(9);
280 /// vec = vec.rsub_vec(ISize2::new(6, 3));
281 /// assert_eq!(0, vec.x);
282 /// assert_eq!(3, vec.y);
283 /// ```
284 pub fn rsub_vec(&self, v: ISize2) -> ISize2 {
285 return ISize2::new(v.x - self.x, v.y - self.y);
286 }
287
288 /// Computes (v, v) / self.
289 /// ```
290 /// use vox_geometry_rust::isize2::ISize2;
291 /// let mut vec = ISize2::new(4, 3);
292 /// vec = vec.rdiv_scalar(12);
293 /// assert_eq!(3, vec.x);
294 /// assert_eq!(vec.y, 4);
295 /// ```
296 pub fn rdiv_scalar(&self, v: isize) -> ISize2 {
297 return ISize2::new(v / self.x, v / self.y);
298 }
299
300 /// Computes (v.x, v.y) / self.
301 /// ```
302 /// use vox_geometry_rust::isize2::ISize2;
303 /// let mut vec = ISize2::new(4, 3);
304 /// vec = vec.rdiv_scalar(12);
305 /// vec = vec.rdiv_vec(ISize2::new(3, 16));
306 /// assert_eq!(1, vec.x);
307 /// assert_eq!(4, vec.y);
308 /// ```
309 pub fn rdiv_vec(&self, v: ISize2) -> ISize2 {
310 return ISize2::new(v.x / self.x, v.y / self.y);
311 }
312}
313
314/// # Augmented operations: isizehis (+)= v
315impl ISize2 {
316 /// Computes self += (v, v).
317 /// ```
318 /// use vox_geometry_rust::isize2::ISize2;
319 /// let mut vec = ISize2::new(3, 9);
320 /// vec.iadd_scalar(4);
321 /// assert_eq!(7, vec.x);
322 /// assert_eq!(vec.y, 13);
323 /// ```
324 pub fn iadd_scalar(&mut self, v: isize) {
325 self.x = isize::add(self.x, v);
326 self.y = isize::add(self.y, v);
327 }
328
329 /// Computes self += (v.x, v.y).
330 /// ```
331 /// use vox_geometry_rust::isize2::ISize2;
332 /// let mut vec = ISize2::new(3, 9);
333 /// vec.iadd_scalar(4);
334 /// vec.iadd_vec(ISize2::new(2, 1));
335 /// assert_eq!(9, vec.x);
336 /// assert_eq!(vec.y, 14);
337 /// ```
338 pub fn iadd_vec(&mut self, v: ISize2) {
339 self.x = isize::add(self.x, v.x);
340 self.y = isize::add(self.y, v.y);
341 }
342
343 /// Computes self -= (v, v).
344 /// ```
345 /// use vox_geometry_rust::isize2::ISize2;
346 /// let mut vec = ISize2::new(3, 9);
347 /// vec.iadd_scalar(4);
348 /// vec.iadd_vec(ISize2::new(2, 1));
349 /// vec.isub_scalar(8);
350 /// assert_eq!(1, vec.x);
351 /// assert_eq!(6, vec.y);
352 /// ```
353 pub fn isub_scalar(&mut self, v: isize) {
354 self.x = isize::sub(self.x, v);
355 self.y = isize::sub(self.y, v);
356 }
357
358 /// Computes self -= (v.x, v.y).
359 /// ```
360 /// use vox_geometry_rust::isize2::ISize2;
361 /// let mut vec = ISize2::new(3, 9);
362 /// vec.iadd_scalar(4);
363 /// vec.iadd_vec(ISize2::new(2, 1));
364 /// vec.isub_scalar(8);
365 /// vec.isub_vec(ISize2::new(1, 3));
366 /// assert_eq!(0, vec.x);
367 /// assert_eq!(3, vec.y);
368 /// ```
369 pub fn isub_vec(&mut self, v: ISize2) {
370 self.x = isize::sub(self.x, v.x);
371 self.y = isize::sub(self.y, v.y);
372 }
373
374 /// Computes self *= (v, v).
375 /// ```
376 /// use vox_geometry_rust::isize2::ISize2;
377 /// let mut vec = ISize2::new(3, 9);
378 /// vec.iadd_scalar(4);
379 /// vec.iadd_vec(ISize2::new(2, 1));
380 /// vec.isub_scalar(8);
381 /// vec.isub_vec(ISize2::new(1, 3));
382 /// vec.imul_scalar(2);
383 /// assert_eq!(0, vec.x);
384 /// assert_eq!(6, vec.y);
385 /// ```
386 pub fn imul_scalar(&mut self, v: isize) {
387 self.x = isize::mul(self.x, v);
388 self.y = isize::mul(self.y, v);
389 }
390
391 /// Computes self *= (v.x, v.y).
392 /// ```
393 /// use vox_geometry_rust::isize2::ISize2;
394 /// let mut vec = ISize2::new(3, 9);
395 /// vec.iadd_scalar(4);
396 /// vec.iadd_vec(ISize2::new(2, 1));
397 /// vec.isub_scalar(8);
398 /// vec.isub_vec(ISize2::new(1, 3));
399 /// vec.imul_scalar(2);
400 /// vec.imul_vec(ISize2::new(3, 2));
401 /// assert_eq!(0, vec.x);
402 /// assert_eq!(12, vec.y);
403 /// ```
404 pub fn imul_vec(&mut self, v: ISize2) {
405 self.x = isize::mul(self.x, v.x);
406 self.y = isize::mul(self.y, v.y);
407 }
408
409 /// Computes self /= (v, v).
410 /// ```
411 /// use vox_geometry_rust::isize2::ISize2;
412 /// let mut vec = ISize2::new(3, 9);
413 /// vec.iadd_scalar(4);
414 /// vec.iadd_vec(ISize2::new(2, 1));
415 /// vec.isub_scalar(8);
416 /// vec.isub_vec(ISize2::new(1, 3));
417 /// vec.imul_scalar(2);
418 /// vec.imul_vec(ISize2::new(3, 2));
419 /// vec.idiv_scalar(4);
420 /// assert_eq!(0, vec.x);
421 /// assert_eq!(3, vec.y);
422 /// ```
423 pub fn idiv_scalar(&mut self, v: isize) {
424 self.x = isize::div(self.x, v);
425 self.y = isize::div(self.y, v);
426 }
427
428 /// Computes self /= (v.x, v.y).
429 /// ```
430 /// use vox_geometry_rust::isize2::ISize2;
431 /// let mut vec = ISize2::new(3, 9);
432 /// vec.iadd_scalar(4);
433 /// vec.iadd_vec(ISize2::new(2, 1));
434 /// vec.isub_scalar(8);
435 /// vec.isub_vec(ISize2::new(1, 3));
436 /// vec.imul_scalar(2);
437 /// vec.imul_vec(ISize2::new(3, 2));
438 /// vec.idiv_scalar(4);
439 /// vec.idiv_vec(ISize2::new(3, 1));
440 /// assert_eq!(0, vec.x);
441 /// assert_eq!(3, vec.y);
442 /// ```
443 pub fn idiv_vec(&mut self, v: ISize2) {
444 self.x = isize::div(self.x, v.x);
445 self.y = isize::div(self.y, v.y);
446 }
447}
448
449/// # Basic getters
450impl ISize2 {
451 /// Returns const reference to the **i** -th element of the size.
452 /// ```
453 /// use vox_geometry_rust::isize2::ISize2;
454 /// let vec = ISize2::new(8, 9);
455 /// assert_eq!(*vec.at(0), 8);
456 /// assert_eq!(*vec.at(1), 9);
457 /// ```
458 pub fn at(&self, i: isize) -> &isize {
459 match i {
460 0 => return &self.x,
461 1 => return &self.y,
462 _ => { panic!() }
463 }
464 }
465
466 /// Returns reference to the **i** -th element of the size.
467 /// ```
468 /// use vox_geometry_rust::isize2::ISize2;
469 /// let mut a = ISize2::new_default();
470 /// *a.at_mut(0) = 10;
471 /// *a.at_mut(1) = 20;
472 /// assert_eq!(*a.at(0), 10);
473 /// assert_eq!(*a.at(1), 20);
474 /// ```
475 pub fn at_mut(&mut self, i: isize) -> &mut isize {
476 match i {
477 0 => return &mut self.x,
478 1 => return &mut self.y,
479 _ => { panic!() }
480 }
481 }
482
483 /// Returns the sum of all the components (i.e. x + y).
484 /// ```
485 /// use vox_geometry_rust::isize2::ISize2;
486 /// let vec = ISize2::new(3, 7);
487 /// let sum = vec.sum();
488 /// assert_eq!(sum, 10);
489 /// ```
490 pub fn sum(&self) -> isize {
491 return self.x + self.y;
492 }
493
494 /// Returns the minimum value among x and y.
495 /// ```
496 /// use vox_geometry_rust::isize2::ISize2;
497 /// let vec = ISize2::new(3, 7);
498 /// let min = vec.min();
499 /// assert_eq!(min, 3);
500 /// ```
501 pub fn min(&self) -> isize {
502 return self.x.min(self.y);
503 }
504
505 /// Returns the maximum value among x and y.
506 /// ```
507 /// use vox_geometry_rust::isize2::ISize2;
508 /// let vec = ISize2::new(3, 7);
509 /// let max = vec.max();
510 /// assert_eq!(max, 7);
511 /// ```
512 pub fn max(&self) -> isize {
513 return self.x.max(self.y);
514 }
515
516 /// Returns the index of the dominant axis.
517 /// ```
518 /// use vox_geometry_rust::isize2::ISize2;
519 /// let vec = ISize2::new(3, 7);
520 /// let dominant_axis = vec.dominant_axis();
521 /// assert_eq!(dominant_axis, 1);
522 /// ```
523 pub fn dominant_axis(&self) -> isize {
524 match self.x > self.y {
525 true => 0,
526 false => 1
527 }
528 }
529
530 /// Returns the index of the subminant axis.
531 /// ```
532 /// use vox_geometry_rust::isize2::ISize2;
533 /// let vec = ISize2::new(3, 7);
534 /// let subminant_axis = vec.subminant_axis();
535 /// assert_eq!(subminant_axis, 0);
536 /// ```
537 pub fn subminant_axis(&self) -> isize {
538 match self.x < self.y {
539 true => 0,
540 false => 1
541 }
542 }
543
544 /// Returns true if **other** is the same as self size.
545 pub fn is_equal(&self, other: &ISize2) -> bool {
546 return self.x == other.x && self.y == other.y;
547 }
548}
549
550/// Copy constructor.
551/// ```
552/// use vox_geometry_rust::isize2::ISize2;
553/// let mut vec5 = ISize2::new_lst([7, 6]);
554/// let mut vec6 = vec5.clone();
555/// vec6.x = 10;
556/// assert_eq!(10, vec6.x);
557/// assert_eq!(7, vec5.x);
558/// ```
559impl Clone for ISize2 {
560 fn clone(&self) -> Self {
561 return ISize2 {
562 x: self.x,
563 y: self.y,
564 };
565 }
566}
567
568///
569/// ```
570/// use vox_geometry_rust::isize2::ISize2;
571/// let vec = ISize2::new(5, 1);
572/// let mut vec2 = ISize2::new(3, 3);
573/// vec2 = vec;
574/// assert_eq!(5, vec2.x);
575/// assert_eq!(vec2.y, 1);
576/// ```
577impl Copy for ISize2 {}
578
579/// # Operators
580/// Returns const reference to the **i** -th element of the size.
581/// ```
582/// use vox_geometry_rust::isize2::ISize2;
583/// let vec = ISize2::new(8, 9);
584/// assert_eq!(vec[0], 8);
585/// assert_eq!(vec[1], 9);
586/// ```
587impl Index<isize> for ISize2 {
588 type Output = isize;
589 fn index(&self, index: isize) -> &Self::Output {
590 return self.at(index);
591 }
592}
593
594/// Returns reference to the **i** -th element of the size.
595/// ```
596/// use vox_geometry_rust::isize2::ISize2;
597/// let mut vec = ISize2::new(8, 9);
598/// vec[0] = 7;
599/// vec[1] = 6;
600/// assert_eq!(7, vec.x);
601/// assert_eq!(6, vec.y);
602/// ```
603impl IndexMut<isize> for ISize2 {
604 fn index_mut(&mut self, index: isize) -> &mut Self::Output {
605 return self.at_mut(index);
606 }
607}
608
609/// Computes self += (v, v)
610/// ```
611/// use vox_geometry_rust::isize2::ISize2;
612/// let mut vec = ISize2::new(3, 9);
613/// vec += 4;
614/// assert_eq!(7, vec.x);
615/// assert_eq!(vec.y, 13);
616/// ```
617impl AddAssign<isize> for ISize2 {
618 fn add_assign(&mut self, rhs: isize) {
619 self.iadd_scalar(rhs);
620 }
621}
622
623/// Computes self += (v.x, v.y)
624/// ```
625/// use vox_geometry_rust::isize2::ISize2;
626/// let mut vec = ISize2::new(3, 9);
627/// vec += 4;
628/// vec += ISize2::new(2, 1);
629/// assert_eq!(9, vec.x);
630/// assert_eq!(vec.y, 14);
631/// ```
632impl AddAssign for ISize2 {
633 fn add_assign(&mut self, rhs: Self) {
634 self.iadd_vec(rhs);
635 }
636}
637
638/// Computes self -= (v, v)
639/// ```
640/// use vox_geometry_rust::isize2::ISize2;
641/// let mut vec = ISize2::new(3, 9);
642/// vec += 4;
643/// vec += ISize2::new(2, 1);
644/// vec -= 8;
645/// assert_eq!(1, vec.x);
646/// assert_eq!(6, vec.y);
647/// ```
648impl SubAssign<isize> for ISize2 {
649 fn sub_assign(&mut self, rhs: isize) {
650 self.isub_scalar(rhs);
651 }
652}
653
654/// Computes self -= (v.x, v.y)
655/// ```
656/// use vox_geometry_rust::isize2::ISize2;
657/// let mut vec = ISize2::new(3, 9);
658/// vec += 4;
659/// vec += ISize2::new(2, 1);
660/// vec -= 8;
661/// vec -= ISize2::new(1, 3);
662/// assert_eq!(0, vec.x);
663/// assert_eq!(3, vec.y);
664/// ```
665impl SubAssign for ISize2 {
666 fn sub_assign(&mut self, rhs: Self) {
667 self.isub_vec(rhs);
668 }
669}
670
671/// Computes self *= (v, v)
672/// ```
673/// use vox_geometry_rust::isize2::ISize2;
674/// let mut vec = ISize2::new(3, 9);
675/// vec += 4;
676/// vec += ISize2::new(2, 1);
677/// vec -= 8;
678/// vec -= ISize2::new(1, 3);
679/// vec *= 2;
680/// assert_eq!(0, vec.x);
681/// assert_eq!(6, vec.y);
682/// ```
683impl MulAssign<isize> for ISize2 {
684 fn mul_assign(&mut self, rhs: isize) {
685 self.imul_scalar(rhs);
686 }
687}
688
689/// Computes self *= (v.x, v.y)
690/// ```
691/// use vox_geometry_rust::isize2::ISize2;
692/// let mut vec = ISize2::new(3, 9);
693/// vec += 4;
694/// vec += ISize2::new(2, 1);
695/// vec -= 8;
696/// vec -= ISize2::new(1, 3);
697/// vec *= 2;
698/// vec *= ISize2::new(3, 2);
699/// assert_eq!(0, vec.x);
700/// assert_eq!(12, vec.y);
701/// ```
702impl MulAssign for ISize2 {
703 fn mul_assign(&mut self, rhs: Self) {
704 self.imul_vec(rhs);
705 }
706}
707
708/// Computes self /= (v, v)
709/// ```
710/// use vox_geometry_rust::isize2::ISize2;
711/// let mut vec = ISize2::new(3, 9);
712/// vec += 4;
713/// vec += ISize2::new(2, 1);
714/// vec -= 8;
715/// vec -= ISize2::new(1, 3);
716/// vec *= 2;
717/// vec *= ISize2::new(3, 2);
718/// vec /= 4;
719/// assert_eq!(0, vec.x);
720/// assert_eq!(3, vec.y);
721/// ```
722impl DivAssign<isize> for ISize2 {
723 fn div_assign(&mut self, rhs: isize) {
724 self.idiv_scalar(rhs);
725 }
726}
727
728/// Computes self /= (v.x, v.y)
729/// ```
730/// use vox_geometry_rust::isize2::ISize2;
731/// let mut vec = ISize2::new(3, 9);
732/// vec += 4;
733/// vec += ISize2::new(2, 1);
734/// vec -= 8;
735/// vec -= ISize2::new(1, 3);
736/// vec *= 2;
737/// vec *= ISize2::new(3, 2);
738/// vec /= 4;
739/// vec /= ISize2::new(3, 1);
740/// assert_eq!(0, vec.x);
741/// assert_eq!(3, vec.y);
742/// ```
743impl DivAssign for ISize2 {
744 fn div_assign(&mut self, rhs: Self) {
745 self.idiv_vec(rhs);
746 }
747}
748
749/// Returns true if **other** is the same as self size.
750/// ```
751/// use vox_geometry_rust::isize2::ISize2;
752/// let mut vec = ISize2::new_default();
753/// let vec2 = ISize2::new(3, 7);
754/// let vec3 = ISize2::new(3, 5);
755/// let vec4 = ISize2::new(5, 1);
756/// vec = vec2;
757/// assert_eq!(vec == vec2, true);
758/// assert_eq!(vec == vec3, false);
759/// assert_eq!(vec != vec2, false);
760/// assert_eq!(vec != vec3, true);
761/// assert_eq!(vec != vec4, true);
762/// ```
763impl PartialEq for ISize2 {
764 fn eq(&self, other: &Self) -> bool {
765 return self.is_equal(other);
766 }
767}
768
769impl Eq for ISize2 {}
770
771/// Computes (a, a) + (b.x, b.y).
772/// ```
773/// use vox_geometry_rust::isize2::ISize2;
774/// let mut vec = ISize2::new(3, 9);
775/// vec = vec + 4;
776/// assert_eq!(7, vec.x);
777/// assert_eq!(vec.y, 13);
778/// ```
779impl Add<isize> for ISize2 {
780 type Output = ISize2;
781 fn add(self, rhs: isize) -> Self::Output {
782 return self.add_scalar(rhs);
783 }
784}
785
786/// Computes (a.x, a.y) + (b.x, b.y).
787/// ```
788/// use vox_geometry_rust::isize2::ISize2;
789/// let mut vec = ISize2::new(3, 9);
790/// vec = vec + 4;
791/// vec = vec + ISize2::new(2, 1);
792/// assert_eq!(9, vec.x);
793/// assert_eq!(vec.y, 14);
794/// ```
795impl Add for ISize2 {
796 type Output = ISize2;
797 fn add(self, rhs: Self) -> Self::Output {
798 return self.add_vec(rhs);
799 }
800}
801
802/// Computes (a.x, a.y) - (b, b).
803/// ```
804/// use vox_geometry_rust::isize2::ISize2;
805/// let mut vec = ISize2::new(3, 9);
806/// vec = vec + 4;
807/// vec = vec + ISize2::new(2, 1);
808/// vec = vec - 8;
809/// assert_eq!(1, vec.x);
810/// assert_eq!(6, vec.y);
811/// ```
812impl Sub<isize> for ISize2 {
813 type Output = ISize2;
814 fn sub(self, rhs: isize) -> Self::Output {
815 return self.sub_scalar(rhs);
816 }
817}
818
819/// Computes (a.x, a.y) - (b.x, b.y).
820/// ```
821/// use vox_geometry_rust::isize2::ISize2;
822/// let mut vec = ISize2::new(3, 9);
823/// vec = vec + 4;
824/// vec = vec + ISize2::new(2, 1);
825/// vec = vec - 8;
826/// vec = vec - ISize2::new(1, 3);
827/// assert_eq!(0, vec.x);
828/// assert_eq!(3, vec.y);
829/// ```
830impl Sub for ISize2 {
831 type Output = ISize2;
832 fn sub(self, rhs: Self) -> Self::Output {
833 return self.sub_vec(rhs);
834 }
835}
836
837/// Computes (a.x, a.y) * (b, b).
838/// ```
839/// use vox_geometry_rust::isize2::ISize2;
840/// let mut vec = ISize2::new(3, 9);
841/// vec = vec + 4;
842/// vec = vec + ISize2::new(2, 1);
843/// vec = vec - 8;
844/// vec = vec - ISize2::new(1, 3);
845/// vec = vec * 2;
846/// assert_eq!(0, vec.x);
847/// assert_eq!(6, vec.y);
848/// ```
849impl Mul<isize> for ISize2 {
850 type Output = ISize2;
851 fn mul(self, rhs: isize) -> Self::Output {
852 return self.mul_scalar(rhs);
853 }
854}
855
856/// Computes (a.x, a.y) * (b.x, b.y).
857/// ```
858/// use vox_geometry_rust::isize2::ISize2;
859/// let mut vec = ISize2::new(3, 9);
860/// vec = vec + 4;
861/// vec = vec + ISize2::new(2, 1);
862/// vec = vec - 8;
863/// vec = vec - ISize2::new(1, 3);
864/// vec = vec * 2;
865/// vec = vec * ISize2::new(3, 2);
866/// assert_eq!(0, vec.x);
867/// assert_eq!(12, vec.y);
868/// ```
869impl Mul for ISize2 {
870 type Output = ISize2;
871 fn mul(self, rhs: Self) -> Self::Output {
872 return self.mul_vec(rhs);
873 }
874}
875
876/// Computes (a.x, a.y) / (b, b).
877/// ```
878/// use vox_geometry_rust::isize2::ISize2;
879/// let mut vec = ISize2::new(3, 9);
880/// vec = vec + 4;
881/// vec = vec + ISize2::new(2, 1);
882/// vec = vec - 8;
883/// vec = vec - ISize2::new(1, 3);
884/// vec = vec * 2;
885/// vec = vec * ISize2::new(3, 2);
886/// vec = vec / 4;
887/// assert_eq!(0, vec.x);
888/// assert_eq!(3, vec.y);
889/// ```
890impl Div<isize> for ISize2 {
891 type Output = ISize2;
892 fn div(self, rhs: isize) -> Self::Output {
893 return self.div_scalar(rhs);
894 }
895}
896
897/// Computes (a.x, a.y) / (b.x, b.y).
898/// ```
899/// use vox_geometry_rust::isize2::ISize2;
900/// let mut vec = ISize2::new(3, 9);
901/// vec = vec + 4;
902/// vec = vec + ISize2::new(2, 1);
903/// vec = vec - 8;
904/// vec = vec - ISize2::new(1, 3);
905/// vec = vec * 2;
906/// vec = vec * ISize2::new(3, 2);
907/// vec = vec / 4;
908/// vec = vec / ISize2::new(3, 1);
909/// assert_eq!(0, vec.x);
910/// assert_eq!(3, vec.y);
911/// ```
912impl Div for ISize2 {
913 type Output = ISize2;
914 fn div(self, rhs: Self) -> Self::Output {
915 return self.div_vec(rhs);
916 }
917}
918
919impl Debug for ISize2 {
920 /// # Example
921 /// ```
922 ///
923 /// use vox_geometry_rust::isize2::ISize2;
924 /// let vec = ISize2::new(10, 20);
925 /// assert_eq!(format!("{:?}", vec), "(10, 20)");
926 ///
927 /// assert_eq!(format!("{:#?}", vec), "(
928 /// 10,
929 /// 20,
930 /// )");
931 /// ```
932 fn fmt(&self, f: &mut Formatter<'_>) -> Result {
933 f.debug_tuple("")
934 .field(&self.x)
935 .field(&self.y)
936 .finish()
937 }
938}
939
940/// # utility
941/// Returns element-wise min size: (min(a.x, b.x), min(a.y, b.y)).
942/// ```
943/// use vox_geometry_rust::isize2::ISize2;
944/// use vox_geometry_rust::isize2::min;
945/// let vec = ISize2::new(5, 1);
946/// let vec2 = ISize2::new(3, 3);
947/// let min_size = min(&vec, &vec2);
948/// assert_eq!(ISize2::new(3, 1), min_size);
949/// ```
950pub fn min(a: &ISize2, b: &ISize2) -> ISize2 {
951 return ISize2::new(isize::min(a.x, b.x), isize::min(a.y, b.y));
952}
953
954/// Returns element-wise max size: (max(a.x, b.x), max(a.y, b.y)).
955/// ```
956/// use vox_geometry_rust::isize2::ISize2;
957/// use vox_geometry_rust::isize2::max;
958/// let vec = ISize2::new(5, 1);
959/// let vec2 = ISize2::new(3, 3);
960/// let min_size = max(&vec, &vec2);
961/// assert_eq!(ISize2::new(5, 3), min_size);
962/// ```
963pub fn max(a: &ISize2, b: &ISize2) -> ISize2 {
964 return ISize2::new(isize::max(a.x, b.x), isize::max(a.y, b.y));
965}
966
967/// Returns element-wise clamped size.
968/// ```
969/// use vox_geometry_rust::isize2::ISize2;
970/// use vox_geometry_rust::isize2::clamp;
971/// let vec = ISize2::new(2, 4);
972/// let low = ISize2::new(3, 1);
973/// let high = ISize2::new(5, 2);
974/// let clamped_vec = clamp(&vec, &low, &high);
975/// assert_eq!(ISize2::new(3, 2), clamped_vec);
976/// ```
977pub fn clamp(v: &ISize2, low: &ISize2, high: &ISize2) -> ISize2 {
978 return ISize2::new(isize::clamp(v.x, low.x, high.x),
979 isize::clamp(v.y, low.y, high.y));
980}