Change arguments from value to reference

TonalidadeHidrica · TonalidadeHidrica · commit f54acaf2ec06 · 2020-09-15T00:15:47.000+09:00
diff --git a/examples/practice2_k_range_affine_range_sum.rs b/examples/practice2_k_range_affine_range_sum.rs
@@ -10,7 +10,7 @@ impl Monoid for Sum {
         (0.into(), 0)
     }
 
-    fn binary_operation((a, n): Self::S, (b, m): Self::S) -> Self::S {
+    fn binary_operation(&(a, n): &Self::S, &(b, m): &Self::S) -> Self::S {
         (a + b, n + m)
     }
 }
@@ -23,12 +23,12 @@ impl MapMonoid for Affine {
         (1.into(), 0.into())
     }
 
-    fn mapping((a, b): Self::F, (x, n): <Self::M as Monoid>::S) -> <Self::M as Monoid>::S {
+    fn mapping(&(a, b): &Self::F, &(x, n): &<Self::M as Monoid>::S) -> <Self::M as Monoid>::S {
         (a * x + b * Mint::new(n), n)
     }
 
     // a(cx + d) + b = (ac)x + (ad+b)
-    fn composition((a, b): Self::F, (c, d): Self::F) -> Self::F {
+    fn composition(&(a, b): &Self::F, &(c, d): &Self::F) -> Self::F {
         (a * c, a * d + b)
     }
 }
diff --git a/examples/practice2_l_lazy_segment_tree.rs b/examples/practice2_l_lazy_segment_tree.rs
@@ -9,7 +9,7 @@ impl Monoid for M {
     fn identity() -> Self::S {
         (0, 0, 0)
     }
-    fn binary_operation((a, b, c): Self::S, (d, e, f): Self::S) -> Self::S {
+    fn binary_operation(&(a, b, c): &Self::S, &(d, e, f): &Self::S) -> Self::S {
         (a + d, b + e, c + f + b * d)
     }
 }
@@ -21,7 +21,7 @@ impl MapMonoid for F {
     fn identity_map() -> Self::F {
         false
     }
-    fn mapping(f: Self::F, (a, b, c): <M as Monoid>::S) -> <M as Monoid>::S {
+    fn mapping(&f: &Self::F, &(a, b, c): &<M as Monoid>::S) -> <M as Monoid>::S {
         if f {
             // (a + b) * (a + b - 1) / 2 - a * (a - 1) / 2 - b * (b - 1) / 2 - c
             // = a * b - c
@@ -30,7 +30,7 @@ impl MapMonoid for F {
             (a, b, c)
         }
     }
-    fn composition(f: Self::F, g: Self::F) -> Self::F {
+    fn composition(&f: &Self::F, &g: &Self::F) -> Self::F {
         f ^ g
     }
 }
diff --git a/src/lazysegtree.rs b/src/lazysegtree.rs
@@ -9,14 +9,14 @@ pub trait MapMonoid {
         Self::M::identity()
     }
     fn binary_operation(
-        a: <Self::M as Monoid>::S,
-        b: <Self::M as Monoid>::S,
+        a: &<Self::M as Monoid>::S,
+        b: &<Self::M as Monoid>::S,
     ) -> <Self::M as Monoid>::S {
         Self::M::binary_operation(a, b)
     }
     fn identity_map() -> Self::F;
-    fn mapping(f: Self::F, x: <Self::M as Monoid>::S) -> <Self::M as Monoid>::S;
-    fn composition(f: Self::F, g: Self::F) -> Self::F;
+    fn mapping(f: &Self::F, x: &<Self::M as Monoid>::S) -> <Self::M as Monoid>::S;
+    fn composition(f: &Self::F, g: &Self::F) -> Self::F;
 }
 
 impl<F: MapMonoid> Default for LazySegtree<F> {
@@ -95,18 +95,18 @@ impl<F: MapMonoid> LazySegtree<F> {
         let mut smr = F::identity_element();
         while l < r {
             if l & 1 != 0 {
-                sml = F::binary_operation(sml, self.d[l].clone());
+                sml = F::binary_operation(&sml, &self.d[l]);
                 l += 1;
             }
             if r & 1 != 0 {
                 r -= 1;
-                smr = F::binary_operation(self.d[r].clone(), smr);
+                smr = F::binary_operation(&self.d[r], &smr);
             }
             l >>= 1;
             r >>= 1;
         }
 
-        F::binary_operation(sml, smr)
+        F::binary_operation(&sml, &smr)
     }
 
     pub fn all_prod(&self) -> <F::M as Monoid>::S {
@@ -119,7 +119,7 @@ impl<F: MapMonoid> LazySegtree<F> {
         for i in (1..=self.log).rev() {
             self.push(p >> i);
         }
-        self.d[p] = F::mapping(f, self.d[p].clone());
+        self.d[p] = F::mapping(&f, &self.d[p]);
         for i in 1..=self.log {
             self.update(p >> i);
         }
@@ -190,19 +190,19 @@ impl<F: MapMonoid> LazySegtree<F> {
             while l % 2 == 0 {
                 l >>= 1;
             }
-            if !g(F::binary_operation(sm.clone(), self.d[l].clone())) {
+            if !g(F::binary_operation(&sm, &self.d[l])) {
                 while l < self.size {
                     self.push(l);
                     l *= 2;
-                    let res = F::binary_operation(sm.clone(), self.d[l].clone());
+                    let res = F::binary_operation(&sm, &self.d[l]);
                     if g(res.clone()) {
                         sm = res;
                         l += 1;
                     }
                 }
                 return l - self.size;
             }
-            sm = F::binary_operation(sm, self.d[l].clone());
+            sm = F::binary_operation(&sm, &self.d[l]);
             l += 1;
             //while
             {
@@ -233,19 +233,19 @@ impl<F: MapMonoid> LazySegtree<F> {
             while r > 1 && r % 2 != 0 {
                 r >>= 1;
             }
-            if !g(F::binary_operation(self.d[r].clone(), sm.clone())) {
+            if !g(F::binary_operation(&self.d[r], &sm)) {
                 while r < self.size {
                     self.push(r);
                     r = 2 * r + 1;
-                    let res = F::binary_operation(self.d[r].clone(), sm.clone());
+                    let res = F::binary_operation(&self.d[r], &sm);
                     if g(res.clone()) {
                         sm = res;
                         r -= 1;
                     }
                 }
                 return r + 1 - self.size;
             }
-            sm = F::binary_operation(self.d[r].clone(), sm);
+            sm = F::binary_operation(&self.d[r], &sm);
             // while
             {
                 let r = r as isize;
@@ -271,12 +271,12 @@ where
     F: MapMonoid,
 {
     fn update(&mut self, k: usize) {
-        self.d[k] = F::binary_operation(self.d[2 * k].clone(), self.d[2 * k + 1].clone());
+        self.d[k] = F::binary_operation(&self.d[2 * k], &self.d[2 * k + 1]);
     }
     fn all_apply(&mut self, k: usize, f: F::F) {
-        self.d[k] = F::mapping(f.clone(), self.d[k].clone());
+        self.d[k] = F::mapping(&f, &self.d[k]);
         if k < self.size {
-            self.lz[k] = F::composition(f, self.lz[k].clone());
+            self.lz[k] = F::composition(&f, &self.lz[k]);
         }
     }
     fn push(&mut self, k: usize) {
@@ -325,11 +325,11 @@ mod tests {
             0
         }
 
-        fn mapping(f: i32, x: i32) -> i32 {
+        fn mapping(&f: &i32, &x: &i32) -> i32 {
             f + x
         }
 
-        fn composition(f: i32, g: i32) -> i32 {
+        fn composition(&f: &i32, &g: &i32) -> i32 {
             f + g
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ impl Monoid for Sum {`
`10`	`10`	`(0.into(), 0)`
`11`	`11`	`}`
`12`	`12`
`13`		`- fn binary_operation((a, n): Self::S, (b, m): Self::S) -> Self::S {`
	`13`	`+ fn binary_operation(&(a, n): &Self::S, &(b, m): &Self::S) -> Self::S {`
`14`	`14`	`(a + b, n + m)`
`15`	`15`	`}`
`16`	`16`	`}`
`@@ -23,12 +23,12 @@ impl MapMonoid for Affine {`
`23`	`23`	`(1.into(), 0.into())`
`24`	`24`	`}`
`25`	`25`
`26`		`- fn mapping((a, b): Self::F, (x, n): <Self::M as Monoid>::S) -> <Self::M as Monoid>::S {`
	`26`	`+ fn mapping(&(a, b): &Self::F, &(x, n): &<Self::M as Monoid>::S) -> <Self::M as Monoid>::S {`
`27`	`27`	`(a * x + b * Mint::new(n), n)`
`28`	`28`	`}`
`29`	`29`
`30`	`30`	`// a(cx + d) + b = (ac)x + (ad+b)`
`31`		`- fn composition((a, b): Self::F, (c, d): Self::F) -> Self::F {`
	`31`	`+ fn composition(&(a, b): &Self::F, &(c, d): &Self::F) -> Self::F {`
`32`	`32`	`(a * c, a * d + b)`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ impl Monoid for M {`
`9`	`9`	`fn identity() -> Self::S {`
`10`	`10`	`(0, 0, 0)`
`11`	`11`	`}`
`12`		`- fn binary_operation((a, b, c): Self::S, (d, e, f): Self::S) -> Self::S {`
	`12`	`+ fn binary_operation(&(a, b, c): &Self::S, &(d, e, f): &Self::S) -> Self::S {`
`13`	`13`	`(a + d, b + e, c + f + b * d)`
`14`	`14`	`}`
`15`	`15`	`}`
`@@ -21,7 +21,7 @@ impl MapMonoid for F {`
`21`	`21`	`fn identity_map() -> Self::F {`
`22`	`22`	`false`
`23`	`23`	`}`
`24`		`- fn mapping(f: Self::F, (a, b, c): <M as Monoid>::S) -> <M as Monoid>::S {`
	`24`	`+ fn mapping(&f: &Self::F, &(a, b, c): &<M as Monoid>::S) -> <M as Monoid>::S {`
`25`	`25`	`if f {`
`26`	`26`	`// (a + b) * (a + b - 1) / 2 - a * (a - 1) / 2 - b * (b - 1) / 2 - c`
`27`	`27`	`// = a * b - c`
`@@ -30,7 +30,7 @@ impl MapMonoid for F {`
`30`	`30`	`(a, b, c)`
`31`	`31`	`}`
`32`	`32`	`}`
`33`		`- fn composition(f: Self::F, g: Self::F) -> Self::F {`
	`33`	`+ fn composition(&f: &Self::F, &g: &Self::F) -> Self::F {`
`34`	`34`	`f ^ g`
`35`	`35`	`}`
`36`	`36`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,14 +9,14 @@ pub trait MapMonoid {`
`9`	`9`	`Self::M::identity()`
`10`	`10`	`}`
`11`	`11`	`fn binary_operation(`
`12`		`- a: <Self::M as Monoid>::S,`
`13`		`- b: <Self::M as Monoid>::S,`
	`12`	`+ a: &<Self::M as Monoid>::S,`
	`13`	`+ b: &<Self::M as Monoid>::S,`
`14`	`14`	`) -> <Self::M as Monoid>::S {`
`15`	`15`	`Self::M::binary_operation(a, b)`
`16`	`16`	`}`
`17`	`17`	`fn identity_map() -> Self::F;`
`18`		`- fn mapping(f: Self::F, x: <Self::M as Monoid>::S) -> <Self::M as Monoid>::S;`
`19`		`- fn composition(f: Self::F, g: Self::F) -> Self::F;`
	`18`	`+ fn mapping(f: &Self::F, x: &<Self::M as Monoid>::S) -> <Self::M as Monoid>::S;`
	`19`	`+ fn composition(f: &Self::F, g: &Self::F) -> Self::F;`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`impl<F: MapMonoid> Default for LazySegtree<F> {`
`@@ -95,18 +95,18 @@ impl<F: MapMonoid> LazySegtree<F> {`
`95`	`95`	`let mut smr = F::identity_element();`
`96`	`96`	`while l < r {`
`97`	`97`	`if l & 1 != 0 {`
`98`		`- sml = F::binary_operation(sml, self.d[l].clone());`
	`98`	`+ sml = F::binary_operation(&sml, &self.d[l]);`
`99`	`99`	`l += 1;`
`100`	`100`	`}`
`101`	`101`	`if r & 1 != 0 {`
`102`	`102`	`r -= 1;`
`103`		`- smr = F::binary_operation(self.d[r].clone(), smr);`
	`103`	`+ smr = F::binary_operation(&self.d[r], &smr);`
`104`	`104`	`}`
`105`	`105`	`l >>= 1;`
`106`	`106`	`r >>= 1;`
`107`	`107`	`}`
`108`	`108`
`109`		`- F::binary_operation(sml, smr)`
	`109`	`+ F::binary_operation(&sml, &smr)`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`pub fn all_prod(&self) -> <F::M as Monoid>::S {`
`@@ -119,7 +119,7 @@ impl<F: MapMonoid> LazySegtree<F> {`
`119`	`119`	`for i in (1..=self.log).rev() {`
`120`	`120`	`self.push(p >> i);`
`121`	`121`	`}`
`122`		`- self.d[p] = F::mapping(f, self.d[p].clone());`
	`122`	`+ self.d[p] = F::mapping(&f, &self.d[p]);`
`123`	`123`	`for i in 1..=self.log {`
`124`	`124`	`self.update(p >> i);`
`125`	`125`	`}`
`@@ -190,19 +190,19 @@ impl<F: MapMonoid> LazySegtree<F> {`
`190`	`190`	`while l % 2 == 0 {`
`191`	`191`	`l >>= 1;`
`192`	`192`	`}`
`193`		`- if !g(F::binary_operation(sm.clone(), self.d[l].clone())) {`
	`193`	`+ if !g(F::binary_operation(&sm, &self.d[l])) {`
`194`	`194`	`while l < self.size {`
`195`	`195`	`self.push(l);`
`196`	`196`	`l *= 2;`
`197`		`- let res = F::binary_operation(sm.clone(), self.d[l].clone());`
	`197`	`+ let res = F::binary_operation(&sm, &self.d[l]);`
`198`	`198`	`if g(res.clone()) {`
`199`	`199`	`sm = res;`
`200`	`200`	`l += 1;`
`201`	`201`	`}`
`202`	`202`	`}`
`203`	`203`	`return l - self.size;`
`204`	`204`	`}`
`205`		`- sm = F::binary_operation(sm, self.d[l].clone());`
	`205`	`+ sm = F::binary_operation(&sm, &self.d[l]);`
`206`	`206`	`l += 1;`
`207`	`207`	`//while`
`208`	`208`	`{`
`@@ -233,19 +233,19 @@ impl<F: MapMonoid> LazySegtree<F> {`
`233`	`233`	`while r > 1 && r % 2 != 0 {`
`234`	`234`	`r >>= 1;`
`235`	`235`	`}`
`236`		`- if !g(F::binary_operation(self.d[r].clone(), sm.clone())) {`
	`236`	`+ if !g(F::binary_operation(&self.d[r], &sm)) {`
`237`	`237`	`while r < self.size {`
`238`	`238`	`self.push(r);`
`239`	`239`	`r = 2 * r + 1;`
`240`		`- let res = F::binary_operation(self.d[r].clone(), sm.clone());`
	`240`	`+ let res = F::binary_operation(&self.d[r], &sm);`
`241`	`241`	`if g(res.clone()) {`
`242`	`242`	`sm = res;`
`243`	`243`	`r -= 1;`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`	`return r + 1 - self.size;`
`247`	`247`	`}`
`248`		`- sm = F::binary_operation(self.d[r].clone(), sm);`
	`248`	`+ sm = F::binary_operation(&self.d[r], &sm);`
`249`	`249`	`// while`
`250`	`250`	`{`
`251`	`251`	`let r = r as isize;`
`@@ -271,12 +271,12 @@ where`
`271`	`271`	`F: MapMonoid,`
`272`	`272`	`{`
`273`	`273`	`fn update(&mut self, k: usize) {`
`274`		`- self.d[k] = F::binary_operation(self.d[2 * k].clone(), self.d[2 * k + 1].clone());`
	`274`	`+ self.d[k] = F::binary_operation(&self.d[2 * k], &self.d[2 * k + 1]);`
`275`	`275`	`}`
`276`	`276`	`fn all_apply(&mut self, k: usize, f: F::F) {`
`277`		`- self.d[k] = F::mapping(f.clone(), self.d[k].clone());`
	`277`	`+ self.d[k] = F::mapping(&f, &self.d[k]);`
`278`	`278`	`if k < self.size {`
`279`		`- self.lz[k] = F::composition(f, self.lz[k].clone());`
	`279`	`+ self.lz[k] = F::composition(&f, &self.lz[k]);`
`280`	`280`	`}`
`281`	`281`	`}`
`282`	`282`	`fn push(&mut self, k: usize) {`
`@@ -325,11 +325,11 @@ mod tests {`
`325`	`325`	`0`
`326`	`326`	`}`
`327`	`327`
`328`		`- fn mapping(f: i32, x: i32) -> i32 {`
	`328`	`+ fn mapping(&f: &i32, &x: &i32) -> i32 {`
`329`	`329`	`f + x`
`330`	`330`	`}`
`331`	`331`
`332`		`- fn composition(f: i32, g: i32) -> i32 {`
	`332`	`+ fn composition(&f: &i32, &g: &i32) -> i32 {`
`333`	`333`	`f + g`
`334`	`334`	`}`
`335`	`335`	`}`