csta/
lib.rs

1//!
2//! This file contains the Randomizable trait and the basic vector types with all the operations implemented.
3//!
4//! # CSTA
5//!
6//! `csta` is a library for simulating and analyzing complex systems. It is designed to be modular and easy to use.
7//!
8//! ## Features
9
10pub mod constraints;
11pub mod gamma;
12pub mod hist;
13pub mod indexing;
14pub mod markov;
15pub mod montecarlo;
16pub mod prelude;
17
18use rand::prelude::*;
19use std::ops::*;
20
21///
22/// Its like `Default` but it generates a random value on a given distribution.
23///
24/// # Examples
25///
26/// ```
27/// use rand::prelude::*;
28/// use csta::prelude::*;
29/// use rand::distributions::Uniform;
30///
31/// let mut rng = ThreadRng::default();
32/// let distr = Uniform::new(0.0, 100.0);
33/// let random_tuple = <(f64, f64)>::sample(&distr, &mut rng);
34/// assert!(f64::sample(&distr, &mut rng) < 100.0);
35/// assert!(f64::sample(&distr, &mut rng) >= 0.0);
36/// assert!(random_tuple.0 + random_tuple.0 < 200.0);
37/// assert!(random_tuple.0 + random_tuple.0 >= 0.0);
38/// ```
39///  
40pub trait Randomizable {
41    /// Generates a random value in the given distribution.
42    fn sample<D: Distribution<f64>, R: Rng + ?Sized>(distr: &D, rng: &mut R) -> Self;
43
44    /// Generates a random value in a uniform distribution [0.0, 1.0[.
45    fn sample_uniform<R: Rng + ?Sized>(rng: &mut R) -> Self
46    where
47        Self: Sized,
48    {
49        let distr = rand::distributions::Uniform::new(0.0, 1.0);
50        Self::sample(&distr, rng)
51    }
52
53    /// Generates a random value in a uniform distribution [0.0, 1.0[.
54    /// Function for testig purposes.
55    fn default_sample() -> Self
56    where
57        Self: Sized,
58    {
59        let mut rng = rand::thread_rng();
60        Self::sample_uniform(&mut rng)
61    }
62}
63
64///
65/// if two elements are randomizable, a tuple of both elements also will be
66macro_rules! randomize_tuple {
67    ($($t:tt)+) => {
68        impl<$($t: Randomizable,)+> Randomizable for ($($t,)+) {
69            fn sample<D: Distribution<f64>, R: Rng + ?Sized>(distr: &D, rng: &mut R) -> Self {
70                ( $( <$t>::sample(distr, rng), )+ )
71            }
72        }
73    };
74}
75
76randomize_tuple! {A B}
77randomize_tuple! {A B C}
78randomize_tuple! {A B C E}
79randomize_tuple! {A B C E F}
80randomize_tuple! {A B C E F G}
81randomize_tuple! {A B C E F G H}
82randomize_tuple! {A B C E F G H I}
83randomize_tuple! {A B C E F G H I J}
84randomize_tuple! {A B C E F G H I J K}
85randomize_tuple! {A B C E F G H I J K L}
86randomize_tuple! {A B C E F G H I J K L M}
87randomize_tuple! {A B C E F G H I J K L M N}
88randomize_tuple! {A B C E F G H I J K L M N O}
89randomize_tuple! {A B C E F G H I J K L M N O P}
90randomize_tuple! {A B C E F G H I J K L M N O P Q}
91
92// Definitions and implementations for 1 to 4 dimensions vectors with f64 elements.
93
94impl Randomizable for f64 {
95    fn sample<D: Distribution<f64>, R: Rng + ?Sized>(distr: &D, rng: &mut R) -> Self {
96        distr.sample(rng)
97    }
98}
99
100/// A 2D vector.
101#[derive(Debug, Clone, Copy, PartialEq, Default)]
102pub struct Vec2(f64, f64);
103
104impl Vec2 {
105    pub fn len(&self) -> f64 {
106        (self.0 * self.0 + self.1 * self.1).sqrt()
107    }
108
109    pub fn len2(&self) -> f64 {
110        self.0 * self.0 + self.1 * self.1
111    }
112
113    pub fn normalize(&mut self) {
114        let len = self.len();
115        self.0 /= len;
116        self.1 /= len;
117    }
118}
119
120impl Randomizable for Vec2 {
121    fn sample<D: Distribution<f64>, R: Rng + ?Sized>(distr: &D, rng: &mut R) -> Self {
122        Self(f64::sample(distr, rng), f64::sample(distr, rng))
123    }
124}
125
126impl From<(f64, f64)> for Vec2 {
127    fn from((x, y): (f64, f64)) -> Self {
128        Self(x, y)
129    }
130}
131
132impl From<Vec2> for (f64, f64) {
133    fn from(Vec2(x, y): Vec2) -> Self {
134        (x, y)
135    }
136}
137
138impl From<Vec2> for [f64; 2] {
139    fn from(Vec2(x, y): Vec2) -> Self {
140        [x, y]
141    }
142}
143
144impl From<[f64; 2]> for Vec2 {
145    fn from([x, y]: [f64; 2]) -> Self {
146        Self(x, y)
147    }
148}
149
150/// A 3D vector.
151#[derive(Debug, Clone, Copy, PartialEq, Default)]
152pub struct Vec3(f64, f64, f64);
153
154impl Vec3 {
155    pub fn len(&self) -> f64 {
156        (self.0 * self.0 + self.1 * self.1 + self.2 * self.2).sqrt()
157    }
158
159    pub fn len2(&self) -> f64 {
160        self.0 * self.0 + self.1 * self.1 + self.2 * self.2
161    }
162
163    pub fn normalize(&mut self) {
164        let len = self.len();
165        self.0 /= len;
166        self.1 /= len;
167        self.2 /= len;
168    }
169}
170
171impl Randomizable for Vec3 {
172    fn sample<D: Distribution<f64>, R: Rng + ?Sized>(distr: &D, rng: &mut R) -> Self {
173        Self(
174            f64::sample(distr, rng),
175            f64::sample(distr, rng),
176            f64::sample(distr, rng),
177        )
178    }
179}
180
181impl From<(f64, f64, f64)> for Vec3 {
182    fn from((x, y, z): (f64, f64, f64)) -> Self {
183        Self(x, y, z)
184    }
185}
186
187impl From<Vec3> for (f64, f64, f64) {
188    fn from(Vec3(x, y, z): Vec3) -> Self {
189        (x, y, z)
190    }
191}
192
193impl From<Vec3> for [f64; 3] {
194    fn from(Vec3(x, y, z): Vec3) -> Self {
195        [x, y, z]
196    }
197}
198
199impl From<[f64; 3]> for Vec3 {
200    fn from([x, y, z]: [f64; 3]) -> Self {
201        Self(x, y, z)
202    }
203}
204
205/// A 4D vector.
206#[derive(Debug, Clone, Copy, PartialEq, Default)]
207pub struct Vec4(f64, f64, f64, f64);
208
209impl Vec4 {
210    pub fn len(&self) -> f64 {
211        (self.0 * self.0 + self.1 * self.1 + self.2 * self.2 + self.3 * self.3).sqrt()
212    }
213
214    pub fn len2(&self) -> f64 {
215        self.0 * self.0 + self.1 * self.1 + self.2 * self.2 + self.3 * self.3
216    }
217
218    pub fn normalize(&mut self) {
219        let len = self.len();
220        self.0 /= len;
221        self.1 /= len;
222        self.2 /= len;
223        self.3 /= len;
224    }
225}
226
227impl Randomizable for Vec4 {
228    fn sample<D: Distribution<f64>, R: Rng + ?Sized>(distr: &D, rng: &mut R) -> Self {
229        Self(
230            f64::sample(distr, rng),
231            f64::sample(distr, rng),
232            f64::sample(distr, rng),
233            f64::sample(distr, rng),
234        )
235    }
236}
237
238impl From<(f64, f64, f64, f64)> for Vec4 {
239    fn from((x, y, z, w): (f64, f64, f64, f64)) -> Self {
240        Self(x, y, z, w)
241    }
242}
243
244impl From<Vec4> for (f64, f64, f64, f64) {
245    fn from(Vec4(x, y, z, w): Vec4) -> Self {
246        (x, y, z, w)
247    }
248}
249
250impl From<Vec4> for [f64; 4] {
251    fn from(Vec4(x, y, z, w): Vec4) -> Self {
252        [x, y, z, w]
253    }
254}
255
256impl From<[f64; 4]> for Vec4 {
257    fn from([x, y, z, w]: [f64; 4]) -> Self {
258        Self(x, y, z, w)
259    }
260}
261
262// Implementation of the basic operations for the vectors.
263
264impl Add<Vec2> for Vec2 {
265    type Output = Vec2;
266
267    fn add(self, Vec2(x, y): Self) -> Vec2 {
268        Self(self.0 + x, self.1 + y)
269    }
270}
271
272impl AddAssign<Vec2> for Vec2 {
273    fn add_assign(&mut self, Vec2(x, y): Self) {
274        self.0 += x;
275        self.1 += y;
276    }
277}
278
279impl Sub<Vec2> for Vec2 {
280    type Output = Vec2;
281
282    fn sub(self, Vec2(x, y): Self) -> Vec2 {
283        Self(self.0 - x, self.1 - y)
284    }
285}
286
287impl SubAssign<Vec2> for Vec2 {
288    fn sub_assign(&mut self, Vec2(x, y): Self) {
289        self.0 -= x;
290        self.1 -= y;
291    }
292}
293
294impl Mul<f64> for Vec2 {
295    type Output = Vec2;
296
297    fn mul(self, scalar: f64) -> Vec2 {
298        Self(self.0 * scalar, self.1 * scalar)
299    }
300}
301
302impl MulAssign<f64> for Vec2 {
303    fn mul_assign(&mut self, scalar: f64) {
304        self.0 *= scalar;
305        self.1 *= scalar;
306    }
307}
308
309impl Div<f64> for Vec2 {
310    type Output = Vec2;
311
312    fn div(self, scalar: f64) -> Vec2 {
313        Self(self.0 / scalar, self.1 / scalar)
314    }
315}
316
317impl DivAssign<f64> for Vec2 {
318    fn div_assign(&mut self, scalar: f64) {
319        self.0 /= scalar;
320        self.1 /= scalar;
321    }
322}
323
324impl Neg for Vec2 {
325    type Output = Self;
326
327    fn neg(self) -> Self {
328        Self(-self.0, -self.1)
329    }
330}
331
332impl<'a> Add<&'a Vec2> for &'a Vec2 {
333    type Output = Vec2;
334
335    fn add(self, Vec2(x, y): Self) -> Vec2 {
336        Vec2(self.0 + x, self.1 + y)
337    }
338}
339
340impl<'a> Sub<&'a Vec2> for &'a Vec2 {
341    type Output = Vec2;
342
343    fn sub(self, Vec2(x, y): Self) -> Vec2 {
344        Vec2(self.0 - x, self.1 - y)
345    }
346}
347
348impl<'a> Mul<&f64> for &'a Vec2 {
349    type Output = Vec2;
350
351    fn mul(self, scalar: &f64) -> Vec2 {
352        Vec2(self.0 * scalar, self.1 * scalar)
353    }
354}
355
356impl<'a> Div<&f64> for &'a Vec2 {
357    type Output = Vec2;
358
359    fn div(self, scalar: &f64) -> Vec2 {
360        Vec2(self.0 / scalar, self.1 / scalar)
361    }
362}
363
364impl<'a> Neg for &'a Vec2 {
365    type Output = Vec2;
366
367    fn neg(self) -> Vec2 {
368        Vec2(-self.0, -self.1)
369    }
370}
371
372impl AddAssign<&Vec2> for Vec2 {
373    fn add_assign(&mut self, rhs: &Vec2) {
374        self.0 += rhs.0;
375        self.1 += rhs.1;
376    }
377}
378
379impl SubAssign<&Vec2> for Vec2 {
380    fn sub_assign(&mut self, rhs: &Vec2) {
381        self.0 -= rhs.0;
382        self.1 -= rhs.1;
383    }
384}
385
386impl MulAssign<&f64> for Vec2 {
387    fn mul_assign(&mut self, scalar: &f64) {
388        self.0 *= scalar;
389        self.1 *= scalar;
390    }
391}
392
393impl DivAssign<&f64> for Vec2 {
394    fn div_assign(&mut self, scalar: &f64) {
395        self.0 /= scalar;
396        self.1 /= scalar;
397    }
398}
399
400impl Add<Vec3> for Vec3 {
401    type Output = Vec3;
402
403    fn add(self, Vec3(x, y, z): Self) -> Vec3 {
404        Self(self.0 + x, self.1 + y, self.2 + z)
405    }
406}
407
408impl AddAssign<Vec3> for Vec3 {
409    fn add_assign(&mut self, Vec3(x, y, z): Self) {
410        self.0 += x;
411        self.1 += y;
412        self.2 += z;
413    }
414}
415
416impl Sub<Vec3> for Vec3 {
417    type Output = Vec3;
418
419    fn sub(self, Vec3(x, y, z): Self) -> Vec3 {
420        Self(self.0 - x, self.1 - y, self.2 - z)
421    }
422}
423
424impl SubAssign<Vec3> for Vec3 {
425    fn sub_assign(&mut self, Vec3(x, y, z): Self) {
426        self.0 -= x;
427        self.1 -= y;
428        self.2 -= z;
429    }
430}
431
432impl Mul<f64> for Vec3 {
433    type Output = Vec3;
434
435    fn mul(self, scalar: f64) -> Vec3 {
436        Self(self.0 * scalar, self.1 * scalar, self.2 * scalar)
437    }
438}
439
440impl MulAssign<f64> for Vec3 {
441    fn mul_assign(&mut self, scalar: f64) {
442        self.0 *= scalar;
443        self.1 *= scalar;
444        self.2 *= scalar;
445    }
446}
447
448impl Div<f64> for Vec3 {
449    type Output = Vec3;
450
451    fn div(self, scalar: f64) -> Vec3 {
452        Self(self.0 / scalar, self.1 / scalar, self.2 / scalar)
453    }
454}
455
456impl DivAssign<f64> for Vec3 {
457    fn div_assign(&mut self, scalar: f64) {
458        self.0 /= scalar;
459        self.1 /= scalar;
460        self.2 /= scalar;
461    }
462}
463
464impl Neg for Vec3 {
465    type Output = Self;
466
467    fn neg(self) -> Self {
468        Self(-self.0, -self.1, -self.2)
469    }
470}
471
472impl<'a> Add<&'a Vec3> for &'a Vec3 {
473    type Output = Vec3;
474
475    fn add(self, Vec3(x, y, z): Self) -> Vec3 {
476        Vec3(self.0 + x, self.1 + y, self.2 + z)
477    }
478}
479
480impl<'a> Sub<&'a Vec3> for &'a Vec3 {
481    type Output = Vec3;
482
483    fn sub(self, Vec3(x, y, z): Self) -> Vec3 {
484        Vec3(self.0 - x, self.1 - y, self.2 - z)
485    }
486}
487
488impl<'a> Mul<&f64> for &'a Vec3 {
489    type Output = Vec3;
490
491    fn mul(self, scalar: &f64) -> Vec3 {
492        Vec3(self.0 * scalar, self.1 * scalar, self.2 * scalar)
493    }
494}
495
496impl<'a> Div<&f64> for &'a Vec3 {
497    type Output = Vec3;
498
499    fn div(self, scalar: &f64) -> Vec3 {
500        Vec3(self.0 / scalar, self.1 / scalar, self.2 / scalar)
501    }
502}
503
504impl<'a> Neg for &'a Vec3 {
505    type Output = Vec3;
506
507    fn neg(self) -> Vec3 {
508        Vec3(-self.0, -self.1, -self.2)
509    }
510}
511
512impl AddAssign<&Vec3> for Vec3 {
513    fn add_assign(&mut self, rhs: &Vec3) {
514        self.0 += rhs.0;
515        self.1 += rhs.1;
516        self.2 += rhs.2;
517    }
518}
519
520impl SubAssign<&Vec3> for Vec3 {
521    fn sub_assign(&mut self, rhs: &Vec3) {
522        self.0 -= rhs.0;
523        self.1 -= rhs.1;
524        self.2 -= rhs.2;
525    }
526}
527
528impl MulAssign<&f64> for Vec3 {
529    fn mul_assign(&mut self, scalar: &f64) {
530        self.0 *= scalar;
531        self.1 *= scalar;
532        self.2 *= scalar;
533    }
534}
535
536impl DivAssign<&f64> for Vec3 {
537    fn div_assign(&mut self, scalar: &f64) {
538        self.0 /= scalar;
539        self.1 /= scalar;
540        self.2 /= scalar;
541    }
542}
543
544impl Add<Vec4> for Vec4 {
545    type Output = Vec4;
546
547    fn add(self, Vec4(x, y, z, w): Self) -> Vec4 {
548        Self(self.0 + x, self.1 + y, self.2 + z, self.3 + w)
549    }
550}
551
552impl AddAssign<Vec4> for Vec4 {
553    fn add_assign(&mut self, Vec4(x, y, z, w): Self) {
554        self.0 += x;
555        self.1 += y;
556        self.2 += z;
557        self.3 += w;
558    }
559}
560
561impl Sub<Vec4> for Vec4 {
562    type Output = Vec4;
563
564    fn sub(self, Vec4(x, y, z, w): Self) -> Vec4 {
565        Self(self.0 - x, self.1 - y, self.2 - z, self.3 - w)
566    }
567}
568
569impl SubAssign<Vec4> for Vec4 {
570    fn sub_assign(&mut self, Vec4(x, y, z, w): Self) {
571        self.0 -= x;
572        self.1 -= y;
573        self.2 -= z;
574        self.3 -= w;
575    }
576}
577
578impl Mul<f64> for Vec4 {
579    type Output = Vec4;
580
581    fn mul(self, scalar: f64) -> Vec4 {
582        Self(
583            self.0 * scalar,
584            self.1 * scalar,
585            self.2 * scalar,
586            self.3 * scalar,
587        )
588    }
589}
590
591impl MulAssign<f64> for Vec4 {
592    fn mul_assign(&mut self, scalar: f64) {
593        self.0 *= scalar;
594        self.1 *= scalar;
595        self.2 *= scalar;
596        self.3 *= scalar;
597    }
598}
599
600impl Div<f64> for Vec4 {
601    type Output = Vec4;
602
603    fn div(self, scalar: f64) -> Vec4 {
604        Self(
605            self.0 / scalar,
606            self.1 / scalar,
607            self.2 / scalar,
608            self.3 / scalar,
609        )
610    }
611}
612
613impl DivAssign<f64> for Vec4 {
614    fn div_assign(&mut self, scalar: f64) {
615        self.0 /= scalar;
616        self.1 /= scalar;
617        self.2 /= scalar;
618        self.3 /= scalar;
619    }
620}
621
622impl Neg for Vec4 {
623    type Output = Self;
624
625    fn neg(self) -> Self {
626        Self(-self.0, -self.1, -self.2, -self.3)
627    }
628}
629
630impl<'a> Add<&'a Vec4> for &'a Vec4 {
631    type Output = Vec4;
632
633    fn add(self, Vec4(x, y, z, w): Self) -> Vec4 {
634        Vec4(self.0 + x, self.1 + y, self.2 + z, self.3 + w)
635    }
636}
637
638impl<'a> Sub<&'a Vec4> for &'a Vec4 {
639    type Output = Vec4;
640
641    fn sub(self, Vec4(x, y, z, w): Self) -> Vec4 {
642        Vec4(self.0 - x, self.1 - y, self.2 - z, self.3 - w)
643    }
644}
645
646impl<'a> Mul<&f64> for &'a Vec4 {
647    type Output = Vec4;
648
649    fn mul(self, scalar: &f64) -> Vec4 {
650        Vec4(
651            self.0 * scalar,
652            self.1 * scalar,
653            self.2 * scalar,
654            self.3 * scalar,
655        )
656    }
657}
658
659impl<'a> Div<&f64> for &'a Vec4 {
660    type Output = Vec4;
661
662    fn div(self, scalar: &f64) -> Vec4 {
663        Vec4(
664            self.0 / scalar,
665            self.1 / scalar,
666            self.2 / scalar,
667            self.3 / scalar,
668        )
669    }
670}
671
672impl<'a> Neg for &'a Vec4 {
673    type Output = Vec4;
674
675    fn neg(self) -> Vec4 {
676        Vec4(-self.0, -self.1, -self.2, -self.3)
677    }
678}
679
680impl AddAssign<&Vec4> for Vec4 {
681    fn add_assign(&mut self, rhs: &Vec4) {
682        self.0 += rhs.0;
683        self.1 += rhs.1;
684        self.2 += rhs.2;
685        self.3 += rhs.3;
686    }
687}
688
689impl SubAssign<&Vec4> for Vec4 {
690    fn sub_assign(&mut self, rhs: &Vec4) {
691        self.0 -= rhs.0;
692        self.1 -= rhs.1;
693        self.2 -= rhs.2;
694        self.3 -= rhs.3;
695    }
696}
697
698impl MulAssign<&f64> for Vec4 {
699    fn mul_assign(&mut self, scalar: &f64) {
700        self.0 *= scalar;
701        self.1 *= scalar;
702        self.2 *= scalar;
703        self.3 *= scalar;
704    }
705}
706
707impl DivAssign<&f64> for Vec4 {
708    fn div_assign(&mut self, scalar: &f64) {
709        self.0 /= scalar;
710        self.1 /= scalar;
711        self.2 /= scalar;
712        self.3 /= scalar;
713    }
714}
715
716#[derive(Debug, Clone, Copy, PartialEq, Default)]
717pub struct CartesianCoord2(Vec2);
718
719impl Deref for CartesianCoord2 {
720    type Target = Vec2;
721
722    fn deref(&self) -> &Self::Target {
723        &self.0
724    }
725}
726
727impl DerefMut for CartesianCoord2 {
728    fn deref_mut(&mut self) -> &mut Self::Target {
729        &mut self.0
730    }
731}
732
733impl From<Vec2> for CartesianCoord2 {
734    fn from(v: Vec2) -> Self {
735        Self(v)
736    }
737}
738
739impl From<CartesianCoord2> for Vec2 {
740    fn from(CartesianCoord2(v): CartesianCoord2) -> Self {
741        v
742    }
743}
744
745#[derive(Debug, Clone, Copy, PartialEq, Default)]
746pub struct CartesianCoord3(Vec3);
747
748impl Deref for CartesianCoord3 {
749    type Target = Vec3;
750
751    fn deref(&self) -> &Self::Target {
752        &self.0
753    }
754}
755
756impl DerefMut for CartesianCoord3 {
757    fn deref_mut(&mut self) -> &mut Self::Target {
758        &mut self.0
759    }
760}
761
762impl From<Vec3> for CartesianCoord3 {
763    fn from(v: Vec3) -> Self {
764        Self(v)
765    }
766}
767
768impl From<CartesianCoord3> for Vec3 {
769    fn from(CartesianCoord3(v): CartesianCoord3) -> Self {
770        v
771    }
772}
773
774#[derive(Debug, Clone, Copy, PartialEq, Default)]
775pub struct CartesianCoord4(Vec4);
776
777impl Deref for CartesianCoord4 {
778    type Target = Vec4;
779
780    fn deref(&self) -> &Self::Target {
781        &self.0
782    }
783}
784
785impl DerefMut for CartesianCoord4 {
786    fn deref_mut(&mut self) -> &mut Self::Target {
787        &mut self.0
788    }
789}
790
791impl From<Vec4> for CartesianCoord4 {
792    fn from(v: Vec4) -> Self {
793        Self(v)
794    }
795}
796
797impl From<CartesianCoord4> for Vec4 {
798    fn from(CartesianCoord4(v): CartesianCoord4) -> Self {
799        v
800    }
801}
802
803#[derive(Debug, Clone, Copy, PartialEq, Default)]
804pub struct SphericalCoord2(Vec2);
805
806impl Deref for SphericalCoord2 {
807    type Target = Vec2;
808
809    fn deref(&self) -> &Self::Target {
810        &self.0
811    }
812}
813
814impl DerefMut for SphericalCoord2 {
815    fn deref_mut(&mut self) -> &mut Self::Target {
816        &mut self.0
817    }
818}
819
820impl From<Vec2> for SphericalCoord2 {
821    fn from(v: Vec2) -> Self {
822        Self(v)
823    }
824}
825
826impl From<SphericalCoord2> for Vec2 {
827    fn from(SphericalCoord2(v): SphericalCoord2) -> Self {
828        v
829    }
830}
831
832#[derive(Debug, Clone, Copy, PartialEq, Default)]
833pub struct SphericalCoord3(Vec3);
834
835impl Deref for SphericalCoord3 {
836    type Target = Vec3;
837
838    fn deref(&self) -> &Self::Target {
839        &self.0
840    }
841}
842
843impl DerefMut for SphericalCoord3 {
844    fn deref_mut(&mut self) -> &mut Self::Target {
845        &mut self.0
846    }
847}
848
849impl From<Vec3> for SphericalCoord3 {
850    fn from(v: Vec3) -> Self {
851        Self(v)
852    }
853}
854
855impl From<SphericalCoord3> for Vec3 {
856    fn from(SphericalCoord3(v): SphericalCoord3) -> Self {
857        v
858    }
859}
860
861#[derive(Debug, Clone, Copy, PartialEq, Default)]
862pub struct SphericalCoord4(Vec4);
863
864impl Deref for SphericalCoord4 {
865    type Target = Vec4;
866
867    fn deref(&self) -> &Self::Target {
868        &self.0
869    }
870}
871
872impl DerefMut for SphericalCoord4 {
873    fn deref_mut(&mut self) -> &mut Self::Target {
874        &mut self.0
875    }
876}
877
878impl From<Vec4> for SphericalCoord4 {
879    fn from(v: Vec4) -> Self {
880        Self(v)
881    }
882}
883
884impl From<SphericalCoord4> for Vec4 {
885    fn from(SphericalCoord4(v): SphericalCoord4) -> Self {
886        v
887    }
888}
csta/lib.rs

csta/
lib.rs
