Struct FormalPowerSeries

Source

pub struct FormalPowerSeries<T, C> {
    pub data: Vec<T>,
    _marker: PhantomData<C>,
}

Fields§

§data: Vec<T>§_marker: PhantomData<C>

Implementations§

Source §

impl<T, C> FormalPowerSeries<T, C>

Source

pub fn from_vec(data: Vec<T>) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 38)

37    fn clone(&self) -> Self {
38        Self::from_vec(self.data.clone())
39    }
40}
41impl<T, C> PartialEq for FormalPowerSeries<T, C>
42where
43    T: PartialEq,
44{
45    fn eq(&self, other: &Self) -> bool {
46        self.data.eq(&other.data)
47    }
48}
49impl<T, C> Eq for FormalPowerSeries<T, C> where T: PartialEq {}
50
51impl<T, C> FormalPowerSeries<T, C>
52where
53    T: Zero,
54{
55    pub fn zeros(deg: usize) -> Self {
56        repeat_with(T::zero).take(deg).collect()
57    }
58    pub fn resize(&mut self, deg: usize) {
59        self.data.resize_with(deg, Zero::zero)
60    }
61    pub fn resized(mut self, deg: usize) -> Self {
62        self.resize(deg);
63        self
64    }
65    pub fn reversed(mut self) -> Self {
66        self.data.reverse();
67        self
68    }
69}
70
71impl<T, C> FormalPowerSeries<T, C>
72where
73    T: Zero + Clone,
74{
75    pub fn coeff(&self, deg: usize) -> T {
76        self.data.get(deg).cloned().unwrap_or_else(T::zero)
77    }
78}
79
80impl<T, C> FormalPowerSeries<T, C>
81where
82    T: Zero + PartialEq,
83{
84    pub fn trim_tail_zeros(&mut self) {
85        let mut len = self.length();
86        while len > 0 {
87            if self.data[len - 1].is_zero() {
88                len -= 1;
89            } else {
90                break;
91            }
92        }
93        self.truncate(len);
94    }
95}
96
97impl<T, C> Zero for FormalPowerSeries<T, C>
98where
99    T: PartialEq,
100{
101    fn zero() -> Self {
102        Self::from_vec(Vec::new())
103    }
104}
105impl<T, C> One for FormalPowerSeries<T, C>
106where
107    T: PartialEq + One,
108{
109    fn one() -> Self {
110        Self::from(T::one())
111    }
112}
113
114impl<T, C> IntoIterator for FormalPowerSeries<T, C> {
115    type Item = T;
116    type IntoIter = std::vec::IntoIter<T>;
117    fn into_iter(self) -> Self::IntoIter {
118        self.data.into_iter()
119    }
120}
121impl<'a, T, C> IntoIterator for &'a FormalPowerSeries<T, C> {
122    type Item = &'a T;
123    type IntoIter = Iter<'a, T>;
124    fn into_iter(self) -> Self::IntoIter {
125        self.data.iter()
126    }
127}
128impl<'a, T, C> IntoIterator for &'a mut FormalPowerSeries<T, C> {
129    type Item = &'a mut T;
130    type IntoIter = IterMut<'a, T>;
131    fn into_iter(self) -> Self::IntoIter {
132        self.data.iter_mut()
133    }
134}
135
136impl<T, C> FromIterator<T> for FormalPowerSeries<T, C> {
137    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
138        Self::from_vec(iter.into_iter().collect())
139    }
140}
141
142impl<T, C> Index<usize> for FormalPowerSeries<T, C> {
143    type Output = T;
144    fn index(&self, index: usize) -> &Self::Output {
145        &self.data[index]
146    }
147}
148impl<T, C> IndexMut<usize> for FormalPowerSeries<T, C> {
149    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
150        &mut self.data[index]
151    }
152}
153
154impl<T, C> From<T> for FormalPowerSeries<T, C> {
155    fn from(x: T) -> Self {
156        once(x).collect()
157    }
158}
159impl<T, C> From<Vec<T>> for FormalPowerSeries<T, C> {
160    fn from(data: Vec<T>) -> Self {
161        Self::from_vec(data)
162    }
163}
164
165impl<T, C> FormalPowerSeries<T, C>
166where
167    T: FormalPowerSeriesCoefficient,
168{
169    pub fn prefix_ref(&self, deg: usize) -> Self {
170        if deg < self.length() {
171            Self::from_vec(self.data[..deg].to_vec())
172        } else {
173            self.clone()
174        }
175    }
176    pub fn prefix(mut self, deg: usize) -> Self {
177        self.data.truncate(deg);
178        self
179    }
180    pub fn even(mut self) -> Self {
181        let mut keep = false;
182        self.data.retain(|_| {
183            keep = !keep;
184            keep
185        });
186        self
187    }
188    pub fn odd(mut self) -> Self {
189        let mut keep = true;
190        self.data.retain(|_| {
191            keep = !keep;
192            keep
193        });
194        self
195    }
196    pub fn diff(mut self) -> Self {
197        let mut c = T::one();
198        for x in self.iter_mut().skip(1) {
199            *x *= &c;
200            c += T::one();
201        }
202        if self.length() > 0 {
203            self.data.remove(0);
204        }
205        self
206    }
207    pub fn integral(mut self) -> Self {
208        let n = self.length();
209        self.data.insert(0, Zero::zero());
210        let mut fact = Vec::with_capacity(n + 1);
211        let mut c = T::one();
212        fact.push(c.clone());
213        for _ in 1..n {
214            fact.push(fact.last().cloned().unwrap() * c.clone());
215            c += T::one();
216        }
217        let mut invf = T::one() / (fact.last().cloned().unwrap() * c.clone());
218        for x in self.iter_mut().skip(1).rev() {
219            *x *= invf.clone() * fact.pop().unwrap();
220            invf *= c.clone();
221            c -= T::one();
222        }
223        self
224    }
225    pub fn parity_inversion(mut self) -> Self {
226        self.iter_mut()
227            .skip(1)
228            .step_by(2)
229            .for_each(|x| *x = -x.clone());
230        self
231    }
232    pub fn eval(&self, x: T) -> T {
233        let mut base = T::one();
234        let mut res = T::zero();
235        for a in self.iter() {
236            res += base.clone() * a.clone();
237            base *= x.clone();
238        }
239        res
240    }
241}
242
243impl<T, C> FormalPowerSeries<T, C>
244where
245    T: FormalPowerSeriesCoefficient,
246    C: ConvolveSteps<T = Vec<T>>,
247{
248    pub fn inv(&self, deg: usize) -> Self {
249        debug_assert!(!self[0].is_zero());
250        if self.data.iter().filter(|x| !x.is_zero()).count()
251            <= deg.next_power_of_two().trailing_zeros() as usize * 6
252        {
253            let pos: Vec<_> = self
254                .data
255                .iter()
256                .enumerate()
257                .skip(1)
258                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
259                .collect();
260            let mut f = Self::zeros(deg);
261            f[0] = T::one() / self[0].clone();
262            for i in 1..deg {
263                let mut tot = T::zero();
264                for &j in &pos {
265                    if j > i {
266                        break;
267                    }
268                    tot += self[j].clone() * &f[i - j];
269                }
270                f[i] = -tot * &f[0];
271            }
272            return f;
273        }
274        let mut f = Self::from(T::one() / self[0].clone());
275        let mut i = 1;
276        while i < deg {
277            let g = self.prefix_ref((i * 2).min(deg));
278            let h = f.clone();
279            let mut g = C::transform(g.data, 2 * i);
280            let h = C::transform(h.data, 2 * i);
281            C::multiply(&mut g, &h);
282            let mut g = Self::from_vec(C::inverse_transform(g, 2 * i));
283            g >>= i;
284            let mut g = C::transform(g.data, 2 * i);
285            C::multiply(&mut g, &h);
286            let g = Self::from_vec(C::inverse_transform(g, 2 * i));
287            f.data.extend((-g).into_iter().take(i));
288            i *= 2;
289        }
290        f.truncate(deg);
291        f
292    }
293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }
969    /// f(x) <- f(x + a)
970    pub fn taylor_shift(mut self, a: T) -> Self {
971        let f = T::memorized_factorial(self.length());
972        let n = self.length();
973        for i in 0..n {
974            self.data[i] *= T::memorized_fact(&f)[i].clone();
975        }
976        self.data.reverse();
977        let mut b = a.clone();
978        let mut g = Self::from_vec(T::memorized_inv_fact(&f)[..n].to_vec());
979        for i in 1..n {
980            g[i] *= b.clone();
981            b *= a.clone();
982        }
983        self *= g;
984        self.truncate(n);
985        self.data.reverse();
986        for i in 0..n {
987            self.data[i] *= T::memorized_inv_fact(&f)[i].clone();
988        }
989        self
990    }

More examples

Hide additional examples

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 200)

199    fn mul(self, rhs: Self) -> Self::Output {
200        Self::from_vec(C::convolve(self.data, rhs.data))
201    }

crates/library_checker/src/polynomial/exp_of_formal_power_series.rs (line 10)

6pub fn exp_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.exp(n);
12    iter_print!(writer, @it g.data);
13}

crates/library_checker/src/polynomial/inv_of_formal_power_series.rs (line 10)

6pub fn inv_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.inv(n);
12    iter_print!(writer, @it g.data);
13}

crates/library_checker/src/polynomial/log_of_formal_power_series.rs (line 10)

6pub fn log_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.log(n);
12    iter_print!(writer, @it g.data);
13}

crates/library_checker/src/polynomial/pow_of_formal_power_series.rs (line 10)

6pub fn pow_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, m, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.pow(m, n);
12    iter_print!(writer, @it g.data);
13}

Additional examples can be found in:

Source

pub fn length(&self) -> usize

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 15)

14    fn add_assign(&mut self, rhs: T) {
15        if self.length() == 0 {
16            self.data.push(T::zero());
17        }
18        self.data[0].add_assign(rhs);
19    }
20}
21impl<T, C> SubAssign<T> for FormalPowerSeries<T, C>
22where
23    T: FormalPowerSeriesCoefficient,
24{
25    fn sub_assign(&mut self, rhs: T) {
26        if self.length() == 0 {
27            self.data.push(T::zero());
28        }
29        self.data[0].sub_assign(rhs);
30        self.trim_tail_zeros();
31    }
32}
33impl<T, C> MulAssign<T> for FormalPowerSeries<T, C>
34where
35    T: FormalPowerSeriesCoefficient,
36{
37    fn mul_assign(&mut self, rhs: T) {
38        for x in self.iter_mut() {
39            x.mul_assign(&rhs);
40        }
41    }
42}
43impl<T, C> DivAssign<T> for FormalPowerSeries<T, C>
44where
45    T: FormalPowerSeriesCoefficient,
46{
47    fn div_assign(&mut self, rhs: T) {
48        let rinv = T::one() / rhs;
49        for x in self.iter_mut() {
50            x.mul_assign(&rinv);
51        }
52    }
53}
54macro_rules! impl_fps_single_binop {
55    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
56        impl<T, C> $imp_assign<&T> for FormalPowerSeries<T, C>
57        where
58            T: FormalPowerSeriesCoefficient,
59        {
60            fn $method_assign(&mut self, rhs: &T) {
61                $imp_assign::$method_assign(self, rhs.clone());
62            }
63        }
64        impl<T, C> $imp<T> for FormalPowerSeries<T, C>
65        where
66            T: FormalPowerSeriesCoefficient,
67        {
68            type Output = Self;
69            fn $method(mut self, rhs: T) -> Self::Output {
70                $imp_assign::$method_assign(&mut self, rhs);
71                self
72            }
73        }
74        impl<T, C> $imp<&T> for FormalPowerSeries<T, C>
75        where
76            T: FormalPowerSeriesCoefficient,
77        {
78            type Output = Self;
79            fn $method(mut self, rhs: &T) -> Self::Output {
80                $imp_assign::$method_assign(&mut self, rhs);
81                self
82            }
83        }
84        impl<T, C> $imp<T> for &FormalPowerSeries<T, C>
85        where
86            T: FormalPowerSeriesCoefficient,
87        {
88            type Output = FormalPowerSeries<T, C>;
89            fn $method(self, rhs: T) -> Self::Output {
90                $imp::$method(self.clone(), rhs)
91            }
92        }
93        impl<T, C> $imp<&T> for &FormalPowerSeries<T, C>
94        where
95            T: FormalPowerSeriesCoefficient,
96        {
97            type Output = FormalPowerSeries<T, C>;
98            fn $method(self, rhs: &T) -> Self::Output {
99                $imp::$method(self.clone(), rhs)
100            }
101        }
102    };
103}
104impl_fps_single_binop!(Add, add, AddAssign, add_assign);
105impl_fps_single_binop!(Sub, sub, SubAssign, sub_assign);
106impl_fps_single_binop!(Mul, mul, MulAssign, mul_assign);
107impl_fps_single_binop!(Div, div, DivAssign, div_assign);
108
109impl<T, C> AddAssign<&Self> for FormalPowerSeries<T, C>
110where
111    T: FormalPowerSeriesCoefficient,
112{
113    fn add_assign(&mut self, rhs: &Self) {
114        if self.length() < rhs.length() {
115            self.resize(rhs.length());
116        }
117        for (x, y) in self.iter_mut().zip(rhs.iter()) {
118            x.add_assign(y);
119        }
120    }
121}
122impl<T, C> SubAssign<&Self> for FormalPowerSeries<T, C>
123where
124    T: FormalPowerSeriesCoefficient,
125{
126    fn sub_assign(&mut self, rhs: &Self) {
127        if self.length() < rhs.length() {
128            self.resize(rhs.length());
129        }
130        for (x, y) in self.iter_mut().zip(rhs.iter()) {
131            x.sub_assign(y);
132        }
133        self.trim_tail_zeros();
134    }
135}
136
137macro_rules! impl_fps_binop_addsub {
138    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
139        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
140        where
141            T: FormalPowerSeriesCoefficient,
142        {
143            fn $method_assign(&mut self, rhs: Self) {
144                $imp_assign::$method_assign(self, &rhs);
145            }
146        }
147        impl<T, C> $imp for FormalPowerSeries<T, C>
148        where
149            T: FormalPowerSeriesCoefficient,
150        {
151            type Output = Self;
152            fn $method(mut self, rhs: Self) -> Self::Output {
153                $imp_assign::$method_assign(&mut self, &rhs);
154                self
155            }
156        }
157        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
158        where
159            T: FormalPowerSeriesCoefficient,
160        {
161            type Output = Self;
162            fn $method(mut self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
163                $imp_assign::$method_assign(&mut self, rhs);
164                self
165            }
166        }
167        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
168        where
169            T: FormalPowerSeriesCoefficient,
170        {
171            type Output = FormalPowerSeries<T, C>;
172            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
173                let mut self_ = self.clone();
174                $imp_assign::$method_assign(&mut self_, &rhs);
175                self_
176            }
177        }
178        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
179        where
180            T: FormalPowerSeriesCoefficient,
181        {
182            type Output = FormalPowerSeries<T, C>;
183            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
184                let mut self_ = self.clone();
185                $imp_assign::$method_assign(&mut self_, rhs);
186                self_
187            }
188        }
189    };
190}
191impl_fps_binop_addsub!(Add, add, AddAssign, add_assign);
192impl_fps_binop_addsub!(Sub, sub, SubAssign, sub_assign);
193
194impl<T, C> Mul for FormalPowerSeries<T, C>
195where
196    C: ConvolveSteps<T = Vec<T>>,
197{
198    type Output = Self;
199    fn mul(self, rhs: Self) -> Self::Output {
200        Self::from_vec(C::convolve(self.data, rhs.data))
201    }
202}
203impl<T, C> Div for FormalPowerSeries<T, C>
204where
205    T: FormalPowerSeriesCoefficient,
206    C: ConvolveSteps<T = Vec<T>>,
207{
208    type Output = Self;
209    fn div(mut self, mut rhs: Self) -> Self::Output {
210        self.trim_tail_zeros();
211        rhs.trim_tail_zeros();
212        if self.length() < rhs.length() {
213            return Self::zero();
214        }
215        self.data.reverse();
216        rhs.data.reverse();
217        let n = self.length() - rhs.length() + 1;
218        let mut res = self * rhs.inv(n);
219        res.truncate(n);
220        res.data.reverse();
221        res
222    }
223}
224impl<T, C> Rem for FormalPowerSeries<T, C>
225where
226    T: FormalPowerSeriesCoefficient,
227    C: ConvolveSteps<T = Vec<T>>,
228{
229    type Output = Self;
230    fn rem(self, rhs: Self) -> Self::Output {
231        let mut rem = self.clone() - self / rhs.clone() * rhs;
232        rem.trim_tail_zeros();
233        rem
234    }
235}
236
237impl<T, C> FormalPowerSeries<T, C>
238where
239    T: FormalPowerSeriesCoefficient,
240    C: ConvolveSteps<T = Vec<T>>,
241{
242    pub fn div_rem(self, rhs: Self) -> (Self, Self) {
243        let div = self.clone() / rhs.clone();
244        let mut rem = self - div.clone() * rhs;
245        rem.trim_tail_zeros();
246        (div, rem)
247    }
248}
249
250macro_rules! impl_fps_binop_conv {
251    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
252        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
253        where
254            T: FormalPowerSeriesCoefficient,
255            C: ConvolveSteps<T = Vec<T>>,
256        {
257            fn $method_assign(&mut self, rhs: Self) {
258                *self = $imp::$method(Self::from_vec(take(&mut self.data)), rhs);
259            }
260        }
261        impl<T, C> $imp_assign<&Self> for FormalPowerSeries<T, C>
262        where
263            T: FormalPowerSeriesCoefficient,
264            C: ConvolveSteps<T = Vec<T>>,
265        {
266            fn $method_assign(&mut self, rhs: &Self) {
267                $imp_assign::$method_assign(self, rhs.clone());
268            }
269        }
270        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
271        where
272            T: FormalPowerSeriesCoefficient,
273            C: ConvolveSteps<T = Vec<T>>,
274        {
275            type Output = Self;
276            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
277                $imp::$method(self, rhs.clone())
278            }
279        }
280        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
281        where
282            T: FormalPowerSeriesCoefficient,
283            C: ConvolveSteps<T = Vec<T>>,
284        {
285            type Output = FormalPowerSeries<T, C>;
286            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
287                $imp::$method(self.clone(), rhs)
288            }
289        }
290        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
291        where
292            T: FormalPowerSeriesCoefficient,
293            C: ConvolveSteps<T = Vec<T>>,
294        {
295            type Output = FormalPowerSeries<T, C>;
296            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
297                $imp::$method(self.clone(), rhs.clone())
298            }
299        }
300    };
301}
302impl_fps_binop_conv!(Mul, mul, MulAssign, mul_assign);
303impl_fps_binop_conv!(Div, div, DivAssign, div_assign);
304impl_fps_binop_conv!(Rem, rem, RemAssign, rem_assign);
305
306impl<T, C> Neg for FormalPowerSeries<T, C>
307where
308    T: FormalPowerSeriesCoefficient,
309{
310    type Output = Self;
311    fn neg(mut self) -> Self::Output {
312        for x in self.iter_mut() {
313            *x = -x.clone();
314        }
315        self
316    }
317}
318impl<T, C> Neg for &FormalPowerSeries<T, C>
319where
320    T: FormalPowerSeriesCoefficient,
321{
322    type Output = FormalPowerSeries<T, C>;
323    fn neg(self) -> Self::Output {
324        self.clone().neg()
325    }
326}
327
328impl<T, C> ShrAssign<usize> for FormalPowerSeries<T, C>
329where
330    T: FormalPowerSeriesCoefficient,
331{
332    fn shr_assign(&mut self, rhs: usize) {
333        if self.length() <= rhs {
334            *self = Self::zero();
335        } else {
336            for i in rhs..self.length() {
337                self[i - rhs] = self[i].clone();
338            }
339            self.truncate(self.length() - rhs);
340        }
341    }
342}
343impl<T, C> ShlAssign<usize> for FormalPowerSeries<T, C>
344where
345    T: FormalPowerSeriesCoefficient,
346{
347    fn shl_assign(&mut self, rhs: usize) {
348        let n = self.length();
349        self.resize(n + rhs);
350        for i in (0..n).rev() {
351            self[i + rhs] = self[i].clone();
352        }
353        for i in 0..rhs {
354            self[i] = T::zero();
355        }
356    }
357}
358
359impl<T, C> Shr<usize> for FormalPowerSeries<T, C>
360where
361    T: FormalPowerSeriesCoefficient,
362{
363    type Output = Self;
364    fn shr(mut self, rhs: usize) -> Self::Output {
365        self.shr_assign(rhs);
366        self
367    }
368}
369impl<T, C> Shl<usize> for FormalPowerSeries<T, C>
370where
371    T: FormalPowerSeriesCoefficient,
372{
373    type Output = Self;
374    fn shl(mut self, rhs: usize) -> Self::Output {
375        self.shl_assign(rhs);
376        self
377    }
378}
379impl<T, C> Shr<usize> for &FormalPowerSeries<T, C>
380where
381    T: FormalPowerSeriesCoefficient,
382{
383    type Output = FormalPowerSeries<T, C>;
384    fn shr(self, rhs: usize) -> Self::Output {
385        if self.length() <= rhs {
386            Self::Output::zero()
387        } else {
388            let mut f = Self::Output::zeros(self.length() - rhs);
389            for i in rhs..self.length() {
390                f[i - rhs] = self[i].clone();
391            }
392            f
393        }
394    }
395}
396impl<T, C> Shl<usize> for &FormalPowerSeries<T, C>
397where
398    T: FormalPowerSeriesCoefficient,
399{
400    type Output = FormalPowerSeries<T, C>;
401    fn shl(self, rhs: usize) -> Self::Output {
402        let mut f = Self::Output::zeros(self.length() + rhs);
403        for (i, x) in self.iter().cloned().enumerate().rev() {
404            f[i + rhs] = x;
405        }
406        f
407    }

More examples

Hide additional examples

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 85)

84    pub fn trim_tail_zeros(&mut self) {
85        let mut len = self.length();
86        while len > 0 {
87            if self.data[len - 1].is_zero() {
88                len -= 1;
89            } else {
90                break;
91            }
92        }
93        self.truncate(len);
94    }
95}
96
97impl<T, C> Zero for FormalPowerSeries<T, C>
98where
99    T: PartialEq,
100{
101    fn zero() -> Self {
102        Self::from_vec(Vec::new())
103    }
104}
105impl<T, C> One for FormalPowerSeries<T, C>
106where
107    T: PartialEq + One,
108{
109    fn one() -> Self {
110        Self::from(T::one())
111    }
112}
113
114impl<T, C> IntoIterator for FormalPowerSeries<T, C> {
115    type Item = T;
116    type IntoIter = std::vec::IntoIter<T>;
117    fn into_iter(self) -> Self::IntoIter {
118        self.data.into_iter()
119    }
120}
121impl<'a, T, C> IntoIterator for &'a FormalPowerSeries<T, C> {
122    type Item = &'a T;
123    type IntoIter = Iter<'a, T>;
124    fn into_iter(self) -> Self::IntoIter {
125        self.data.iter()
126    }
127}
128impl<'a, T, C> IntoIterator for &'a mut FormalPowerSeries<T, C> {
129    type Item = &'a mut T;
130    type IntoIter = IterMut<'a, T>;
131    fn into_iter(self) -> Self::IntoIter {
132        self.data.iter_mut()
133    }
134}
135
136impl<T, C> FromIterator<T> for FormalPowerSeries<T, C> {
137    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
138        Self::from_vec(iter.into_iter().collect())
139    }
140}
141
142impl<T, C> Index<usize> for FormalPowerSeries<T, C> {
143    type Output = T;
144    fn index(&self, index: usize) -> &Self::Output {
145        &self.data[index]
146    }
147}
148impl<T, C> IndexMut<usize> for FormalPowerSeries<T, C> {
149    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
150        &mut self.data[index]
151    }
152}
153
154impl<T, C> From<T> for FormalPowerSeries<T, C> {
155    fn from(x: T) -> Self {
156        once(x).collect()
157    }
158}
159impl<T, C> From<Vec<T>> for FormalPowerSeries<T, C> {
160    fn from(data: Vec<T>) -> Self {
161        Self::from_vec(data)
162    }
163}
164
165impl<T, C> FormalPowerSeries<T, C>
166where
167    T: FormalPowerSeriesCoefficient,
168{
169    pub fn prefix_ref(&self, deg: usize) -> Self {
170        if deg < self.length() {
171            Self::from_vec(self.data[..deg].to_vec())
172        } else {
173            self.clone()
174        }
175    }
176    pub fn prefix(mut self, deg: usize) -> Self {
177        self.data.truncate(deg);
178        self
179    }
180    pub fn even(mut self) -> Self {
181        let mut keep = false;
182        self.data.retain(|_| {
183            keep = !keep;
184            keep
185        });
186        self
187    }
188    pub fn odd(mut self) -> Self {
189        let mut keep = true;
190        self.data.retain(|_| {
191            keep = !keep;
192            keep
193        });
194        self
195    }
196    pub fn diff(mut self) -> Self {
197        let mut c = T::one();
198        for x in self.iter_mut().skip(1) {
199            *x *= &c;
200            c += T::one();
201        }
202        if self.length() > 0 {
203            self.data.remove(0);
204        }
205        self
206    }
207    pub fn integral(mut self) -> Self {
208        let n = self.length();
209        self.data.insert(0, Zero::zero());
210        let mut fact = Vec::with_capacity(n + 1);
211        let mut c = T::one();
212        fact.push(c.clone());
213        for _ in 1..n {
214            fact.push(fact.last().cloned().unwrap() * c.clone());
215            c += T::one();
216        }
217        let mut invf = T::one() / (fact.last().cloned().unwrap() * c.clone());
218        for x in self.iter_mut().skip(1).rev() {
219            *x *= invf.clone() * fact.pop().unwrap();
220            invf *= c.clone();
221            c -= T::one();
222        }
223        self
224    }
225    pub fn parity_inversion(mut self) -> Self {
226        self.iter_mut()
227            .skip(1)
228            .step_by(2)
229            .for_each(|x| *x = -x.clone());
230        self
231    }
232    pub fn eval(&self, x: T) -> T {
233        let mut base = T::one();
234        let mut res = T::zero();
235        for a in self.iter() {
236            res += base.clone() * a.clone();
237            base *= x.clone();
238        }
239        res
240    }
241}
242
243impl<T, C> FormalPowerSeries<T, C>
244where
245    T: FormalPowerSeriesCoefficient,
246    C: ConvolveSteps<T = Vec<T>>,
247{
248    pub fn inv(&self, deg: usize) -> Self {
249        debug_assert!(!self[0].is_zero());
250        if self.data.iter().filter(|x| !x.is_zero()).count()
251            <= deg.next_power_of_two().trailing_zeros() as usize * 6
252        {
253            let pos: Vec<_> = self
254                .data
255                .iter()
256                .enumerate()
257                .skip(1)
258                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
259                .collect();
260            let mut f = Self::zeros(deg);
261            f[0] = T::one() / self[0].clone();
262            for i in 1..deg {
263                let mut tot = T::zero();
264                for &j in &pos {
265                    if j > i {
266                        break;
267                    }
268                    tot += self[j].clone() * &f[i - j];
269                }
270                f[i] = -tot * &f[0];
271            }
272            return f;
273        }
274        let mut f = Self::from(T::one() / self[0].clone());
275        let mut i = 1;
276        while i < deg {
277            let g = self.prefix_ref((i * 2).min(deg));
278            let h = f.clone();
279            let mut g = C::transform(g.data, 2 * i);
280            let h = C::transform(h.data, 2 * i);
281            C::multiply(&mut g, &h);
282            let mut g = Self::from_vec(C::inverse_transform(g, 2 * i));
283            g >>= i;
284            let mut g = C::transform(g.data, 2 * i);
285            C::multiply(&mut g, &h);
286            let g = Self::from_vec(C::inverse_transform(g, 2 * i));
287            f.data.extend((-g).into_iter().take(i));
288            i *= 2;
289        }
290        f.truncate(deg);
291        f
292    }
293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }
969    /// f(x) <- f(x + a)
970    pub fn taylor_shift(mut self, a: T) -> Self {
971        let f = T::memorized_factorial(self.length());
972        let n = self.length();
973        for i in 0..n {
974            self.data[i] *= T::memorized_fact(&f)[i].clone();
975        }
976        self.data.reverse();
977        let mut b = a.clone();
978        let mut g = Self::from_vec(T::memorized_inv_fact(&f)[..n].to_vec());
979        for i in 1..n {
980            g[i] *= b.clone();
981            b *= a.clone();
982        }
983        self *= g;
984        self.truncate(n);
985        self.data.reverse();
986        for i in 0..n {
987            self.data[i] *= T::memorized_inv_fact(&f)[i].clone();
988        }
989        self
990    }

crates/library_checker/src/polynomial/division_of_polynomials.rs (line 13)

6pub fn division_of_polynomials(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, m, f: [MInt998244353; n], g: [MInt998244353; m]);
10    let f = Fps998244353::from_vec(f);
11    let g = Fps998244353::from_vec(g);
12    let (q, r) = f.div_rem(g);
13    writeln!(writer, "{} {}", q.length(), r.length()).ok();
14    iter_print!(writer, @it q.data);
15    iter_print!(writer, @it r.data);
16}

Source

pub fn truncate(&mut self, deg: usize)

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 93)

84    pub fn trim_tail_zeros(&mut self) {
85        let mut len = self.length();
86        while len > 0 {
87            if self.data[len - 1].is_zero() {
88                len -= 1;
89            } else {
90                break;
91            }
92        }
93        self.truncate(len);
94    }
95}
96
97impl<T, C> Zero for FormalPowerSeries<T, C>
98where
99    T: PartialEq,
100{
101    fn zero() -> Self {
102        Self::from_vec(Vec::new())
103    }
104}
105impl<T, C> One for FormalPowerSeries<T, C>
106where
107    T: PartialEq + One,
108{
109    fn one() -> Self {
110        Self::from(T::one())
111    }
112}
113
114impl<T, C> IntoIterator for FormalPowerSeries<T, C> {
115    type Item = T;
116    type IntoIter = std::vec::IntoIter<T>;
117    fn into_iter(self) -> Self::IntoIter {
118        self.data.into_iter()
119    }
120}
121impl<'a, T, C> IntoIterator for &'a FormalPowerSeries<T, C> {
122    type Item = &'a T;
123    type IntoIter = Iter<'a, T>;
124    fn into_iter(self) -> Self::IntoIter {
125        self.data.iter()
126    }
127}
128impl<'a, T, C> IntoIterator for &'a mut FormalPowerSeries<T, C> {
129    type Item = &'a mut T;
130    type IntoIter = IterMut<'a, T>;
131    fn into_iter(self) -> Self::IntoIter {
132        self.data.iter_mut()
133    }
134}
135
136impl<T, C> FromIterator<T> for FormalPowerSeries<T, C> {
137    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
138        Self::from_vec(iter.into_iter().collect())
139    }
140}
141
142impl<T, C> Index<usize> for FormalPowerSeries<T, C> {
143    type Output = T;
144    fn index(&self, index: usize) -> &Self::Output {
145        &self.data[index]
146    }
147}
148impl<T, C> IndexMut<usize> for FormalPowerSeries<T, C> {
149    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
150        &mut self.data[index]
151    }
152}
153
154impl<T, C> From<T> for FormalPowerSeries<T, C> {
155    fn from(x: T) -> Self {
156        once(x).collect()
157    }
158}
159impl<T, C> From<Vec<T>> for FormalPowerSeries<T, C> {
160    fn from(data: Vec<T>) -> Self {
161        Self::from_vec(data)
162    }
163}
164
165impl<T, C> FormalPowerSeries<T, C>
166where
167    T: FormalPowerSeriesCoefficient,
168{
169    pub fn prefix_ref(&self, deg: usize) -> Self {
170        if deg < self.length() {
171            Self::from_vec(self.data[..deg].to_vec())
172        } else {
173            self.clone()
174        }
175    }
176    pub fn prefix(mut self, deg: usize) -> Self {
177        self.data.truncate(deg);
178        self
179    }
180    pub fn even(mut self) -> Self {
181        let mut keep = false;
182        self.data.retain(|_| {
183            keep = !keep;
184            keep
185        });
186        self
187    }
188    pub fn odd(mut self) -> Self {
189        let mut keep = true;
190        self.data.retain(|_| {
191            keep = !keep;
192            keep
193        });
194        self
195    }
196    pub fn diff(mut self) -> Self {
197        let mut c = T::one();
198        for x in self.iter_mut().skip(1) {
199            *x *= &c;
200            c += T::one();
201        }
202        if self.length() > 0 {
203            self.data.remove(0);
204        }
205        self
206    }
207    pub fn integral(mut self) -> Self {
208        let n = self.length();
209        self.data.insert(0, Zero::zero());
210        let mut fact = Vec::with_capacity(n + 1);
211        let mut c = T::one();
212        fact.push(c.clone());
213        for _ in 1..n {
214            fact.push(fact.last().cloned().unwrap() * c.clone());
215            c += T::one();
216        }
217        let mut invf = T::one() / (fact.last().cloned().unwrap() * c.clone());
218        for x in self.iter_mut().skip(1).rev() {
219            *x *= invf.clone() * fact.pop().unwrap();
220            invf *= c.clone();
221            c -= T::one();
222        }
223        self
224    }
225    pub fn parity_inversion(mut self) -> Self {
226        self.iter_mut()
227            .skip(1)
228            .step_by(2)
229            .for_each(|x| *x = -x.clone());
230        self
231    }
232    pub fn eval(&self, x: T) -> T {
233        let mut base = T::one();
234        let mut res = T::zero();
235        for a in self.iter() {
236            res += base.clone() * a.clone();
237            base *= x.clone();
238        }
239        res
240    }
241}
242
243impl<T, C> FormalPowerSeries<T, C>
244where
245    T: FormalPowerSeriesCoefficient,
246    C: ConvolveSteps<T = Vec<T>>,
247{
248    pub fn inv(&self, deg: usize) -> Self {
249        debug_assert!(!self[0].is_zero());
250        if self.data.iter().filter(|x| !x.is_zero()).count()
251            <= deg.next_power_of_two().trailing_zeros() as usize * 6
252        {
253            let pos: Vec<_> = self
254                .data
255                .iter()
256                .enumerate()
257                .skip(1)
258                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
259                .collect();
260            let mut f = Self::zeros(deg);
261            f[0] = T::one() / self[0].clone();
262            for i in 1..deg {
263                let mut tot = T::zero();
264                for &j in &pos {
265                    if j > i {
266                        break;
267                    }
268                    tot += self[j].clone() * &f[i - j];
269                }
270                f[i] = -tot * &f[0];
271            }
272            return f;
273        }
274        let mut f = Self::from(T::one() / self[0].clone());
275        let mut i = 1;
276        while i < deg {
277            let g = self.prefix_ref((i * 2).min(deg));
278            let h = f.clone();
279            let mut g = C::transform(g.data, 2 * i);
280            let h = C::transform(h.data, 2 * i);
281            C::multiply(&mut g, &h);
282            let mut g = Self::from_vec(C::inverse_transform(g, 2 * i));
283            g >>= i;
284            let mut g = C::transform(g.data, 2 * i);
285            C::multiply(&mut g, &h);
286            let g = Self::from_vec(C::inverse_transform(g, 2 * i));
287            f.data.extend((-g).into_iter().take(i));
288            i *= 2;
289        }
290        f.truncate(deg);
291        f
292    }
293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }
969    /// f(x) <- f(x + a)
970    pub fn taylor_shift(mut self, a: T) -> Self {
971        let f = T::memorized_factorial(self.length());
972        let n = self.length();
973        for i in 0..n {
974            self.data[i] *= T::memorized_fact(&f)[i].clone();
975        }
976        self.data.reverse();
977        let mut b = a.clone();
978        let mut g = Self::from_vec(T::memorized_inv_fact(&f)[..n].to_vec());
979        for i in 1..n {
980            g[i] *= b.clone();
981            b *= a.clone();
982        }
983        self *= g;
984        self.truncate(n);
985        self.data.reverse();
986        for i in 0..n {
987            self.data[i] *= T::memorized_inv_fact(&f)[i].clone();
988        }
989        self
990    }

More examples

Hide additional examples

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 219)

209    fn div(mut self, mut rhs: Self) -> Self::Output {
210        self.trim_tail_zeros();
211        rhs.trim_tail_zeros();
212        if self.length() < rhs.length() {
213            return Self::zero();
214        }
215        self.data.reverse();
216        rhs.data.reverse();
217        let n = self.length() - rhs.length() + 1;
218        let mut res = self * rhs.inv(n);
219        res.truncate(n);
220        res.data.reverse();
221        res
222    }
223}
224impl<T, C> Rem for FormalPowerSeries<T, C>
225where
226    T: FormalPowerSeriesCoefficient,
227    C: ConvolveSteps<T = Vec<T>>,
228{
229    type Output = Self;
230    fn rem(self, rhs: Self) -> Self::Output {
231        let mut rem = self.clone() - self / rhs.clone() * rhs;
232        rem.trim_tail_zeros();
233        rem
234    }
235}
236
237impl<T, C> FormalPowerSeries<T, C>
238where
239    T: FormalPowerSeriesCoefficient,
240    C: ConvolveSteps<T = Vec<T>>,
241{
242    pub fn div_rem(self, rhs: Self) -> (Self, Self) {
243        let div = self.clone() / rhs.clone();
244        let mut rem = self - div.clone() * rhs;
245        rem.trim_tail_zeros();
246        (div, rem)
247    }
248}
249
250macro_rules! impl_fps_binop_conv {
251    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
252        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
253        where
254            T: FormalPowerSeriesCoefficient,
255            C: ConvolveSteps<T = Vec<T>>,
256        {
257            fn $method_assign(&mut self, rhs: Self) {
258                *self = $imp::$method(Self::from_vec(take(&mut self.data)), rhs);
259            }
260        }
261        impl<T, C> $imp_assign<&Self> for FormalPowerSeries<T, C>
262        where
263            T: FormalPowerSeriesCoefficient,
264            C: ConvolveSteps<T = Vec<T>>,
265        {
266            fn $method_assign(&mut self, rhs: &Self) {
267                $imp_assign::$method_assign(self, rhs.clone());
268            }
269        }
270        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
271        where
272            T: FormalPowerSeriesCoefficient,
273            C: ConvolveSteps<T = Vec<T>>,
274        {
275            type Output = Self;
276            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
277                $imp::$method(self, rhs.clone())
278            }
279        }
280        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
281        where
282            T: FormalPowerSeriesCoefficient,
283            C: ConvolveSteps<T = Vec<T>>,
284        {
285            type Output = FormalPowerSeries<T, C>;
286            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
287                $imp::$method(self.clone(), rhs)
288            }
289        }
290        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
291        where
292            T: FormalPowerSeriesCoefficient,
293            C: ConvolveSteps<T = Vec<T>>,
294        {
295            type Output = FormalPowerSeries<T, C>;
296            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
297                $imp::$method(self.clone(), rhs.clone())
298            }
299        }
300    };
301}
302impl_fps_binop_conv!(Mul, mul, MulAssign, mul_assign);
303impl_fps_binop_conv!(Div, div, DivAssign, div_assign);
304impl_fps_binop_conv!(Rem, rem, RemAssign, rem_assign);
305
306impl<T, C> Neg for FormalPowerSeries<T, C>
307where
308    T: FormalPowerSeriesCoefficient,
309{
310    type Output = Self;
311    fn neg(mut self) -> Self::Output {
312        for x in self.iter_mut() {
313            *x = -x.clone();
314        }
315        self
316    }
317}
318impl<T, C> Neg for &FormalPowerSeries<T, C>
319where
320    T: FormalPowerSeriesCoefficient,
321{
322    type Output = FormalPowerSeries<T, C>;
323    fn neg(self) -> Self::Output {
324        self.clone().neg()
325    }
326}
327
328impl<T, C> ShrAssign<usize> for FormalPowerSeries<T, C>
329where
330    T: FormalPowerSeriesCoefficient,
331{
332    fn shr_assign(&mut self, rhs: usize) {
333        if self.length() <= rhs {
334            *self = Self::zero();
335        } else {
336            for i in rhs..self.length() {
337                self[i - rhs] = self[i].clone();
338            }
339            self.truncate(self.length() - rhs);
340        }
341    }

Source

pub fn iter(&self) -> Iter<'_, T>

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 117)

113    fn add_assign(&mut self, rhs: &Self) {
114        if self.length() < rhs.length() {
115            self.resize(rhs.length());
116        }
117        for (x, y) in self.iter_mut().zip(rhs.iter()) {
118            x.add_assign(y);
119        }
120    }
121}
122impl<T, C> SubAssign<&Self> for FormalPowerSeries<T, C>
123where
124    T: FormalPowerSeriesCoefficient,
125{
126    fn sub_assign(&mut self, rhs: &Self) {
127        if self.length() < rhs.length() {
128            self.resize(rhs.length());
129        }
130        for (x, y) in self.iter_mut().zip(rhs.iter()) {
131            x.sub_assign(y);
132        }
133        self.trim_tail_zeros();
134    }
135}
136
137macro_rules! impl_fps_binop_addsub {
138    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
139        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
140        where
141            T: FormalPowerSeriesCoefficient,
142        {
143            fn $method_assign(&mut self, rhs: Self) {
144                $imp_assign::$method_assign(self, &rhs);
145            }
146        }
147        impl<T, C> $imp for FormalPowerSeries<T, C>
148        where
149            T: FormalPowerSeriesCoefficient,
150        {
151            type Output = Self;
152            fn $method(mut self, rhs: Self) -> Self::Output {
153                $imp_assign::$method_assign(&mut self, &rhs);
154                self
155            }
156        }
157        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
158        where
159            T: FormalPowerSeriesCoefficient,
160        {
161            type Output = Self;
162            fn $method(mut self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
163                $imp_assign::$method_assign(&mut self, rhs);
164                self
165            }
166        }
167        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
168        where
169            T: FormalPowerSeriesCoefficient,
170        {
171            type Output = FormalPowerSeries<T, C>;
172            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
173                let mut self_ = self.clone();
174                $imp_assign::$method_assign(&mut self_, &rhs);
175                self_
176            }
177        }
178        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
179        where
180            T: FormalPowerSeriesCoefficient,
181        {
182            type Output = FormalPowerSeries<T, C>;
183            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
184                let mut self_ = self.clone();
185                $imp_assign::$method_assign(&mut self_, rhs);
186                self_
187            }
188        }
189    };
190}
191impl_fps_binop_addsub!(Add, add, AddAssign, add_assign);
192impl_fps_binop_addsub!(Sub, sub, SubAssign, sub_assign);
193
194impl<T, C> Mul for FormalPowerSeries<T, C>
195where
196    C: ConvolveSteps<T = Vec<T>>,
197{
198    type Output = Self;
199    fn mul(self, rhs: Self) -> Self::Output {
200        Self::from_vec(C::convolve(self.data, rhs.data))
201    }
202}
203impl<T, C> Div for FormalPowerSeries<T, C>
204where
205    T: FormalPowerSeriesCoefficient,
206    C: ConvolveSteps<T = Vec<T>>,
207{
208    type Output = Self;
209    fn div(mut self, mut rhs: Self) -> Self::Output {
210        self.trim_tail_zeros();
211        rhs.trim_tail_zeros();
212        if self.length() < rhs.length() {
213            return Self::zero();
214        }
215        self.data.reverse();
216        rhs.data.reverse();
217        let n = self.length() - rhs.length() + 1;
218        let mut res = self * rhs.inv(n);
219        res.truncate(n);
220        res.data.reverse();
221        res
222    }
223}
224impl<T, C> Rem for FormalPowerSeries<T, C>
225where
226    T: FormalPowerSeriesCoefficient,
227    C: ConvolveSteps<T = Vec<T>>,
228{
229    type Output = Self;
230    fn rem(self, rhs: Self) -> Self::Output {
231        let mut rem = self.clone() - self / rhs.clone() * rhs;
232        rem.trim_tail_zeros();
233        rem
234    }
235}
236
237impl<T, C> FormalPowerSeries<T, C>
238where
239    T: FormalPowerSeriesCoefficient,
240    C: ConvolveSteps<T = Vec<T>>,
241{
242    pub fn div_rem(self, rhs: Self) -> (Self, Self) {
243        let div = self.clone() / rhs.clone();
244        let mut rem = self - div.clone() * rhs;
245        rem.trim_tail_zeros();
246        (div, rem)
247    }
248}
249
250macro_rules! impl_fps_binop_conv {
251    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
252        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
253        where
254            T: FormalPowerSeriesCoefficient,
255            C: ConvolveSteps<T = Vec<T>>,
256        {
257            fn $method_assign(&mut self, rhs: Self) {
258                *self = $imp::$method(Self::from_vec(take(&mut self.data)), rhs);
259            }
260        }
261        impl<T, C> $imp_assign<&Self> for FormalPowerSeries<T, C>
262        where
263            T: FormalPowerSeriesCoefficient,
264            C: ConvolveSteps<T = Vec<T>>,
265        {
266            fn $method_assign(&mut self, rhs: &Self) {
267                $imp_assign::$method_assign(self, rhs.clone());
268            }
269        }
270        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
271        where
272            T: FormalPowerSeriesCoefficient,
273            C: ConvolveSteps<T = Vec<T>>,
274        {
275            type Output = Self;
276            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
277                $imp::$method(self, rhs.clone())
278            }
279        }
280        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
281        where
282            T: FormalPowerSeriesCoefficient,
283            C: ConvolveSteps<T = Vec<T>>,
284        {
285            type Output = FormalPowerSeries<T, C>;
286            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
287                $imp::$method(self.clone(), rhs)
288            }
289        }
290        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
291        where
292            T: FormalPowerSeriesCoefficient,
293            C: ConvolveSteps<T = Vec<T>>,
294        {
295            type Output = FormalPowerSeries<T, C>;
296            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
297                $imp::$method(self.clone(), rhs.clone())
298            }
299        }
300    };
301}
302impl_fps_binop_conv!(Mul, mul, MulAssign, mul_assign);
303impl_fps_binop_conv!(Div, div, DivAssign, div_assign);
304impl_fps_binop_conv!(Rem, rem, RemAssign, rem_assign);
305
306impl<T, C> Neg for FormalPowerSeries<T, C>
307where
308    T: FormalPowerSeriesCoefficient,
309{
310    type Output = Self;
311    fn neg(mut self) -> Self::Output {
312        for x in self.iter_mut() {
313            *x = -x.clone();
314        }
315        self
316    }
317}
318impl<T, C> Neg for &FormalPowerSeries<T, C>
319where
320    T: FormalPowerSeriesCoefficient,
321{
322    type Output = FormalPowerSeries<T, C>;
323    fn neg(self) -> Self::Output {
324        self.clone().neg()
325    }
326}
327
328impl<T, C> ShrAssign<usize> for FormalPowerSeries<T, C>
329where
330    T: FormalPowerSeriesCoefficient,
331{
332    fn shr_assign(&mut self, rhs: usize) {
333        if self.length() <= rhs {
334            *self = Self::zero();
335        } else {
336            for i in rhs..self.length() {
337                self[i - rhs] = self[i].clone();
338            }
339            self.truncate(self.length() - rhs);
340        }
341    }
342}
343impl<T, C> ShlAssign<usize> for FormalPowerSeries<T, C>
344where
345    T: FormalPowerSeriesCoefficient,
346{
347    fn shl_assign(&mut self, rhs: usize) {
348        let n = self.length();
349        self.resize(n + rhs);
350        for i in (0..n).rev() {
351            self[i + rhs] = self[i].clone();
352        }
353        for i in 0..rhs {
354            self[i] = T::zero();
355        }
356    }
357}
358
359impl<T, C> Shr<usize> for FormalPowerSeries<T, C>
360where
361    T: FormalPowerSeriesCoefficient,
362{
363    type Output = Self;
364    fn shr(mut self, rhs: usize) -> Self::Output {
365        self.shr_assign(rhs);
366        self
367    }
368}
369impl<T, C> Shl<usize> for FormalPowerSeries<T, C>
370where
371    T: FormalPowerSeriesCoefficient,
372{
373    type Output = Self;
374    fn shl(mut self, rhs: usize) -> Self::Output {
375        self.shl_assign(rhs);
376        self
377    }
378}
379impl<T, C> Shr<usize> for &FormalPowerSeries<T, C>
380where
381    T: FormalPowerSeriesCoefficient,
382{
383    type Output = FormalPowerSeries<T, C>;
384    fn shr(self, rhs: usize) -> Self::Output {
385        if self.length() <= rhs {
386            Self::Output::zero()
387        } else {
388            let mut f = Self::Output::zeros(self.length() - rhs);
389            for i in rhs..self.length() {
390                f[i - rhs] = self[i].clone();
391            }
392            f
393        }
394    }
395}
396impl<T, C> Shl<usize> for &FormalPowerSeries<T, C>
397where
398    T: FormalPowerSeriesCoefficient,
399{
400    type Output = FormalPowerSeries<T, C>;
401    fn shl(self, rhs: usize) -> Self::Output {
402        let mut f = Self::Output::zeros(self.length() + rhs);
403        for (i, x) in self.iter().cloned().enumerate().rev() {
404            f[i + rhs] = x;
405        }
406        f
407    }

More examples

Hide additional examples

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 235)

232    pub fn eval(&self, x: T) -> T {
233        let mut base = T::one();
234        let mut res = T::zero();
235        for a in self.iter() {
236            res += base.clone() * a.clone();
237            base *= x.clone();
238        }
239        res
240    }
241}
242
243impl<T, C> FormalPowerSeries<T, C>
244where
245    T: FormalPowerSeriesCoefficient,
246    C: ConvolveSteps<T = Vec<T>>,
247{
248    pub fn inv(&self, deg: usize) -> Self {
249        debug_assert!(!self[0].is_zero());
250        if self.data.iter().filter(|x| !x.is_zero()).count()
251            <= deg.next_power_of_two().trailing_zeros() as usize * 6
252        {
253            let pos: Vec<_> = self
254                .data
255                .iter()
256                .enumerate()
257                .skip(1)
258                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
259                .collect();
260            let mut f = Self::zeros(deg);
261            f[0] = T::one() / self[0].clone();
262            for i in 1..deg {
263                let mut tot = T::zero();
264                for &j in &pos {
265                    if j > i {
266                        break;
267                    }
268                    tot += self[j].clone() * &f[i - j];
269                }
270                f[i] = -tot * &f[0];
271            }
272            return f;
273        }
274        let mut f = Self::from(T::one() / self[0].clone());
275        let mut i = 1;
276        while i < deg {
277            let g = self.prefix_ref((i * 2).min(deg));
278            let h = f.clone();
279            let mut g = C::transform(g.data, 2 * i);
280            let h = C::transform(h.data, 2 * i);
281            C::multiply(&mut g, &h);
282            let mut g = Self::from_vec(C::inverse_transform(g, 2 * i));
283            g >>= i;
284            let mut g = C::transform(g.data, 2 * i);
285            C::multiply(&mut g, &h);
286            let g = Self::from_vec(C::inverse_transform(g, 2 * i));
287            f.data.extend((-g).into_iter().take(i));
288            i *= 2;
289        }
290        f.truncate(deg);
291        f
292    }
293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }

Source

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 38)

37    fn mul_assign(&mut self, rhs: T) {
38        for x in self.iter_mut() {
39            x.mul_assign(&rhs);
40        }
41    }
42}
43impl<T, C> DivAssign<T> for FormalPowerSeries<T, C>
44where
45    T: FormalPowerSeriesCoefficient,
46{
47    fn div_assign(&mut self, rhs: T) {
48        let rinv = T::one() / rhs;
49        for x in self.iter_mut() {
50            x.mul_assign(&rinv);
51        }
52    }
53}
54macro_rules! impl_fps_single_binop {
55    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
56        impl<T, C> $imp_assign<&T> for FormalPowerSeries<T, C>
57        where
58            T: FormalPowerSeriesCoefficient,
59        {
60            fn $method_assign(&mut self, rhs: &T) {
61                $imp_assign::$method_assign(self, rhs.clone());
62            }
63        }
64        impl<T, C> $imp<T> for FormalPowerSeries<T, C>
65        where
66            T: FormalPowerSeriesCoefficient,
67        {
68            type Output = Self;
69            fn $method(mut self, rhs: T) -> Self::Output {
70                $imp_assign::$method_assign(&mut self, rhs);
71                self
72            }
73        }
74        impl<T, C> $imp<&T> for FormalPowerSeries<T, C>
75        where
76            T: FormalPowerSeriesCoefficient,
77        {
78            type Output = Self;
79            fn $method(mut self, rhs: &T) -> Self::Output {
80                $imp_assign::$method_assign(&mut self, rhs);
81                self
82            }
83        }
84        impl<T, C> $imp<T> for &FormalPowerSeries<T, C>
85        where
86            T: FormalPowerSeriesCoefficient,
87        {
88            type Output = FormalPowerSeries<T, C>;
89            fn $method(self, rhs: T) -> Self::Output {
90                $imp::$method(self.clone(), rhs)
91            }
92        }
93        impl<T, C> $imp<&T> for &FormalPowerSeries<T, C>
94        where
95            T: FormalPowerSeriesCoefficient,
96        {
97            type Output = FormalPowerSeries<T, C>;
98            fn $method(self, rhs: &T) -> Self::Output {
99                $imp::$method(self.clone(), rhs)
100            }
101        }
102    };
103}
104impl_fps_single_binop!(Add, add, AddAssign, add_assign);
105impl_fps_single_binop!(Sub, sub, SubAssign, sub_assign);
106impl_fps_single_binop!(Mul, mul, MulAssign, mul_assign);
107impl_fps_single_binop!(Div, div, DivAssign, div_assign);
108
109impl<T, C> AddAssign<&Self> for FormalPowerSeries<T, C>
110where
111    T: FormalPowerSeriesCoefficient,
112{
113    fn add_assign(&mut self, rhs: &Self) {
114        if self.length() < rhs.length() {
115            self.resize(rhs.length());
116        }
117        for (x, y) in self.iter_mut().zip(rhs.iter()) {
118            x.add_assign(y);
119        }
120    }
121}
122impl<T, C> SubAssign<&Self> for FormalPowerSeries<T, C>
123where
124    T: FormalPowerSeriesCoefficient,
125{
126    fn sub_assign(&mut self, rhs: &Self) {
127        if self.length() < rhs.length() {
128            self.resize(rhs.length());
129        }
130        for (x, y) in self.iter_mut().zip(rhs.iter()) {
131            x.sub_assign(y);
132        }
133        self.trim_tail_zeros();
134    }
135}
136
137macro_rules! impl_fps_binop_addsub {
138    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
139        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
140        where
141            T: FormalPowerSeriesCoefficient,
142        {
143            fn $method_assign(&mut self, rhs: Self) {
144                $imp_assign::$method_assign(self, &rhs);
145            }
146        }
147        impl<T, C> $imp for FormalPowerSeries<T, C>
148        where
149            T: FormalPowerSeriesCoefficient,
150        {
151            type Output = Self;
152            fn $method(mut self, rhs: Self) -> Self::Output {
153                $imp_assign::$method_assign(&mut self, &rhs);
154                self
155            }
156        }
157        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
158        where
159            T: FormalPowerSeriesCoefficient,
160        {
161            type Output = Self;
162            fn $method(mut self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
163                $imp_assign::$method_assign(&mut self, rhs);
164                self
165            }
166        }
167        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
168        where
169            T: FormalPowerSeriesCoefficient,
170        {
171            type Output = FormalPowerSeries<T, C>;
172            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
173                let mut self_ = self.clone();
174                $imp_assign::$method_assign(&mut self_, &rhs);
175                self_
176            }
177        }
178        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
179        where
180            T: FormalPowerSeriesCoefficient,
181        {
182            type Output = FormalPowerSeries<T, C>;
183            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
184                let mut self_ = self.clone();
185                $imp_assign::$method_assign(&mut self_, rhs);
186                self_
187            }
188        }
189    };
190}
191impl_fps_binop_addsub!(Add, add, AddAssign, add_assign);
192impl_fps_binop_addsub!(Sub, sub, SubAssign, sub_assign);
193
194impl<T, C> Mul for FormalPowerSeries<T, C>
195where
196    C: ConvolveSteps<T = Vec<T>>,
197{
198    type Output = Self;
199    fn mul(self, rhs: Self) -> Self::Output {
200        Self::from_vec(C::convolve(self.data, rhs.data))
201    }
202}
203impl<T, C> Div for FormalPowerSeries<T, C>
204where
205    T: FormalPowerSeriesCoefficient,
206    C: ConvolveSteps<T = Vec<T>>,
207{
208    type Output = Self;
209    fn div(mut self, mut rhs: Self) -> Self::Output {
210        self.trim_tail_zeros();
211        rhs.trim_tail_zeros();
212        if self.length() < rhs.length() {
213            return Self::zero();
214        }
215        self.data.reverse();
216        rhs.data.reverse();
217        let n = self.length() - rhs.length() + 1;
218        let mut res = self * rhs.inv(n);
219        res.truncate(n);
220        res.data.reverse();
221        res
222    }
223}
224impl<T, C> Rem for FormalPowerSeries<T, C>
225where
226    T: FormalPowerSeriesCoefficient,
227    C: ConvolveSteps<T = Vec<T>>,
228{
229    type Output = Self;
230    fn rem(self, rhs: Self) -> Self::Output {
231        let mut rem = self.clone() - self / rhs.clone() * rhs;
232        rem.trim_tail_zeros();
233        rem
234    }
235}
236
237impl<T, C> FormalPowerSeries<T, C>
238where
239    T: FormalPowerSeriesCoefficient,
240    C: ConvolveSteps<T = Vec<T>>,
241{
242    pub fn div_rem(self, rhs: Self) -> (Self, Self) {
243        let div = self.clone() / rhs.clone();
244        let mut rem = self - div.clone() * rhs;
245        rem.trim_tail_zeros();
246        (div, rem)
247    }
248}
249
250macro_rules! impl_fps_binop_conv {
251    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
252        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
253        where
254            T: FormalPowerSeriesCoefficient,
255            C: ConvolveSteps<T = Vec<T>>,
256        {
257            fn $method_assign(&mut self, rhs: Self) {
258                *self = $imp::$method(Self::from_vec(take(&mut self.data)), rhs);
259            }
260        }
261        impl<T, C> $imp_assign<&Self> for FormalPowerSeries<T, C>
262        where
263            T: FormalPowerSeriesCoefficient,
264            C: ConvolveSteps<T = Vec<T>>,
265        {
266            fn $method_assign(&mut self, rhs: &Self) {
267                $imp_assign::$method_assign(self, rhs.clone());
268            }
269        }
270        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
271        where
272            T: FormalPowerSeriesCoefficient,
273            C: ConvolveSteps<T = Vec<T>>,
274        {
275            type Output = Self;
276            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
277                $imp::$method(self, rhs.clone())
278            }
279        }
280        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
281        where
282            T: FormalPowerSeriesCoefficient,
283            C: ConvolveSteps<T = Vec<T>>,
284        {
285            type Output = FormalPowerSeries<T, C>;
286            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
287                $imp::$method(self.clone(), rhs)
288            }
289        }
290        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
291        where
292            T: FormalPowerSeriesCoefficient,
293            C: ConvolveSteps<T = Vec<T>>,
294        {
295            type Output = FormalPowerSeries<T, C>;
296            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
297                $imp::$method(self.clone(), rhs.clone())
298            }
299        }
300    };
301}
302impl_fps_binop_conv!(Mul, mul, MulAssign, mul_assign);
303impl_fps_binop_conv!(Div, div, DivAssign, div_assign);
304impl_fps_binop_conv!(Rem, rem, RemAssign, rem_assign);
305
306impl<T, C> Neg for FormalPowerSeries<T, C>
307where
308    T: FormalPowerSeriesCoefficient,
309{
310    type Output = Self;
311    fn neg(mut self) -> Self::Output {
312        for x in self.iter_mut() {
313            *x = -x.clone();
314        }
315        self
316    }

More examples

Hide additional examples

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 198)

196    pub fn diff(mut self) -> Self {
197        let mut c = T::one();
198        for x in self.iter_mut().skip(1) {
199            *x *= &c;
200            c += T::one();
201        }
202        if self.length() > 0 {
203            self.data.remove(0);
204        }
205        self
206    }
207    pub fn integral(mut self) -> Self {
208        let n = self.length();
209        self.data.insert(0, Zero::zero());
210        let mut fact = Vec::with_capacity(n + 1);
211        let mut c = T::one();
212        fact.push(c.clone());
213        for _ in 1..n {
214            fact.push(fact.last().cloned().unwrap() * c.clone());
215            c += T::one();
216        }
217        let mut invf = T::one() / (fact.last().cloned().unwrap() * c.clone());
218        for x in self.iter_mut().skip(1).rev() {
219            *x *= invf.clone() * fact.pop().unwrap();
220            invf *= c.clone();
221            c -= T::one();
222        }
223        self
224    }
225    pub fn parity_inversion(mut self) -> Self {
226        self.iter_mut()
227            .skip(1)
228            .step_by(2)
229            .for_each(|x| *x = -x.clone());
230        self
231    }
232    pub fn eval(&self, x: T) -> T {
233        let mut base = T::one();
234        let mut res = T::zero();
235        for a in self.iter() {
236            res += base.clone() * a.clone();
237            base *= x.clone();
238        }
239        res
240    }
241}
242
243impl<T, C> FormalPowerSeries<T, C>
244where
245    T: FormalPowerSeriesCoefficient,
246    C: ConvolveSteps<T = Vec<T>>,
247{
248    pub fn inv(&self, deg: usize) -> Self {
249        debug_assert!(!self[0].is_zero());
250        if self.data.iter().filter(|x| !x.is_zero()).count()
251            <= deg.next_power_of_two().trailing_zeros() as usize * 6
252        {
253            let pos: Vec<_> = self
254                .data
255                .iter()
256                .enumerate()
257                .skip(1)
258                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
259                .collect();
260            let mut f = Self::zeros(deg);
261            f[0] = T::one() / self[0].clone();
262            for i in 1..deg {
263                let mut tot = T::zero();
264                for &j in &pos {
265                    if j > i {
266                        break;
267                    }
268                    tot += self[j].clone() * &f[i - j];
269                }
270                f[i] = -tot * &f[0];
271            }
272            return f;
273        }
274        let mut f = Self::from(T::one() / self[0].clone());
275        let mut i = 1;
276        while i < deg {
277            let g = self.prefix_ref((i * 2).min(deg));
278            let h = f.clone();
279            let mut g = C::transform(g.data, 2 * i);
280            let h = C::transform(h.data, 2 * i);
281            C::multiply(&mut g, &h);
282            let mut g = Self::from_vec(C::inverse_transform(g, 2 * i));
283            g >>= i;
284            let mut g = C::transform(g.data, 2 * i);
285            C::multiply(&mut g, &h);
286            let g = Self::from_vec(C::inverse_transform(g, 2 * i));
287            f.data.extend((-g).into_iter().take(i));
288            i *= 2;
289        }
290        f.truncate(deg);
291        f
292    }
293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }

Source §

impl<T, C> FormalPowerSeries<T, C>
where T: Zero,

Source

pub fn zeros(deg: usize) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 388)

384    fn shr(self, rhs: usize) -> Self::Output {
385        if self.length() <= rhs {
386            Self::Output::zero()
387        } else {
388            let mut f = Self::Output::zeros(self.length() - rhs);
389            for i in rhs..self.length() {
390                f[i - rhs] = self[i].clone();
391            }
392            f
393        }
394    }
395}
396impl<T, C> Shl<usize> for &FormalPowerSeries<T, C>
397where
398    T: FormalPowerSeriesCoefficient,
399{
400    type Output = FormalPowerSeries<T, C>;
401    fn shl(self, rhs: usize) -> Self::Output {
402        let mut f = Self::Output::zeros(self.length() + rhs);
403        for (i, x) in self.iter().cloned().enumerate().rev() {
404            f[i + rhs] = x;
405        }
406        f
407    }

More examples

Hide additional examples

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 260)

248    pub fn inv(&self, deg: usize) -> Self {
249        debug_assert!(!self[0].is_zero());
250        if self.data.iter().filter(|x| !x.is_zero()).count()
251            <= deg.next_power_of_two().trailing_zeros() as usize * 6
252        {
253            let pos: Vec<_> = self
254                .data
255                .iter()
256                .enumerate()
257                .skip(1)
258                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
259                .collect();
260            let mut f = Self::zeros(deg);
261            f[0] = T::one() / self[0].clone();
262            for i in 1..deg {
263                let mut tot = T::zero();
264                for &j in &pos {
265                    if j > i {
266                        break;
267                    }
268                    tot += self[j].clone() * &f[i - j];
269                }
270                f[i] = -tot * &f[0];
271            }
272            return f;
273        }
274        let mut f = Self::from(T::one() / self[0].clone());
275        let mut i = 1;
276        while i < deg {
277            let g = self.prefix_ref((i * 2).min(deg));
278            let h = f.clone();
279            let mut g = C::transform(g.data, 2 * i);
280            let h = C::transform(h.data, 2 * i);
281            C::multiply(&mut g, &h);
282            let mut g = Self::from_vec(C::inverse_transform(g, 2 * i));
283            g >>= i;
284            let mut g = C::transform(g.data, 2 * i);
285            C::multiply(&mut g, &h);
286            let g = Self::from_vec(C::inverse_transform(g, 2 * i));
287            f.data.extend((-g).into_iter().take(i));
288            i *= 2;
289        }
290        f.truncate(deg);
291        f
292    }
293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }

Source

pub fn resize(&mut self, deg: usize)

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 62)

61    pub fn resized(mut self, deg: usize) -> Self {
62        self.resize(deg);
63        self
64    }
65    pub fn reversed(mut self) -> Self {
66        self.data.reverse();
67        self
68    }
69}
70
71impl<T, C> FormalPowerSeries<T, C>
72where
73    T: Zero + Clone,
74{
75    pub fn coeff(&self, deg: usize) -> T {
76        self.data.get(deg).cloned().unwrap_or_else(T::zero)
77    }
78}
79
80impl<T, C> FormalPowerSeries<T, C>
81where
82    T: Zero + PartialEq,
83{
84    pub fn trim_tail_zeros(&mut self) {
85        let mut len = self.length();
86        while len > 0 {
87            if self.data[len - 1].is_zero() {
88                len -= 1;
89            } else {
90                break;
91            }
92        }
93        self.truncate(len);
94    }
95}
96
97impl<T, C> Zero for FormalPowerSeries<T, C>
98where
99    T: PartialEq,
100{
101    fn zero() -> Self {
102        Self::from_vec(Vec::new())
103    }
104}
105impl<T, C> One for FormalPowerSeries<T, C>
106where
107    T: PartialEq + One,
108{
109    fn one() -> Self {
110        Self::from(T::one())
111    }
112}
113
114impl<T, C> IntoIterator for FormalPowerSeries<T, C> {
115    type Item = T;
116    type IntoIter = std::vec::IntoIter<T>;
117    fn into_iter(self) -> Self::IntoIter {
118        self.data.into_iter()
119    }
120}
121impl<'a, T, C> IntoIterator for &'a FormalPowerSeries<T, C> {
122    type Item = &'a T;
123    type IntoIter = Iter<'a, T>;
124    fn into_iter(self) -> Self::IntoIter {
125        self.data.iter()
126    }
127}
128impl<'a, T, C> IntoIterator for &'a mut FormalPowerSeries<T, C> {
129    type Item = &'a mut T;
130    type IntoIter = IterMut<'a, T>;
131    fn into_iter(self) -> Self::IntoIter {
132        self.data.iter_mut()
133    }
134}
135
136impl<T, C> FromIterator<T> for FormalPowerSeries<T, C> {
137    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
138        Self::from_vec(iter.into_iter().collect())
139    }
140}
141
142impl<T, C> Index<usize> for FormalPowerSeries<T, C> {
143    type Output = T;
144    fn index(&self, index: usize) -> &Self::Output {
145        &self.data[index]
146    }
147}
148impl<T, C> IndexMut<usize> for FormalPowerSeries<T, C> {
149    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
150        &mut self.data[index]
151    }
152}
153
154impl<T, C> From<T> for FormalPowerSeries<T, C> {
155    fn from(x: T) -> Self {
156        once(x).collect()
157    }
158}
159impl<T, C> From<Vec<T>> for FormalPowerSeries<T, C> {
160    fn from(data: Vec<T>) -> Self {
161        Self::from_vec(data)
162    }
163}
164
165impl<T, C> FormalPowerSeries<T, C>
166where
167    T: FormalPowerSeriesCoefficient,
168{
169    pub fn prefix_ref(&self, deg: usize) -> Self {
170        if deg < self.length() {
171            Self::from_vec(self.data[..deg].to_vec())
172        } else {
173            self.clone()
174        }
175    }
176    pub fn prefix(mut self, deg: usize) -> Self {
177        self.data.truncate(deg);
178        self
179    }
180    pub fn even(mut self) -> Self {
181        let mut keep = false;
182        self.data.retain(|_| {
183            keep = !keep;
184            keep
185        });
186        self
187    }
188    pub fn odd(mut self) -> Self {
189        let mut keep = true;
190        self.data.retain(|_| {
191            keep = !keep;
192            keep
193        });
194        self
195    }
196    pub fn diff(mut self) -> Self {
197        let mut c = T::one();
198        for x in self.iter_mut().skip(1) {
199            *x *= &c;
200            c += T::one();
201        }
202        if self.length() > 0 {
203            self.data.remove(0);
204        }
205        self
206    }
207    pub fn integral(mut self) -> Self {
208        let n = self.length();
209        self.data.insert(0, Zero::zero());
210        let mut fact = Vec::with_capacity(n + 1);
211        let mut c = T::one();
212        fact.push(c.clone());
213        for _ in 1..n {
214            fact.push(fact.last().cloned().unwrap() * c.clone());
215            c += T::one();
216        }
217        let mut invf = T::one() / (fact.last().cloned().unwrap() * c.clone());
218        for x in self.iter_mut().skip(1).rev() {
219            *x *= invf.clone() * fact.pop().unwrap();
220            invf *= c.clone();
221            c -= T::one();
222        }
223        self
224    }
225    pub fn parity_inversion(mut self) -> Self {
226        self.iter_mut()
227            .skip(1)
228            .step_by(2)
229            .for_each(|x| *x = -x.clone());
230        self
231    }
232    pub fn eval(&self, x: T) -> T {
233        let mut base = T::one();
234        let mut res = T::zero();
235        for a in self.iter() {
236            res += base.clone() * a.clone();
237            base *= x.clone();
238        }
239        res
240    }
241}
242
243impl<T, C> FormalPowerSeries<T, C>
244where
245    T: FormalPowerSeriesCoefficient,
246    C: ConvolveSteps<T = Vec<T>>,
247{
248    pub fn inv(&self, deg: usize) -> Self {
249        debug_assert!(!self[0].is_zero());
250        if self.data.iter().filter(|x| !x.is_zero()).count()
251            <= deg.next_power_of_two().trailing_zeros() as usize * 6
252        {
253            let pos: Vec<_> = self
254                .data
255                .iter()
256                .enumerate()
257                .skip(1)
258                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
259                .collect();
260            let mut f = Self::zeros(deg);
261            f[0] = T::one() / self[0].clone();
262            for i in 1..deg {
263                let mut tot = T::zero();
264                for &j in &pos {
265                    if j > i {
266                        break;
267                    }
268                    tot += self[j].clone() * &f[i - j];
269                }
270                f[i] = -tot * &f[0];
271            }
272            return f;
273        }
274        let mut f = Self::from(T::one() / self[0].clone());
275        let mut i = 1;
276        while i < deg {
277            let g = self.prefix_ref((i * 2).min(deg));
278            let h = f.clone();
279            let mut g = C::transform(g.data, 2 * i);
280            let h = C::transform(h.data, 2 * i);
281            C::multiply(&mut g, &h);
282            let mut g = Self::from_vec(C::inverse_transform(g, 2 * i));
283            g >>= i;
284            let mut g = C::transform(g.data, 2 * i);
285            C::multiply(&mut g, &h);
286            let g = Self::from_vec(C::inverse_transform(g, 2 * i));
287            f.data.extend((-g).into_iter().take(i));
288            i *= 2;
289        }
290        f.truncate(deg);
291        f
292    }
293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }

More examples

Hide additional examples

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 115)

113    fn add_assign(&mut self, rhs: &Self) {
114        if self.length() < rhs.length() {
115            self.resize(rhs.length());
116        }
117        for (x, y) in self.iter_mut().zip(rhs.iter()) {
118            x.add_assign(y);
119        }
120    }
121}
122impl<T, C> SubAssign<&Self> for FormalPowerSeries<T, C>
123where
124    T: FormalPowerSeriesCoefficient,
125{
126    fn sub_assign(&mut self, rhs: &Self) {
127        if self.length() < rhs.length() {
128            self.resize(rhs.length());
129        }
130        for (x, y) in self.iter_mut().zip(rhs.iter()) {
131            x.sub_assign(y);
132        }
133        self.trim_tail_zeros();
134    }
135}
136
137macro_rules! impl_fps_binop_addsub {
138    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
139        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
140        where
141            T: FormalPowerSeriesCoefficient,
142        {
143            fn $method_assign(&mut self, rhs: Self) {
144                $imp_assign::$method_assign(self, &rhs);
145            }
146        }
147        impl<T, C> $imp for FormalPowerSeries<T, C>
148        where
149            T: FormalPowerSeriesCoefficient,
150        {
151            type Output = Self;
152            fn $method(mut self, rhs: Self) -> Self::Output {
153                $imp_assign::$method_assign(&mut self, &rhs);
154                self
155            }
156        }
157        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
158        where
159            T: FormalPowerSeriesCoefficient,
160        {
161            type Output = Self;
162            fn $method(mut self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
163                $imp_assign::$method_assign(&mut self, rhs);
164                self
165            }
166        }
167        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
168        where
169            T: FormalPowerSeriesCoefficient,
170        {
171            type Output = FormalPowerSeries<T, C>;
172            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
173                let mut self_ = self.clone();
174                $imp_assign::$method_assign(&mut self_, &rhs);
175                self_
176            }
177        }
178        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
179        where
180            T: FormalPowerSeriesCoefficient,
181        {
182            type Output = FormalPowerSeries<T, C>;
183            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
184                let mut self_ = self.clone();
185                $imp_assign::$method_assign(&mut self_, rhs);
186                self_
187            }
188        }
189    };
190}
191impl_fps_binop_addsub!(Add, add, AddAssign, add_assign);
192impl_fps_binop_addsub!(Sub, sub, SubAssign, sub_assign);
193
194impl<T, C> Mul for FormalPowerSeries<T, C>
195where
196    C: ConvolveSteps<T = Vec<T>>,
197{
198    type Output = Self;
199    fn mul(self, rhs: Self) -> Self::Output {
200        Self::from_vec(C::convolve(self.data, rhs.data))
201    }
202}
203impl<T, C> Div for FormalPowerSeries<T, C>
204where
205    T: FormalPowerSeriesCoefficient,
206    C: ConvolveSteps<T = Vec<T>>,
207{
208    type Output = Self;
209    fn div(mut self, mut rhs: Self) -> Self::Output {
210        self.trim_tail_zeros();
211        rhs.trim_tail_zeros();
212        if self.length() < rhs.length() {
213            return Self::zero();
214        }
215        self.data.reverse();
216        rhs.data.reverse();
217        let n = self.length() - rhs.length() + 1;
218        let mut res = self * rhs.inv(n);
219        res.truncate(n);
220        res.data.reverse();
221        res
222    }
223}
224impl<T, C> Rem for FormalPowerSeries<T, C>
225where
226    T: FormalPowerSeriesCoefficient,
227    C: ConvolveSteps<T = Vec<T>>,
228{
229    type Output = Self;
230    fn rem(self, rhs: Self) -> Self::Output {
231        let mut rem = self.clone() - self / rhs.clone() * rhs;
232        rem.trim_tail_zeros();
233        rem
234    }
235}
236
237impl<T, C> FormalPowerSeries<T, C>
238where
239    T: FormalPowerSeriesCoefficient,
240    C: ConvolveSteps<T = Vec<T>>,
241{
242    pub fn div_rem(self, rhs: Self) -> (Self, Self) {
243        let div = self.clone() / rhs.clone();
244        let mut rem = self - div.clone() * rhs;
245        rem.trim_tail_zeros();
246        (div, rem)
247    }
248}
249
250macro_rules! impl_fps_binop_conv {
251    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
252        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
253        where
254            T: FormalPowerSeriesCoefficient,
255            C: ConvolveSteps<T = Vec<T>>,
256        {
257            fn $method_assign(&mut self, rhs: Self) {
258                *self = $imp::$method(Self::from_vec(take(&mut self.data)), rhs);
259            }
260        }
261        impl<T, C> $imp_assign<&Self> for FormalPowerSeries<T, C>
262        where
263            T: FormalPowerSeriesCoefficient,
264            C: ConvolveSteps<T = Vec<T>>,
265        {
266            fn $method_assign(&mut self, rhs: &Self) {
267                $imp_assign::$method_assign(self, rhs.clone());
268            }
269        }
270        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
271        where
272            T: FormalPowerSeriesCoefficient,
273            C: ConvolveSteps<T = Vec<T>>,
274        {
275            type Output = Self;
276            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
277                $imp::$method(self, rhs.clone())
278            }
279        }
280        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
281        where
282            T: FormalPowerSeriesCoefficient,
283            C: ConvolveSteps<T = Vec<T>>,
284        {
285            type Output = FormalPowerSeries<T, C>;
286            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
287                $imp::$method(self.clone(), rhs)
288            }
289        }
290        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
291        where
292            T: FormalPowerSeriesCoefficient,
293            C: ConvolveSteps<T = Vec<T>>,
294        {
295            type Output = FormalPowerSeries<T, C>;
296            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
297                $imp::$method(self.clone(), rhs.clone())
298            }
299        }
300    };
301}
302impl_fps_binop_conv!(Mul, mul, MulAssign, mul_assign);
303impl_fps_binop_conv!(Div, div, DivAssign, div_assign);
304impl_fps_binop_conv!(Rem, rem, RemAssign, rem_assign);
305
306impl<T, C> Neg for FormalPowerSeries<T, C>
307where
308    T: FormalPowerSeriesCoefficient,
309{
310    type Output = Self;
311    fn neg(mut self) -> Self::Output {
312        for x in self.iter_mut() {
313            *x = -x.clone();
314        }
315        self
316    }
317}
318impl<T, C> Neg for &FormalPowerSeries<T, C>
319where
320    T: FormalPowerSeriesCoefficient,
321{
322    type Output = FormalPowerSeries<T, C>;
323    fn neg(self) -> Self::Output {
324        self.clone().neg()
325    }
326}
327
328impl<T, C> ShrAssign<usize> for FormalPowerSeries<T, C>
329where
330    T: FormalPowerSeriesCoefficient,
331{
332    fn shr_assign(&mut self, rhs: usize) {
333        if self.length() <= rhs {
334            *self = Self::zero();
335        } else {
336            for i in rhs..self.length() {
337                self[i - rhs] = self[i].clone();
338            }
339            self.truncate(self.length() - rhs);
340        }
341    }
342}
343impl<T, C> ShlAssign<usize> for FormalPowerSeries<T, C>
344where
345    T: FormalPowerSeriesCoefficient,
346{
347    fn shl_assign(&mut self, rhs: usize) {
348        let n = self.length();
349        self.resize(n + rhs);
350        for i in (0..n).rev() {
351            self[i + rhs] = self[i].clone();
352        }
353        for i in 0..rhs {
354            self[i] = T::zero();
355        }
356    }

Source

pub fn resized(self, deg: usize) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 717)

699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }

Source

pub fn reversed(self) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 682)

668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }

Source §

impl<T, C> FormalPowerSeries<T, C>
where T: Zero + Clone,

Source

pub fn coeff(&self, deg: usize) -> T

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 396)

392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }

Source §

impl<T, C> FormalPowerSeries<T, C>
where T: Zero + PartialEq,

Source

pub fn trim_tail_zeros(&mut self)

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 30)

25    fn sub_assign(&mut self, rhs: T) {
26        if self.length() == 0 {
27            self.data.push(T::zero());
28        }
29        self.data[0].sub_assign(rhs);
30        self.trim_tail_zeros();
31    }
32}
33impl<T, C> MulAssign<T> for FormalPowerSeries<T, C>
34where
35    T: FormalPowerSeriesCoefficient,
36{
37    fn mul_assign(&mut self, rhs: T) {
38        for x in self.iter_mut() {
39            x.mul_assign(&rhs);
40        }
41    }
42}
43impl<T, C> DivAssign<T> for FormalPowerSeries<T, C>
44where
45    T: FormalPowerSeriesCoefficient,
46{
47    fn div_assign(&mut self, rhs: T) {
48        let rinv = T::one() / rhs;
49        for x in self.iter_mut() {
50            x.mul_assign(&rinv);
51        }
52    }
53}
54macro_rules! impl_fps_single_binop {
55    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
56        impl<T, C> $imp_assign<&T> for FormalPowerSeries<T, C>
57        where
58            T: FormalPowerSeriesCoefficient,
59        {
60            fn $method_assign(&mut self, rhs: &T) {
61                $imp_assign::$method_assign(self, rhs.clone());
62            }
63        }
64        impl<T, C> $imp<T> for FormalPowerSeries<T, C>
65        where
66            T: FormalPowerSeriesCoefficient,
67        {
68            type Output = Self;
69            fn $method(mut self, rhs: T) -> Self::Output {
70                $imp_assign::$method_assign(&mut self, rhs);
71                self
72            }
73        }
74        impl<T, C> $imp<&T> for FormalPowerSeries<T, C>
75        where
76            T: FormalPowerSeriesCoefficient,
77        {
78            type Output = Self;
79            fn $method(mut self, rhs: &T) -> Self::Output {
80                $imp_assign::$method_assign(&mut self, rhs);
81                self
82            }
83        }
84        impl<T, C> $imp<T> for &FormalPowerSeries<T, C>
85        where
86            T: FormalPowerSeriesCoefficient,
87        {
88            type Output = FormalPowerSeries<T, C>;
89            fn $method(self, rhs: T) -> Self::Output {
90                $imp::$method(self.clone(), rhs)
91            }
92        }
93        impl<T, C> $imp<&T> for &FormalPowerSeries<T, C>
94        where
95            T: FormalPowerSeriesCoefficient,
96        {
97            type Output = FormalPowerSeries<T, C>;
98            fn $method(self, rhs: &T) -> Self::Output {
99                $imp::$method(self.clone(), rhs)
100            }
101        }
102    };
103}
104impl_fps_single_binop!(Add, add, AddAssign, add_assign);
105impl_fps_single_binop!(Sub, sub, SubAssign, sub_assign);
106impl_fps_single_binop!(Mul, mul, MulAssign, mul_assign);
107impl_fps_single_binop!(Div, div, DivAssign, div_assign);
108
109impl<T, C> AddAssign<&Self> for FormalPowerSeries<T, C>
110where
111    T: FormalPowerSeriesCoefficient,
112{
113    fn add_assign(&mut self, rhs: &Self) {
114        if self.length() < rhs.length() {
115            self.resize(rhs.length());
116        }
117        for (x, y) in self.iter_mut().zip(rhs.iter()) {
118            x.add_assign(y);
119        }
120    }
121}
122impl<T, C> SubAssign<&Self> for FormalPowerSeries<T, C>
123where
124    T: FormalPowerSeriesCoefficient,
125{
126    fn sub_assign(&mut self, rhs: &Self) {
127        if self.length() < rhs.length() {
128            self.resize(rhs.length());
129        }
130        for (x, y) in self.iter_mut().zip(rhs.iter()) {
131            x.sub_assign(y);
132        }
133        self.trim_tail_zeros();
134    }
135}
136
137macro_rules! impl_fps_binop_addsub {
138    ($imp:ident, $method:ident, $imp_assign:ident, $method_assign:ident) => {
139        impl<T, C> $imp_assign for FormalPowerSeries<T, C>
140        where
141            T: FormalPowerSeriesCoefficient,
142        {
143            fn $method_assign(&mut self, rhs: Self) {
144                $imp_assign::$method_assign(self, &rhs);
145            }
146        }
147        impl<T, C> $imp for FormalPowerSeries<T, C>
148        where
149            T: FormalPowerSeriesCoefficient,
150        {
151            type Output = Self;
152            fn $method(mut self, rhs: Self) -> Self::Output {
153                $imp_assign::$method_assign(&mut self, &rhs);
154                self
155            }
156        }
157        impl<T, C> $imp<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
158        where
159            T: FormalPowerSeriesCoefficient,
160        {
161            type Output = Self;
162            fn $method(mut self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
163                $imp_assign::$method_assign(&mut self, rhs);
164                self
165            }
166        }
167        impl<T, C> $imp<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
168        where
169            T: FormalPowerSeriesCoefficient,
170        {
171            type Output = FormalPowerSeries<T, C>;
172            fn $method(self, rhs: FormalPowerSeries<T, C>) -> Self::Output {
173                let mut self_ = self.clone();
174                $imp_assign::$method_assign(&mut self_, &rhs);
175                self_
176            }
177        }
178        impl<T, C> $imp<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
179        where
180            T: FormalPowerSeriesCoefficient,
181        {
182            type Output = FormalPowerSeries<T, C>;
183            fn $method(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output {
184                let mut self_ = self.clone();
185                $imp_assign::$method_assign(&mut self_, rhs);
186                self_
187            }
188        }
189    };
190}
191impl_fps_binop_addsub!(Add, add, AddAssign, add_assign);
192impl_fps_binop_addsub!(Sub, sub, SubAssign, sub_assign);
193
194impl<T, C> Mul for FormalPowerSeries<T, C>
195where
196    C: ConvolveSteps<T = Vec<T>>,
197{
198    type Output = Self;
199    fn mul(self, rhs: Self) -> Self::Output {
200        Self::from_vec(C::convolve(self.data, rhs.data))
201    }
202}
203impl<T, C> Div for FormalPowerSeries<T, C>
204where
205    T: FormalPowerSeriesCoefficient,
206    C: ConvolveSteps<T = Vec<T>>,
207{
208    type Output = Self;
209    fn div(mut self, mut rhs: Self) -> Self::Output {
210        self.trim_tail_zeros();
211        rhs.trim_tail_zeros();
212        if self.length() < rhs.length() {
213            return Self::zero();
214        }
215        self.data.reverse();
216        rhs.data.reverse();
217        let n = self.length() - rhs.length() + 1;
218        let mut res = self * rhs.inv(n);
219        res.truncate(n);
220        res.data.reverse();
221        res
222    }
223}
224impl<T, C> Rem for FormalPowerSeries<T, C>
225where
226    T: FormalPowerSeriesCoefficient,
227    C: ConvolveSteps<T = Vec<T>>,
228{
229    type Output = Self;
230    fn rem(self, rhs: Self) -> Self::Output {
231        let mut rem = self.clone() - self / rhs.clone() * rhs;
232        rem.trim_tail_zeros();
233        rem
234    }
235}
236
237impl<T, C> FormalPowerSeries<T, C>
238where
239    T: FormalPowerSeriesCoefficient,
240    C: ConvolveSteps<T = Vec<T>>,
241{
242    pub fn div_rem(self, rhs: Self) -> (Self, Self) {
243        let div = self.clone() / rhs.clone();
244        let mut rem = self - div.clone() * rhs;
245        rem.trim_tail_zeros();
246        (div, rem)
247    }

More examples

Hide additional examples

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 632)

627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }

Source §

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source

pub fn prefix_ref(&self, deg: usize) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 277)

248    pub fn inv(&self, deg: usize) -> Self {
249        debug_assert!(!self[0].is_zero());
250        if self.data.iter().filter(|x| !x.is_zero()).count()
251            <= deg.next_power_of_two().trailing_zeros() as usize * 6
252        {
253            let pos: Vec<_> = self
254                .data
255                .iter()
256                .enumerate()
257                .skip(1)
258                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
259                .collect();
260            let mut f = Self::zeros(deg);
261            f[0] = T::one() / self[0].clone();
262            for i in 1..deg {
263                let mut tot = T::zero();
264                for &j in &pos {
265                    if j > i {
266                        break;
267                    }
268                    tot += self[j].clone() * &f[i - j];
269                }
270                f[i] = -tot * &f[0];
271            }
272            return f;
273        }
274        let mut f = Self::from(T::one() / self[0].clone());
275        let mut i = 1;
276        while i < deg {
277            let g = self.prefix_ref((i * 2).min(deg));
278            let h = f.clone();
279            let mut g = C::transform(g.data, 2 * i);
280            let h = C::transform(h.data, 2 * i);
281            C::multiply(&mut g, &h);
282            let mut g = Self::from_vec(C::inverse_transform(g, 2 * i));
283            g >>= i;
284            let mut g = C::transform(g.data, 2 * i);
285            C::multiply(&mut g, &h);
286            let g = Self::from_vec(C::inverse_transform(g, 2 * i));
287            f.data.extend((-g).into_iter().take(i));
288            i *= 2;
289        }
290        f.truncate(deg);
291        f
292    }
293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }

Source

pub fn prefix(self, deg: usize) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 328)

293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }

Source

pub fn even(self) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 675)

668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }

Source

pub fn odd(self) -> Self

Source

pub fn diff(self) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 298)

293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }

Source

pub fn integral(self) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 334)

333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }

Source

pub fn parity_inversion(self) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 674)

668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }

Source

pub fn eval(&self, x: T) -> T

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 702)

699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }

Source §

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source

pub fn inv(&self, deg: usize) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 334)

333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }

More examples

Hide additional examples

crates/library_checker/src/polynomial/inv_of_formal_power_series.rs (line 11)

6pub fn inv_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.inv(n);
12    iter_print!(writer, @it g.data);
13}

crates/competitive/src/math/formal_power_series/formal_power_series_nums.rs (line 218)

209    fn div(mut self, mut rhs: Self) -> Self::Output {
210        self.trim_tail_zeros();
211        rhs.trim_tail_zeros();
212        if self.length() < rhs.length() {
213            return Self::zero();
214        }
215        self.data.reverse();
216        rhs.data.reverse();
217        let n = self.length() - rhs.length() + 1;
218        let mut res = self * rhs.inv(n);
219        res.truncate(n);
220        res.data.reverse();
221        res
222    }

crates/library_checker/src/polynomial/inv_of_formal_power_series_sparse.rs (line 16)

6pub fn inv_of_formal_power_series_sparse(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, k);
10    let mut a = vec![MInt998244353::zero(); n];
11    for _ in 0..k {
12        scan!(scanner, i, a_i: MInt998244353);
13        a[i] = a_i;
14    }
15    let f = Fps998244353::from_vec(a);
16    let g = f.inv(n);
17    iter_print!(writer, @it g.data);
18}

Source

pub fn exp(&self, deg: usize) -> Self

Examples found in repository ?

crates/library_checker/src/polynomial/exp_of_formal_power_series.rs (line 11)

6pub fn exp_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.exp(n);
12    iter_print!(writer, @it g.data);
13}

More examples

Hide additional examples

crates/library_checker/src/polynomial/exp_of_formal_power_series_sparse.rs (line 16)

6pub fn exp_of_formal_power_series_sparse(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, k);
10    let mut a = vec![MInt998244353::zero(); n];
11    for _ in 0..k {
12        scan!(scanner, i, a_i: MInt998244353);
13        a[i] = a_i;
14    }
15    let f = Fps998244353::from_vec(a);
16    let g = f.exp(n);
17    iter_print!(writer, @it g.data);
18}

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 357)

336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }

Source

pub fn log(&self, deg: usize) -> Self

Examples found in repository ?

crates/library_checker/src/polynomial/log_of_formal_power_series.rs (line 11)

6pub fn log_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.log(n);
12    iter_print!(writer, @it g.data);
13}

More examples

Hide additional examples

crates/library_checker/src/polynomial/log_of_formal_power_series_sparse.rs (line 16)

6pub fn log_of_formal_power_series_sparse(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, k);
10    let mut a = vec![MInt998244353::zero(); n];
11    for _ in 0..k {
12        scan!(scanner, i, a_i: MInt998244353);
13        a[i] = a_i;
14    }
15    let f = Fps998244353::from_vec(a);
16    let g = f.log(n);
17    iter_print!(writer, @it g.data);
18}

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 323)

293    pub fn exp(&self, deg: usize) -> Self {
294        debug_assert!(self[0].is_zero());
295        if self.data.iter().filter(|x| !x.is_zero()).count()
296            <= deg.next_power_of_two().trailing_zeros() as usize * 16
297        {
298            let diff = self.clone().diff();
299            let pos: Vec<_> = diff
300                .data
301                .iter()
302                .enumerate()
303                .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
304                .collect();
305            let mf = T::memorized_factorial(deg);
306            let mut f = Self::zeros(deg);
307            f[0] = T::one();
308            for i in 1..deg {
309                let mut tot = T::zero();
310                for &j in &pos {
311                    if j > i - 1 {
312                        break;
313                    }
314                    tot += f[i - 1 - j].clone() * &diff[j];
315                }
316                f[i] = tot * T::memorized_inv(&mf, i);
317            }
318            return f;
319        }
320        let mut f = Self::one();
321        let mut i = 1;
322        while i < deg {
323            let mut g = -f.log(i * 2);
324            g[0] += T::one();
325            for (g, x) in g.iter_mut().zip(self.iter().take(i * 2)) {
326                *g += x.clone();
327            }
328            f = (f * g).prefix(i * 2);
329            i *= 2;
330        }
331        f.prefix(deg)
332    }
333    pub fn log(&self, deg: usize) -> Self {
334        (self.inv(deg) * self.clone().diff()).integral().prefix(deg)
335    }
336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }
585}
586
587impl<T, C> FormalPowerSeries<T, C>
588where
589    T: FormalPowerSeriesCoefficient,
590    C: ConvolveSteps<T = Vec<T>>,
591{
592    pub fn count_subset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
593    where
594        F: FnMut(usize) -> T,
595    {
596        let n = self.length();
597        let mut f = Self::zeros(n);
598        for i in 1..n {
599            if !self[i].is_zero() {
600                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
601                    if j & 1 != 0 {
602                        f[d] += self[i].clone() * &inverse(j);
603                    } else {
604                        f[d] -= self[i].clone() * &inverse(j);
605                    }
606                }
607            }
608        }
609        f.exp(deg)
610    }
611    pub fn count_multiset_sum<F>(&self, deg: usize, mut inverse: F) -> Self
612    where
613        F: FnMut(usize) -> T,
614    {
615        let n = self.length();
616        let mut f = Self::zeros(n);
617        for i in 1..n {
618            if !self[i].is_zero() {
619                for (j, d) in (0..n).step_by(i).enumerate().skip(1) {
620                    f[d] += self[i].clone() * &inverse(j);
621                }
622            }
623        }
624        f.exp(deg)
625    }
626    /// [x^n] P(x) / Q(x)
627    pub fn bostan_mori(mut self, mut rhs: Self, mut n: usize) -> T
628    where
629        C: NttReuse<T = Vec<T>>,
630    {
631        let mut res = T::zero();
632        rhs.trim_tail_zeros();
633        if self.length() >= rhs.length() {
634            let r = &self / &rhs;
635            if n < r.length() {
636                res = r[n].clone();
637            }
638            self -= r * &rhs;
639            self.trim_tail_zeros();
640        }
641        let k = rhs.length().next_power_of_two();
642        let mut p = C::transform(self.data, k * 2);
643        let mut q = C::transform(rhs.data, k * 2);
644        while n > 0 {
645            let t = C::even_mul_normal_neg(&q, &q);
646            p = if n.is_multiple_of(2) {
647                C::even_mul_normal_neg(&p, &q)
648            } else {
649                C::odd_mul_normal_neg(&p, &q)
650            };
651            q = t;
652            n /= 2;
653            if n != 0 {
654                if C::MULTIPLE {
655                    p = C::transform(C::inverse_transform(p, k), k * 2);
656                    q = C::transform(C::inverse_transform(q, k), k * 2);
657                } else {
658                    p = C::ntt_doubling(p);
659                    q = C::ntt_doubling(q);
660                }
661            }
662        }
663        let p = C::inverse_transform(p, k);
664        let q = C::inverse_transform(q, k);
665        res + p[0].clone() / q[0].clone()
666    }
667    /// return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)
668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }
734    pub fn product_all<I>(iter: I, deg: usize) -> Self
735    where
736        I: IntoIterator<Item = Self>,
737    {
738        let mut heap: BinaryHeap<_> = iter
739            .into_iter()
740            .map(|f| PartialIgnoredOrd(Reverse(f.length()), f))
741            .collect();
742        while let Some(PartialIgnoredOrd(_, x)) = heap.pop() {
743            if let Some(PartialIgnoredOrd(_, y)) = heap.pop() {
744                let z = (x * y).prefix(deg);
745                heap.push(PartialIgnoredOrd(Reverse(z.length()), z));
746            } else {
747                return x;
748            }
749        }
750        Self::one()
751    }
752    pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
753    where
754        I: IntoIterator<Item = (Self, Self)>,
755    {
756        let mut heap: BinaryHeap<_> = iter
757            .into_iter()
758            .map(|(f, g)| PartialIgnoredOrd(Reverse(f.length().max(g.length())), (f, g)))
759            .collect();
760        while let Some(PartialIgnoredOrd(_, (xa, xb))) = heap.pop() {
761            if let Some(PartialIgnoredOrd(_, (ya, yb))) = heap.pop() {
762                let zb = (&xb * &yb).prefix(deg);
763                let za = (xa * yb + ya * xb).prefix(deg);
764                heap.push(PartialIgnoredOrd(
765                    Reverse(za.length().max(zb.length())),
766                    (za, zb),
767                ));
768            } else {
769                return (xa, xb);
770            }
771        }
772        (Self::zero(), Self::one())
773    }
774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }
784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }
793    /// sum_i a_i exp(b_i x)
794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }
810    /// sum_i (a_i x)^j
811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }
825
826    pub fn power_projection(&self, w: &[T], m: usize) -> Self
827    where
828        C: NttReuse<T = Vec<T>>,
829    {
830        if w.is_empty() {
831            return Self::zeros(m);
832        }
833        if m <= 1 {
834            return Self::from_vec(vec![w[0].clone(); m]);
835        }
836
837        let n0 = w.len();
838        let mut n = n0.next_power_of_two();
839        let mut f = self.prefix_ref(n);
840        f.resize(n);
841
842        let base = n * 2;
843        let mut p_flat = vec![T::zero(); base];
844        for (i, wi) in w.iter().enumerate() {
845            p_flat[n - 1 - i] = wi.clone();
846        }
847        let mut q_flat = vec![T::zero(); base * 2];
848        q_flat[0] = T::one();
849        let q_offset = base;
850        for (i, fi) in f.iter().enumerate() {
851            q_flat[q_offset + i] = -fi.clone();
852        }
853        let mut py = 1usize;
854        let mut qy = 2usize;
855
856        let y_limit = m;
857        while n > 1 {
858            let base = n * 2;
859            let len_p = base * py;
860            let len_q = base * qy;
861            let len = (len_p + len_q - 1).max(len_q + len_q - 1);
862            let len_pot = len.max(1).next_power_of_two();
863            let half = len_pot / 2;
864
865            let p_fft = C::transform(p_flat, len);
866            let q_fft = C::transform(q_flat, len);
867            let pr_fft = C::odd_mul_normal_neg(&p_fft, &q_fft);
868            let qr_fft = C::even_mul_normal_neg(&q_fft, &q_fft);
869            let mut pr = C::inverse_transform(pr_fft, half);
870            let mut qr = C::inverse_transform(qr_fft, half);
871
872            let new_py = (py + qy - 1).min(y_limit);
873            let new_qy = (qy + qy - 1).min(y_limit);
874            let new_base = n;
875            let need_p = new_base * new_py;
876            if pr.len() < need_p {
877                pr.resize_with(need_p, T::zero);
878            } else if pr.len() > need_p {
879                pr.truncate(need_p);
880            }
881            let need_q = new_base * new_qy;
882            if qr.len() < need_q {
883                qr.resize_with(need_q, T::zero);
884            } else if qr.len() > need_q {
885                qr.truncate(need_q);
886            }
887
888            let n2 = n / 2;
889            if n2 < new_base {
890                for y in 0..new_py {
891                    let start = y * new_base + n2;
892                    let end = y * new_base + new_base;
893                    for v in pr[start..end].iter_mut() {
894                        *v = T::zero();
895                    }
896                }
897                for y in 0..new_qy {
898                    let start = y * new_base + n2;
899                    let end = y * new_base + new_base;
900                    for v in qr[start..end].iter_mut() {
901                        *v = T::zero();
902                    }
903                }
904            }
905
906            p_flat = pr;
907            q_flat = qr;
908            py = new_py;
909            qy = new_qy;
910            n = n2;
911        }
912
913        let base = 2;
914        let mut p_y = Vec::with_capacity(py);
915        for y in 0..py {
916            p_y.push(p_flat[base * y].clone());
917        }
918        let mut q_y = Vec::with_capacity(qy);
919        for y in 0..qy {
920            q_y.push(q_flat[base * y].clone());
921        }
922        (Self::from_vec(p_y) * Self::from_vec(q_y).inv(m)).prefix(m)
923    }
924
925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }

Source

pub fn pow(&self, rhs: usize, deg: usize) -> Self

Examples found in repository ?

crates/library_checker/src/polynomial/pow_of_formal_power_series.rs (line 11)

6pub fn pow_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, m, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.pow(m, n);
12    iter_print!(writer, @it g.data);
13}

More examples

Hide additional examples

crates/library_checker/src/polynomial/pow_of_formal_power_series_sparse.rs (line 16)

6pub fn pow_of_formal_power_series_sparse(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, k, m);
10    let mut a = vec![MInt998244353::zero(); n];
11    for _ in 0..k {
12        scan!(scanner, i, a_i: MInt998244353);
13        a[i] = a_i;
14    }
15    let f = Fps998244353::from_vec(a);
16    let g = f.pow(m, n);
17    iter_print!(writer, @it g.data);
18}

Source

fn pow_sparse1(&self, rhs: T, deg: usize) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 355)

336    pub fn pow(&self, rhs: usize, deg: usize) -> Self {
337        if rhs == 0 {
338            return Self::from_vec(
339                once(T::one())
340                    .chain(repeat_with(T::zero))
341                    .take(deg)
342                    .collect(),
343            );
344        }
345        if let Some(k) = self.iter().position(|x| !x.is_zero()) {
346            if k >= deg.div_ceil(rhs) {
347                Self::zeros(deg)
348            } else {
349                let deg = deg - k * rhs;
350                let x0 = self[k].clone();
351                let mut f = (self >> k) / &x0;
352                if f.data.iter().filter(|x| !x.is_zero()).count()
353                    <= deg.next_power_of_two().trailing_zeros() as usize * 12
354                {
355                    f = f.pow_sparse1(T::from(rhs), deg);
356                } else {
357                    f = (f.log(deg) * &T::from(rhs)).exp(deg);
358                }
359                f *= x0.pow(rhs);
360                f <<= k * rhs;
361                f
362            }
363        } else {
364            Self::zeros(deg)
365        }
366    }
367    fn pow_sparse1(&self, rhs: T, deg: usize) -> Self {
368        debug_assert!(!self[0].is_zero());
369        let pos: Vec<_> = self
370            .data
371            .iter()
372            .enumerate()
373            .skip(1)
374            .filter_map(|(i, x)| if x.is_zero() { None } else { Some(i) })
375            .collect();
376        let mf = T::memorized_factorial(deg);
377        let mut f = Self::zeros(deg);
378        f[0] = T::one();
379        for i in 1..deg {
380            let mut tot = T::zero();
381            for &j in &pos {
382                if j > i {
383                    break;
384                }
385                tot += (T::from(j) * &rhs - T::from(i - j)) * &self[j] * &f[i - j];
386            }
387            f[i] = tot * T::memorized_inv(&mf, i);
388        }
389        f
390    }
391
392    fn sparse_fold(&self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize) -> T {
393        sparse
394            .into_iter()
395            .take_while(|&(i, _)| i <= deg)
396            .fold(T::zero(), |sum, (i, x)| sum + x * self.coeff(deg - i))
397    }
398
399    /// solve: $X(QF)'=\alpha P'(QF)+\beta P(Q'F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$
400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }
460
461    /// P^exp_p * Q^exp_q
462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }
545}
546
547impl<T, C> FormalPowerSeries<T, C>
548where
549    T: FormalPowerSeriesCoefficientSqrt,
550    C: ConvolveSteps<T = Vec<T>>,
551{
552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }

Source

fn sparse_fold( &self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize, ) -> T

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 439)

400    pub fn solve_sparse_differential2(
401        p: &Self,
402        q: &Self,
403        x: &Self,
404        alpha: T,
405        beta: T,
406        deg: usize,
407    ) -> Self {
408        if deg == 0 {
409            return Self::zero();
410        }
411        let collect_sparse = |p: &Self| -> Vec<(usize, T)> {
412            p.iter()
413                .enumerate()
414                .filter(|&(_, x)| !x.is_zero())
415                .map(|(i, x)| (i, x.clone()))
416                .collect()
417        };
418        assert!(q.coeff(0).is_one());
419        assert!(x.coeff(0).is_one());
420        let p = collect_sparse(p);
421        let q = collect_sparse(q);
422        let x = collect_sparse(x);
423        let diff = |p: &[(usize, T)]| -> Vec<(usize, T)> {
424            p.iter()
425                .filter(|&&(i, _)| i > 0)
426                .map(|&(i, ref x)| (i - 1, x.clone() * T::from(i)))
427                .collect()
428        };
429        let dp = diff(&p);
430        let dq = diff(&q);
431
432        let mf = T::memorized_factorial(deg);
433        let mut f = Self::zeros(deg);
434        let mut qf = Self::zeros(deg);
435        let mut dq_f = Self::zeros(deg);
436        let mut d_qf = Self::zeros(deg);
437        f[0] = T::one();
438        for i in 0..deg - 1 {
439            qf[i] = f.sparse_fold(q.iter().cloned(), i);
440            dq_f[i] = f.sparse_fold(dq.iter().cloned(), i);
441            let dp_qf_i = qf.sparse_fold(dp.iter().cloned(), i);
442            let p_dq_f_i = dq_f.sparse_fold(p.iter().cloned(), i);
443            let x_d_qf_i = d_qf.sparse_fold(
444                x.iter()
445                    .map(|&(i, ref x)| (i, x.clone() - T::from((i == 0) as usize))),
446                i,
447            );
448            d_qf[i] = alpha.clone() * dp_qf_i + beta.clone() * p_dq_f_i - x_d_qf_i;
449
450            let mut f_ip1 = d_qf[i].clone();
451            for &(j, ref q) in q.iter().take_while(|&&(j, _)| j <= i) {
452                if j > 0 {
453                    f_ip1 -= q.clone() * &f[i - (j - 1)] * T::from(i - (j - 1));
454                }
455            }
456            f[i + 1] = f_ip1 * T::memorized_inv(&mf, i + 1);
457        }
458        f
459    }

Source

pub fn solve_sparse_differential2( p: &Self, q: &Self, x: &Self, alpha: T, beta: T, deg: usize, ) -> Self

solve: $X(QF)’=\alpha P’(QF)+\beta P(Q’F)$ in $O(deg * max(nz(P), nz(Q), nz(X)))$

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (lines 508-515)

462    pub fn mul_of_pow_sparse(&self, q: &Self, exp_p: isize, exp_q: isize, deg: usize) -> Self {
463        if deg == 0 {
464            return Self::zero();
465        }
466        if exp_p == 0 && exp_q == 0 {
467            return Self::from_vec(
468                once(T::one())
469                    .chain(repeat_with(T::zero))
470                    .take(deg)
471                    .collect(),
472            );
473        }
474        if exp_p != 0 && self.iter().all(|x| x.is_zero()) {
475            assert!(exp_p > 0);
476            return Self::zeros(deg);
477        }
478        if exp_q != 0 && q.iter().all(|x| x.is_zero()) {
479            assert!(exp_q > 0);
480            return Self::zeros(deg);
481        }
482
483        let normalize = |f: &Self, exp: isize| {
484            if exp == 0 {
485                return (0usize, T::one(), Self::from_vec(vec![T::one()]));
486            }
487            let k = f.iter().position(|value| !value.is_zero()).unwrap();
488            assert!(
489                exp >= 0 || k == 0,
490                "Negative exponent with zero constant term"
491            );
492            let c = f[k].clone();
493            let f = (f.clone() >> k) / &c;
494            (k, c, f)
495        };
496        let (sp, cp, mut p) = normalize(self, exp_p);
497        let (sq, cq, mut q) = normalize(q, exp_q);
498
499        let shift = exp_p
500            .saturating_mul(sp as _)
501            .saturating_add(exp_q.saturating_mul(sq as _)) as usize;
502        if shift >= deg {
503            return Self::zeros(deg);
504        }
505        p.truncate(deg - shift);
506        q.truncate(deg - shift);
507
508        let mut f = Self::solve_sparse_differential2(
509            &p,
510            &q,
511            &p,
512            T::from(exp_p),
513            T::from(exp_q),
514            deg - shift,
515        );
516        f *= cp.signed_pow(exp_p) * cq.signed_pow(exp_q);
517        if shift > 0 {
518            f <<= shift;
519        }
520        f.prefix(deg)
521    }
522
523    /// exp(P/Q)
524    pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self {
525        if deg == 0 {
526            return Self::zero();
527        }
528        let shift_q = q
529            .iter()
530            .position(|value| !value.is_zero())
531            .expect("Zero denominator");
532        let shift_p = self.iter().position(|value| !value.is_zero()).unwrap_or(!0);
533        assert!(shift_p > shift_q);
534
535        let mut p = self >> shift_q;
536        let mut q = q >> shift_q;
537        assert!(!q.coeff(0).is_zero());
538
539        let c = q[0].clone();
540        p /= c.clone();
541        q /= c;
542
543        Self::solve_sparse_differential2(&p, &q, &q, T::one(), -T::one(), deg)
544    }

Source

pub fn mul_of_pow_sparse( &self, q: &Self, exp_p: isize, exp_q: isize, deg: usize, ) -> Self

P^exp_p * Q^exp_q

Source

pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self

exp(P/Q)

Source §

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficientSqrt, C: ConvolveSteps<T = Vec<T>>,

Source

pub fn sqrt(&self, deg: usize) -> Option<Self>

Examples found in repository ?

crates/library_checker/src/polynomial/sqrt_of_formal_power_series.rs (line 11)

6pub fn sqrt_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    if let Some(g) = f.sqrt(n) {
12        iter_print!(writer, @it g.data);
13    } else {
14        iter_print!(writer, "-1");
15    }
16}

More examples

Hide additional examples

crates/library_checker/src/polynomial/sqrt_of_formal_power_series_sparse.rs (line 16)

6pub fn sqrt_of_formal_power_series_sparse(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, k);
10    let mut a = vec![MInt998244353::zero(); n];
11    for _ in 0..k {
12        scan!(scanner, i, a_i: MInt998244353);
13        a[i] = a_i;
14    }
15    let f = Fps998244353::from_vec(a);
16    if let Some(g) = f.sqrt(n) {
17        iter_print!(writer, @it g.data);
18    } else {
19        iter_print!(writer, "-1");
20    }
21}

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 558)

552    pub fn sqrt(&self, deg: usize) -> Option<Self> {
553        if self[0].is_zero() {
554            if let Some(k) = self.iter().position(|x| !x.is_zero()) {
555                if k % 2 != 0 {
556                    return None;
557                } else if deg > k / 2 {
558                    return Some((self >> k).sqrt(deg - k / 2)? << (k / 2));
559                }
560            }
561        } else {
562            let s = self[0].sqrt_coefficient()?;
563            if self.data.iter().filter(|x| !x.is_zero()).count()
564                <= deg.next_power_of_two().trailing_zeros() as usize * 4
565            {
566                let t = self[0].clone();
567                let mut f = self / t;
568                f = f.pow_sparse1(T::one() / T::from(2usize), deg);
569                f *= s;
570                return Some(f);
571            }
572
573            let mut f = Self::from(s);
574            let inv2 = T::one() / (T::one() + T::one());
575            let mut i = 1;
576            while i < deg {
577                f = (&f + &(self.prefix_ref(i * 2) * f.inv(i * 2))).prefix(i * 2) * &inv2;
578                i *= 2;
579            }
580            f.truncate(deg);
581            return Some(f);
582        }
583        Some(Self::zeros(deg))
584    }

Source §

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source

pub fn count_subset_sum<F>(&self, deg: usize, inverse: F) -> Self
where F: FnMut(usize) -> T,

Examples found in repository ?

crates/library_checker/src/enumerative_combinatorics/sharp_p_subset_sum.rs (line 18)

9pub fn sharp_p_subset_sum(reader: impl Read, mut writer: impl Write) {
10    let s = read_all_unchecked(reader);
11    let mut scanner = Scanner::new(&s);
12    scan!(scanner, n, t, s: [usize; n]);
13    let f = MemorizedFactorial::new(t);
14    let mut c = vec![MInt998244353::zero(); t + 1];
15    for s in s {
16        c[s] += MInt998244353::one();
17    }
18    let a = Fps998244353::from_vec(c).count_subset_sum(t + 1, |x| f.inv(x));
19    iter_print!(writer, @it a.data[1..]);
20}

Source

pub fn count_multiset_sum<F>(&self, deg: usize, inverse: F) -> Self
where F: FnMut(usize) -> T,

Source

pub fn bostan_mori(self, rhs: Self, n: usize) -> T
where C: NttReuse<T = Vec<T>>,

[x^n] P(x) / Q(x)

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 782)

774    pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
775    where
776        C: NttReuse<T = Vec<T>>,
777    {
778        if let Some(x) = a.get(k) {
779            return x.clone();
780        }
781        let p = (Self::from_vec(a).prefix(self.length() - 1) * &self).prefix(self.length() - 1);
782        p.bostan_mori(self, k)
783    }

Source

pub fn bostan_mori_msb(self, n: usize) -> Self

return F(x) where [x^n] P(x) / Q(x) = [x^d-1] P(x) F(x)

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 675)

668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }

Source

pub fn pow_mod(self, n: usize) -> Self

x^n mod self

Examples found in repository ?

crates/competitive/src/math/black_box_matrix.rs (line 244)

235    fn apply_pow<C>(&self, mut b: Vec<MInt<M>>, k: usize) -> Vec<MInt<M>>
236    where
237        M: MIntConvert<usize> + MIntConvert<isize> + MIntConvert<u64>,
238        C: ConvolveSteps<T = Vec<MInt<M>>>,
239    {
240        assert_eq!(self.shape().0, self.shape().1);
241        assert_eq!(self.shape().1, b.len());
242        let n = self.shape().0;
243        let p = self.minimal_polynomial();
244        let f = FormalPowerSeries::<MInt<M>, C>::from_vec(p).pow_mod(k);
245        let mut res = vec![MInt::zero(); n];
246        for f in f {
247            for j in 0..n {
248                res[j] += f * b[j];
249            }
250            b = self.apply(&b);
251        }
252        res
253    }

Source

fn middle_product(self, other: &C::F, deg: usize) -> Self

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 682)

668    pub fn bostan_mori_msb(self, n: usize) -> Self {
669        let d = self.length() - 1;
670        if n == 0 {
671            return (Self::one() << (d - 1)) / self[0].clone();
672        }
673        let q = self;
674        let mq = q.clone().parity_inversion();
675        let w = (q * &mq).even().bostan_mori_msb(n / 2);
676        let mut s = Self::zeros(w.length() * 2 - (n % 2));
677        for (i, x) in w.iter().enumerate() {
678            s[i * 2 + (1 - n % 2)] = x.clone();
679        }
680        let len = 2 * d + 1;
681        let ts = C::transform(s.prefix(len).data, len);
682        mq.reversed().middle_product(&ts, len).prefix(d + 1)
683    }
684    /// x^n mod self
685    pub fn pow_mod(self, n: usize) -> Self {
686        let d = self.length() - 1;
687        let q = self.reversed();
688        let u = q.clone().bostan_mori_msb(n);
689        let mut f = (u * q).prefix(d).reversed();
690        f.trim_tail_zeros();
691        f
692    }
693    fn middle_product(self, other: &C::F, deg: usize) -> Self {
694        let n = self.length();
695        let mut s = C::transform(self.reversed().data, deg);
696        C::multiply(&mut s, other);
697        Self::from_vec((C::inverse_transform(s, deg))[n - 1..].to_vec())
698    }
699    pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T> {
700        let n = points.len();
701        if n <= 32 {
702            return points.iter().map(|p| self.eval(p.clone())).collect();
703        }
704        let mut subproduct_tree = Vec::with_capacity(n * 2);
705        subproduct_tree.resize_with(n, Zero::zero);
706        for x in points {
707            subproduct_tree.push(Self::from_vec(vec![-x.clone(), T::one()]));
708        }
709        for i in (1..n).rev() {
710            subproduct_tree[i] = &subproduct_tree[i * 2] * &subproduct_tree[i * 2 + 1];
711        }
712        let mut uptree_t = Vec::with_capacity(n * 2);
713        uptree_t.resize_with(1, Zero::zero);
714        subproduct_tree.reverse();
715        subproduct_tree.pop();
716        let m = self.length();
717        let v = subproduct_tree.pop().unwrap().reversed().resized(m);
718        let s = C::transform(self.data, m * 2);
719        uptree_t.push(v.inv(m).middle_product(&s, m * 2).resized(n).reversed());
720        for i in 1..n {
721            let subl = subproduct_tree.pop().unwrap();
722            let subr = subproduct_tree.pop().unwrap();
723            let (dl, dr) = (subl.length(), subr.length());
724            let len = dl.max(dr) + uptree_t[i].length();
725            let s = C::transform(uptree_t[i].data.to_vec(), len);
726            uptree_t.push(subr.middle_product(&s, len).prefix(dl));
727            uptree_t.push(subl.middle_product(&s, len).prefix(dr));
728        }
729        uptree_t[n..]
730            .iter()
731            .map(|u| u.data.first().cloned().unwrap_or_else(Zero::zero))
732            .collect()
733    }

Source

pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T>

Examples found in repository ?

crates/library_checker/src/polynomial/multipoint_evaluation.rs (line 11)

6pub fn multipoint_evaluation(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, m, c: [MInt998244353; n], p: [MInt998244353; m]);
10    let f = Fps998244353::from_vec(c);
11    let res = f.multipoint_evaluation(&p);
12    iter_print!(writer, @it res);
13}

Source

pub fn product_all(iter: I, deg: usize) -> Self
where I: IntoIterator<Item = Self>,

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (lines 816-822)

811    pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
812    where
813        I: IntoIterator<Item = T>,
814    {
815        let mut n = T::zero();
816        let prod = Self::product_all(
817            iter.into_iter().map(|a| {
818                n += T::one();
819                Self::from_vec(vec![T::one(), -a])
820            }),
821            deg,
822        );
823        (-prod.log(deg).diff() << 1) + Self::from_vec(vec![n])
824    }

Source

pub fn sum_all_rational(iter: I, deg: usize) -> (Self, Self)
where I: IntoIterator<Item = (Self, Self)>,

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (lines 799-803)

794    pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, mut inv_fact: F) -> Self
795    where
796        I: IntoIterator<Item = (T, T)>,
797        F: FnMut(usize) -> T,
798    {
799        let (p, q) = Self::sum_all_rational(
800            iter.into_iter()
801                .map(|(a, b)| (Self::from_vec(vec![a]), Self::from_vec(vec![T::one(), -b]))),
802            deg,
803        );
804        let mut f = (p * q.inv(deg)).prefix(deg);
805        for i in 0..f.length() {
806            f[i] *= inv_fact(i);
807        }
808        f
809    }

Source

pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
where C: NttReuse<T = Vec<T>>,

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 791)

784    pub fn kth_term(a: Vec<T>, k: usize) -> T
785    where
786        C: NttReuse<T = Vec<T>>,
787    {
788        if let Some(x) = a.get(k) {
789            return x.clone();
790        }
791        Self::from_vec(berlekamp_massey(&a)).kth_term_of_linearly_recurrence(a, k)
792    }

More examples

Hide additional examples

crates/library_checker/src/other/kth_term_of_linearly_recurrent_sequence.rs (line 14)

9pub fn kth_term_of_linearly_recurrent_sequence(reader: impl Read, mut writer: impl Write) {
10    let s = read_all_unchecked(reader);
11    let mut scanner = Scanner::new(&s);
12    scan!(scanner, d, k, a: [MInt998244353; d], c: [MInt998244353; d]);
13    let q = Fps998244353::one() - (Fps998244353::from_vec(c) << 1);
14    iter_print!(writer, q.kth_term_of_linearly_recurrence(a, k));
15}

Source

pub fn kth_term(a: Vec<T>, k: usize) -> T
where C: NttReuse<T = Vec<T>>,

Source

pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, inv_fact: F) -> Self
where I: IntoIterator<Item = (T, T)>, F: FnMut(usize) -> T,

sum_i a_i exp(b_i x)

Source

pub fn sum_of_powers(iter: I, deg: usize) -> Self
where I: IntoIterator<Item = T>,

sum_i (a_i x)^j

Source

pub fn power_projection(&self, w: &[T], m: usize) -> Self
where C: NttReuse<T = Vec<T>>,

Examples found in repository ?

crates/competitive/src/math/formal_power_series/formal_power_series_impls.rs (line 945)

925    pub fn compositional_inverse(&self, deg: usize) -> Self
926    where
927        C: NttReuse<T = Vec<T>>,
928    {
929        if deg == 0 {
930            return Self::zero();
931        }
932        if deg == 1 {
933            return Self::from_vec(vec![T::zero()]);
934        }
935        debug_assert!(self[0].is_zero());
936        debug_assert!(!self[1].is_zero());
937
938        let mut f = self.prefix_ref(deg);
939        f.resize(deg);
940        let c = f[1].clone();
941        f /= c.clone();
942
943        let mut w = vec![T::zero(); deg];
944        w[deg - 1] = T::one();
945        let s = f.power_projection(&w, deg);
946
947        let n = deg - 1;
948        let n_t = T::from(n);
949        let mut h = vec![T::zero(); n];
950        for i in 1..=n {
951            h[n - i] = s[i].clone() * &n_t / T::from(i);
952        }
953
954        let h_fps = Self::from_vec(h);
955        let inv_n = T::one() / n_t;
956        let mut t = h_fps.log(n);
957        t *= -inv_n;
958        let g_over_x = t.exp(n);
959        let mut g = (g_over_x << 1).prefix(deg);
960
961        let inv_c = T::one() / c;
962        let mut pow = T::one();
963        for coef in g.iter_mut() {
964            *coef *= pow.clone();
965            pow *= inv_c.clone();
966        }
967        g
968    }

Source

pub fn compositional_inverse(&self, deg: usize) -> Self
where C: NttReuse<T = Vec<T>>,

Examples found in repository ?

crates/library_checker/src/polynomial/compositional_inverse_of_formal_power_series.rs (line 11)

6pub fn compositional_inverse_of_formal_power_series(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, a: [MInt998244353; n]);
10    let f = Fps998244353::from_vec(a);
11    let g = f.compositional_inverse(n);
12    iter_print!(writer, @it g.data);
13}

More examples

Hide additional examples

crates/library_checker/src/polynomial/compositional_inverse_of_formal_power_series_large.rs (line 14)

6pub fn compositional_inverse_of_formal_power_series_large(
7    reader: impl Read,
8    mut writer: impl Write,
9) {
10    let s = read_all_unchecked(reader);
11    let mut scanner = Scanner::new(&s);
12    scan!(scanner, n, a: [MInt998244353; n]);
13    let f = Fps998244353::from_vec(a);
14    let g = f.compositional_inverse(n);
15    iter_print!(writer, @it g.data);
16}

Source

pub fn taylor_shift(self, a: T) -> Self

f(x) <- f(x + a)

Examples found in repository ?

crates/library_checker/src/polynomial/polynomial_taylor_shift.rs (line 11)

6pub fn polynomial_taylor_shift(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, c: MInt998244353, a: [MInt998244353; n]);
10    let a = Fps998244353::from_vec(a);
11    let res = a.taylor_shift(c);
12    iter_print!(writer, @it res);
13}

Source §

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source

pub fn div_rem(self, rhs: Self) -> (Self, Self)

Examples found in repository ?

crates/library_checker/src/polynomial/division_of_polynomials.rs (line 12)

6pub fn division_of_polynomials(reader: impl Read, mut writer: impl Write) {
7    let s = read_all_unchecked(reader);
8    let mut scanner = Scanner::new(&s);
9    scan!(scanner, n, m, f: [MInt998244353; n], g: [MInt998244353; m]);
10    let f = Fps998244353::from_vec(f);
11    let g = Fps998244353::from_vec(g);
12    let (q, r) = f.div_rem(g);
13    writeln!(writer, "{} {}", q.length(), r.length()).ok();
14    iter_print!(writer, @it q.data);
15    iter_print!(writer, @it r.data);
16}

Trait Implementations§

Source §

impl<T, C> Add<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the + operator.

Source §

fn add(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the + operation. Read more

Source §

impl<T, C> Add<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the + operator.

Source §

fn add(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the + operation. Read more

Source §

impl<T, C> Add<&T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the + operator.

Source §

fn add(self, rhs: &T) -> Self::Output

Performs the + operation. Read more

Source §

impl<T, C> Add<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the + operator.

Source §

fn add(self, rhs: &T) -> Self::Output

Performs the + operation. Read more

Source §

impl<T, C> Add<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the + operator.

Source §

fn add(self, rhs: FormalPowerSeries<T, C>) -> Self::Output

Performs the + operation. Read more

Source §

impl<T, C> Add<T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the + operator.

Source §

fn add(self, rhs: T) -> Self::Output

Performs the + operation. Read more

Source §

impl<T, C> Add<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the + operator.

Source §

fn add(self, rhs: T) -> Self::Output

Performs the + operation. Read more

Source §

impl<T, C> Add for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the + operator.

Source §

fn add(self, rhs: Self) -> Self::Output

Performs the + operation. Read more

Source §

impl<T, C> AddAssign<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn add_assign(&mut self, rhs: &Self)

Performs the += operation. Read more

Source §

impl<T, C> AddAssign<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn add_assign(&mut self, rhs: &T)

Performs the += operation. Read more

Source §

impl<T, C> AddAssign<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn add_assign(&mut self, rhs: T)

Performs the += operation. Read more

Source §

impl<T, C> AddAssign for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn add_assign(&mut self, rhs: Self)

Performs the += operation. Read more

Source §

impl<T, C> Clone for FormalPowerSeries<T, C>
where T: Clone,

Source §

fn clone(&self) -> Self

Returns a duplicate of the value. Read more

1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Source §

impl<T, C> Debug for FormalPowerSeries<T, C>
where T: Debug,

Source §

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Source §

impl<T: Default, C: Default> Default for FormalPowerSeries<T, C>

Source §

fn default() -> FormalPowerSeries<T, C>

Returns the “default value” for a type. Read more

Source §

impl<T, C> Div<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the / operator.

Source §

fn div(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the / operation. Read more

Source §

impl<T, C> Div<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the / operator.

Source §

fn div(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the / operation. Read more

Source §

impl<T, C> Div<&T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the / operator.

Source §

fn div(self, rhs: &T) -> Self::Output

Performs the / operation. Read more

Source §

impl<T, C> Div<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the / operator.

Source §

fn div(self, rhs: &T) -> Self::Output

Performs the / operation. Read more

Source §

impl<T, C> Div<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the / operator.

Source §

fn div(self, rhs: FormalPowerSeries<T, C>) -> Self::Output

Performs the / operation. Read more

Source §

impl<T, C> Div<T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the / operator.

Source §

fn div(self, rhs: T) -> Self::Output

Performs the / operation. Read more

Source §

impl<T, C> Div<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the / operator.

Source §

fn div(self, rhs: T) -> Self::Output

Performs the / operation. Read more

Source §

impl<T, C> Div for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the / operator.

Source §

fn div(self, rhs: Self) -> Self::Output

Performs the / operation. Read more

Source §

impl<T, C> DivAssign<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation. Read more

Source §

impl<T, C> DivAssign<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn div_assign(&mut self, rhs: &T)

Performs the /= operation. Read more

Source §

impl<T, C> DivAssign<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn div_assign(&mut self, rhs: T)

Performs the /= operation. Read more

Source §

impl<T, C> DivAssign for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

fn div_assign(&mut self, rhs: Self)

Performs the /= operation. Read more

Source §

impl<T, C> From<T> for FormalPowerSeries<T, C>

Source §

fn from(x: T) -> Self

Converts to this type from the input type.

Source §

impl<T, C> From<Vec<T>> for FormalPowerSeries<T, C>

Source §

fn from(data: Vec<T>) -> Self

Converts to this type from the input type.

Source §

impl<T, C> FromIterator<T> for FormalPowerSeries<T, C>

Source §

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator. Read more

Source §

impl<T, C> Index<usize> for FormalPowerSeries<T, C>

Source §

type Output = T

The returned type after indexing.

Source §

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation. Read more

Source §

impl<T, C> IndexMut<usize> for FormalPowerSeries<T, C>

Source §

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation. Read more

Source §

impl<'a, T, C> IntoIterator for &'a FormalPowerSeries<T, C>

Source §

type Item = &'a T

The type of the elements being iterated over.

Source §

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

Source §

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

Source §

impl<'a, T, C> IntoIterator for &'a mut FormalPowerSeries<T, C>

Source §

type Item = &'a mut T

The type of the elements being iterated over.

Source §

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

Source §

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

Source §

impl<T, C> IntoIterator for FormalPowerSeries<T, C>

Source §

type Item = T

The type of the elements being iterated over.

Source §

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

Source §

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

Source §

impl<T, C> Mul<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the * operation. Read more

Source §

impl<T, C> Mul<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the * operation. Read more

Source §

impl<T, C> Mul<&T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation. Read more

Source §

impl<T, C> Mul<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: &T) -> Self::Output

Performs the * operation. Read more

Source §

impl<T, C> Mul<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: FormalPowerSeries<T, C>) -> Self::Output

Performs the * operation. Read more

Source §

impl<T, C> Mul<T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: T) -> Self::Output

Performs the * operation. Read more

Source §

impl<T, C> Mul<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: T) -> Self::Output

Performs the * operation. Read more

Source §

impl<T, C> Mul for FormalPowerSeries<T, C>
where C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the * operator.

Source §

fn mul(self, rhs: Self) -> Self::Output

Performs the * operation. Read more

Source §

impl<T, C> MulAssign<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation. Read more

Source §

impl<T, C> MulAssign<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn mul_assign(&mut self, rhs: &T)

Performs the *= operation. Read more

Source §

impl<T, C> MulAssign<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn mul_assign(&mut self, rhs: T)

Performs the *= operation. Read more

Source §

impl<T, C> MulAssign for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation. Read more

Source §

impl<T, C> Neg for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn neg(self) -> Self::Output

Performs the unary - operation. Read more

Source §

impl<T, C> Neg for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn neg(self) -> Self::Output

Performs the unary - operation. Read more

Source §

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

1.0.0 · Source§

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

Source §

impl<T, C> Rem<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the % operator.

Source §

fn rem(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the % operation. Read more

Source §

impl<T, C> Rem<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the % operator.

Source §

fn rem(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the % operation. Read more

Source §

impl<T, C> Rem<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the % operator.

Source §

fn rem(self, rhs: FormalPowerSeries<T, C>) -> Self::Output

Performs the % operation. Read more

Source §

impl<T, C> Rem for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the % operator.

Source §

fn rem(self, rhs: Self) -> Self::Output

Performs the % operation. Read more

Source §

impl<T, C> RemAssign<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

fn rem_assign(&mut self, rhs: &Self)

Performs the %= operation. Read more

Source §

impl<T, C> RemAssign for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

Source §

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation. Read more

Source §

impl<T, C> Shl<usize> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the << operator.

Source §

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation. Read more

Source §

impl<T, C> Shl<usize> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the << operator.

Source §

fn shl(self, rhs: usize) -> Self::Output

Performs the << operation. Read more

Source §

impl<T, C> ShlAssign<usize> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation. Read more

Source §

impl<T, C> Shr<usize> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the >> operator.

Source §

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation. Read more

Source §

impl<T, C> Shr<usize> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the >> operator.

Source §

fn shr(self, rhs: usize) -> Self::Output

Performs the >> operation. Read more

Source §

impl<T, C> ShrAssign<usize> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation. Read more

Source §

impl<T, C> Sub<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn sub(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the - operation. Read more

Source §

impl<T, C> Sub<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn sub(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

Performs the - operation. Read more

Source §

impl<T, C> Sub<&T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation. Read more

Source §

impl<T, C> Sub<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn sub(self, rhs: &T) -> Self::Output

Performs the - operation. Read more

Source §

impl<T, C> Sub<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn sub(self, rhs: FormalPowerSeries<T, C>) -> Self::Output

Performs the - operation. Read more

Source §

impl<T, C> Sub<T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn sub(self, rhs: T) -> Self::Output

Performs the - operation. Read more

Source §

impl<T, C> Sub<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn sub(self, rhs: T) -> Self::Output

Performs the - operation. Read more

Source §

impl<T, C> Sub for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

type Output = FormalPowerSeries<T, C>

The resulting type after applying the - operator.

Source §

fn sub(self, rhs: Self) -> Self::Output

Performs the - operation. Read more

Source §

impl<T, C> SubAssign<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation. Read more

Source §

impl<T, C> SubAssign<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn sub_assign(&mut self, rhs: &T)

Performs the -= operation. Read more

Source §

impl<T, C> SubAssign<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn sub_assign(&mut self, rhs: T)

Performs the -= operation. Read more

Source §

impl<T, C> SubAssign for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

Source §

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation. Read more

Source §

impl<T, C> Zero for FormalPowerSeries<T, C>
where T: PartialEq,

Source §

fn zero() -> Self

Source §

fn is_zero(&self) -> bool
where Self: PartialEq,

Source §

fn set_zero(&mut self)

Source §

impl<T, C> Eq for FormalPowerSeries<T, C>
where T: PartialEq,

Auto Trait Implementations§

§

impl<T, C> Freeze for FormalPowerSeries<T, C>

§

impl<T, C> RefUnwindSafe for FormalPowerSeries<T, C>
where C: RefUnwindSafe, T: RefUnwindSafe,

§

impl<T, C> Send for FormalPowerSeries<T, C>
where C: Send, T: Send,

§

impl<T, C> Sync for FormalPowerSeries<T, C>
where C: Sync, T: Sync,

§

impl<T, C> Unpin for FormalPowerSeries<T, C>
where C: Unpin, T: Unpin,

§

impl<T, C> UnsafeUnpin for FormalPowerSeries<T, C>

§

impl<T, C> UnwindSafe for FormalPowerSeries<T, C>
where C: UnwindSafe, T: UnwindSafe,

Blanket Implementations§

Source §

impl<T> Any for T
where T: 'static + ?Sized,

Source §

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

Source §

impl<T> Borrow<T> for T
where T: ?Sized,

Source §

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

Source §

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source §

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

Source §

impl<T> CloneToUninit for T
where T: Clone,

Source §

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)

Performs copy-assignment from self to dest. Read more

Source §

impl<T> From<!> for T

Source §

fn from(t: !) -> T

Converts to this type from the input type.

Source §

impl<T> From<T> for T

Source §

fn from(t: T) -> T

Returns the argument unchanged.

Source §

impl<T, U> Into for T
where U: From<T>,

Source §

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source §

impl<T> ToArrayVecScalar for T

Source §

fn to_array_vec_scalar(self) -> ArrayVecScalar<T>

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Source §

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct FormalPowerSeries Copy item path

Fields§

Implementations§

impl<T, C> FormalPowerSeries<T, C>

pub fn from_vec(data: Vec<T>) -> Self

pub fn length(&self) -> usize

pub fn truncate(&mut self, deg: usize)

pub fn iter(&self) -> Iter<'_, T>

pub fn iter_mut(&mut self) -> IterMut<'_, T>

impl<T, C> FormalPowerSeries<T, C>where T: Zero,

pub fn zeros(deg: usize) -> Self

pub fn resize(&mut self, deg: usize)

pub fn resized(self, deg: usize) -> Self

pub fn reversed(self) -> Self

impl<T, C> FormalPowerSeries<T, C>where T: Zero + Clone,

pub fn coeff(&self, deg: usize) -> T

impl<T, C> FormalPowerSeries<T, C>where T: Zero + PartialEq,

pub fn trim_tail_zeros(&mut self)

impl<T, C> FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient,

pub fn prefix_ref(&self, deg: usize) -> Self

pub fn prefix(self, deg: usize) -> Self

pub fn even(self) -> Self

pub fn odd(self) -> Self

pub fn diff(self) -> Self

pub fn integral(self) -> Self

pub fn parity_inversion(self) -> Self

pub fn eval(&self, x: T) -> T

impl<T, C> FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

pub fn inv(&self, deg: usize) -> Self

pub fn exp(&self, deg: usize) -> Self

pub fn log(&self, deg: usize) -> Self

pub fn pow(&self, rhs: usize, deg: usize) -> Self

fn pow_sparse1(&self, rhs: T, deg: usize) -> Self

fn sparse_fold( &self, sparse: impl IntoIterator<Item = (usize, T)>, deg: usize, ) -> T

pub fn solve_sparse_differential2( p: &Self, q: &Self, x: &Self, alpha: T, beta: T, deg: usize, ) -> Self

pub fn mul_of_pow_sparse( &self, q: &Self, exp_p: isize, exp_q: isize, deg: usize, ) -> Self

pub fn exp_of_div_sparse(&self, q: &Self, deg: usize) -> Self

impl<T, C> FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficientSqrt, C: ConvolveSteps<T = Vec<T>>,

pub fn sqrt(&self, deg: usize) -> Option<Self>

impl<T, C> FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

pub fn count_subset_sum<F>(&self, deg: usize, inverse: F) -> Selfwhere F: FnMut(usize) -> T,

pub fn count_multiset_sum<F>(&self, deg: usize, inverse: F) -> Selfwhere F: FnMut(usize) -> T,

pub fn bostan_mori(self, rhs: Self, n: usize) -> Twhere C: NttReuse<T = Vec<T>>,

pub fn bostan_mori_msb(self, n: usize) -> Self

pub fn pow_mod(self, n: usize) -> Self

fn middle_product(self, other: &C::F, deg: usize) -> Self

pub fn multipoint_evaluation(self, points: &[T]) -> Vec<T>

pub fn product_all<I>(iter: I, deg: usize) -> Selfwhere I: IntoIterator<Item = Self>,

pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)where I: IntoIterator<Item = (Self, Self)>,

pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> Twhere C: NttReuse<T = Vec<T>>,

pub fn kth_term(a: Vec<T>, k: usize) -> Twhere C: NttReuse<T = Vec<T>>,

pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, inv_fact: F) -> Selfwhere I: IntoIterator<Item = (T, T)>, F: FnMut(usize) -> T,

pub fn sum_of_powers<I>(iter: I, deg: usize) -> Selfwhere I: IntoIterator<Item = T>,

pub fn power_projection(&self, w: &[T], m: usize) -> Selfwhere C: NttReuse<T = Vec<T>>,

pub fn compositional_inverse(&self, deg: usize) -> Selfwhere C: NttReuse<T = Vec<T>>,

pub fn taylor_shift(self, a: T) -> Self

impl<T, C> FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

pub fn div_rem(self, rhs: Self) -> (Self, Self)

Trait Implementations§

impl<T, C> Add<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient,

type Output = FormalPowerSeries<T, C>

fn add(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

impl<T, C> Add<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient,

type Output = FormalPowerSeries<T, C>

fn add(self, rhs: &FormalPowerSeries<T, C>) -> Self::Output

impl<T, C> Add<&T> for &FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient,

type Output = FormalPowerSeries<T, C>

fn add(self, rhs: &T) -> Self::Output

impl<T, C> Add<&T> for FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient,

type Output = FormalPowerSeries<T, C>

fn add(self, rhs: &T) -> Self::Output

impl<T, C> Add<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient,

type Output = FormalPowerSeries<T, C>

fn add(self, rhs: FormalPowerSeries<T, C>) -> Self::Output

impl<T, C> Add<T> for &FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient,

type Output = FormalPowerSeries<T, C>

fn add(self, rhs: T) -> Self::Output

impl<T, C> Add<T> for FormalPowerSeries<T, C>where T: FormalPowerSeriesCoefficient,

type Output = FormalPowerSeries<T, C>

fn add(self, rhs: T) -> Self::Output

Struct FormalPowerSeries

impl<T, C> FormalPowerSeries<T, C>
where T: Zero,

impl<T, C> FormalPowerSeries<T, C>
where T: Zero + Clone,

impl<T, C> FormalPowerSeries<T, C>
where T: Zero + PartialEq,

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficientSqrt, C: ConvolveSteps<T = Vec<T>>,

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

pub fn count_subset_sum<F>(&self, deg: usize, inverse: F) -> Self
where F: FnMut(usize) -> T,

pub fn count_multiset_sum<F>(&self, deg: usize, inverse: F) -> Self
where F: FnMut(usize) -> T,

pub fn bostan_mori(self, rhs: Self, n: usize) -> T
where C: NttReuse<T = Vec<T>>,

pub fn product_all<I>(iter: I, deg: usize) -> Self
where I: IntoIterator<Item = Self>,

pub fn sum_all_rational<I>(iter: I, deg: usize) -> (Self, Self)
where I: IntoIterator<Item = (Self, Self)>,

pub fn kth_term_of_linearly_recurrence(self, a: Vec<T>, k: usize) -> T
where C: NttReuse<T = Vec<T>>,

pub fn kth_term(a: Vec<T>, k: usize) -> T
where C: NttReuse<T = Vec<T>>,

pub fn linear_sum_of_exp<I, F>(iter: I, deg: usize, inv_fact: F) -> Self
where I: IntoIterator<Item = (T, T)>, F: FnMut(usize) -> T,

pub fn sum_of_powers<I>(iter: I, deg: usize) -> Self
where I: IntoIterator<Item = T>,

pub fn power_projection(&self, w: &[T], m: usize) -> Self
where C: NttReuse<T = Vec<T>>,

pub fn compositional_inverse(&self, deg: usize) -> Self
where C: NttReuse<T = Vec<T>>,

impl<T, C> FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

impl<T, C> Add<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> Add<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> Add<&T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> Add<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> Add<FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> Add<T> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> Add<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> Add for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> AddAssign<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> AddAssign<&T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> AddAssign<T> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> AddAssign for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient,

impl<T, C> Clone for FormalPowerSeries<T, C>
where T: Clone,

impl<T, C> Debug for FormalPowerSeries<T, C>
where T: Debug,

impl<T, C> Div<&FormalPowerSeries<T, C>> for &FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,

impl<T, C> Div<&FormalPowerSeries<T, C>> for FormalPowerSeries<T, C>
where T: FormalPowerSeriesCoefficient, C: ConvolveSteps<T = Vec<T>>,