networkit_rs/
generators.rs

1use cxx::{CxxVector, UniquePtr};
2use miette::IntoDiagnostic;
3
4use crate::{
5    base::{Algorithm, GraphEvent, GraphEventType},
6    bridge::{self, *},
7    tools::NodeIter,
8};
9
10pub trait StaticGraphGenerator {
11    fn generate(&mut self) -> crate::Graph;
12}
13
14pub trait StaticDegreeSequenceGenerator: StaticGraphGenerator {
15    fn is_realizable(&mut self) -> bool;
16    fn get_realizable(&self) -> bool;
17}
18
19pub trait DynamicGraphGenerator {
20    fn generate(&mut self, n_steps: u64) -> Vec<crate::base::GraphEvent>;
21}
22
23pub struct BarabasiAlbertGenerator {
24    inner: UniquePtr<bridge::BarabasiAlbertGenerator>,
25}
26
27impl BarabasiAlbertGenerator {
28    pub fn new(k: u64, n_max: u64, n0: Option<u64>, batagelj: bool) -> Self {
29        Self {
30            inner: NewBarabasiAlbertGenerator(k, n_max, n0.unwrap_or(0), batagelj),
31        }
32    }
33}
34
35impl StaticGraphGenerator for BarabasiAlbertGenerator {
36    fn generate(&mut self) -> crate::Graph {
37        BarabasiAlbertGeneratorGenerate(self.inner.pin_mut()).into()
38    }
39}
40
41pub struct ChungLuGenerator {
42    inner: UniquePtr<bridge::ChungLuGenerator>,
43    _seq: UniquePtr<CxxVector<u64>>,
44}
45
46impl ChungLuGenerator {
47    pub fn new(degree_sequence: &[u64]) -> Self {
48        let seq = MakeCountVector(degree_sequence);
49        let inner = NewChungLuGenerator(&seq);
50        Self { inner, _seq: seq }
51    }
52}
53
54impl StaticGraphGenerator for ChungLuGenerator {
55    fn generate(&mut self) -> crate::Graph {
56        ChungLuGeneratorGenerate(self.inner.pin_mut()).into()
57    }
58}
59
60pub struct ClusteredRandomGraphGenerator {
61    inner: UniquePtr<bridge::ClusteredRandomGraphGenerator>,
62}
63
64impl ClusteredRandomGraphGenerator {
65    pub fn new(n: u64, k: u64, p_intra: f64, p_inter: f64) -> Self {
66        let inner = NewClusteredRandomGraphGenerator(n, k, p_intra, p_inter);
67        Self { inner }
68    }
69    pub fn get_communities(&mut self) -> crate::Partition {
70        ClusteredRandomGraphGeneratorGetCommunities(self.inner.pin_mut()).into()
71    }
72}
73
74impl StaticGraphGenerator for ClusteredRandomGraphGenerator {
75    fn generate(&mut self) -> crate::Graph {
76        ClusteredRandomGraphGeneratorGenerate(self.inner.pin_mut()).into()
77    }
78}
79
80pub struct DorogovtsevMendesGenerator {
81    inner: UniquePtr<bridge::DorogovtsevMendesGenerator>,
82}
83
84impl DorogovtsevMendesGenerator {
85    pub fn new(n_nodes: u64) -> Self {
86        let inner = NewDorogovtsevMendesGenerator(n_nodes);
87        Self { inner }
88    }
89}
90
91impl StaticGraphGenerator for DorogovtsevMendesGenerator {
92    fn generate(&mut self) -> crate::Graph {
93        DorogovtsevMendesGeneratorGenerate(self.inner.pin_mut()).into()
94    }
95}
96
97pub struct DynamicDorogovtsevMendesGenerator {
98    inner: UniquePtr<bridge::DynamicDorogovtsevMendesGenerator>,
99}
100
101impl DynamicDorogovtsevMendesGenerator {
102    pub fn new() -> Self {
103        let inner = NewDynamicDorogovtsevMendesGenerator();
104        Self { inner }
105    }
106}
107
108impl DynamicGraphGenerator for DynamicDorogovtsevMendesGenerator {
109    fn generate(&mut self, n_steps: u64) -> Vec<crate::base::GraphEvent> {
110        let mut typs = vec![];
111        let mut us = vec![];
112        let mut vs = vec![];
113        let mut ws = vec![];
114        DynamicDorogovtsevMendesGeneratorGenerate(
115            self.inner.pin_mut(),
116            n_steps,
117            &mut typs,
118            &mut us,
119            &mut vs,
120            &mut ws,
121        );
122        typs.into_iter()
123            .zip(us)
124            .zip(vs)
125            .zip(ws)
126            .map(|(((t, u), v), w)| GraphEvent {
127                kind: GraphEventType::from(t),
128                u,
129                v,
130                ew: w,
131            })
132            .collect()
133    }
134}
135
136pub struct DynamicForestFireGenerator {
137    inner: UniquePtr<bridge::DynamicForestFireGenerator>,
138}
139
140impl DynamicForestFireGenerator {
141    pub fn new(p: f64, directed: bool, r: Option<f64>) -> Self {
142        let inner = NewDynamicForestFireGenerator(p, directed, r.unwrap_or(1.));
143        Self { inner }
144    }
145}
146
147impl DynamicGraphGenerator for DynamicForestFireGenerator {
148    fn generate(&mut self, n_steps: u64) -> Vec<crate::base::GraphEvent> {
149        let mut typs = vec![];
150        let mut us = vec![];
151        let mut vs = vec![];
152        let mut ws = vec![];
153        DynamicForestFireGeneratorGenerate(
154            self.inner.pin_mut(),
155            n_steps,
156            &mut typs,
157            &mut us,
158            &mut vs,
159            &mut ws,
160        );
161        typs.into_iter()
162            .zip(us)
163            .zip(vs)
164            .zip(ws)
165            .map(|(((t, u), v), w)| GraphEvent {
166                kind: GraphEventType::from(t),
167                u,
168                v,
169                ew: w,
170            })
171            .collect()
172    }
173}
174
175pub struct DynamicHyperbolicGenerator {
176    inner: UniquePtr<bridge::DynamicHyperbolicGenerator>,
177}
178
179impl DynamicHyperbolicGenerator {
180    pub fn new(
181        n: u64,
182        avg_degree: f64,
183        exp: f64,
184        t: f64,
185        move_each_step: f64,
186        move_distance: f64,
187    ) -> Self {
188        let inner =
189            NewDynamicHyperbolicGenerator(n, avg_degree, exp, t, move_each_step, move_distance);
190        Self { inner }
191    }
192    pub fn get_graph(&self) -> crate::Graph {
193        DynamicHyperbolicGeneratorGetGraph(&self.inner).into()
194    }
195    pub fn get_coordinates(&self) -> impl Iterator<Item = (f64, f64)> {
196        let mut xs = vec![];
197        let mut ys = vec![];
198        DynamicHyperbolicGeneratorGetCoordinates(&self.inner, &mut xs, &mut ys);
199        xs.into_iter().zip(ys)
200    }
201}
202
203impl DynamicGraphGenerator for DynamicHyperbolicGenerator {
204    fn generate(&mut self, n_steps: u64) -> Vec<crate::base::GraphEvent> {
205        let mut typs = vec![];
206        let mut us = vec![];
207        let mut vs = vec![];
208        let mut ws = vec![];
209        DynamicHyperbolicGeneratorGenerate(
210            self.inner.pin_mut(),
211            n_steps,
212            &mut typs,
213            &mut us,
214            &mut vs,
215            &mut ws,
216        );
217        typs.into_iter()
218            .zip(us)
219            .zip(vs)
220            .zip(ws)
221            .map(|(((t, u), v), w)| GraphEvent {
222                kind: GraphEventType::from(t),
223                u,
224                v,
225                ew: w,
226            })
227            .collect()
228    }
229}
230
231pub struct DynamicPathGenerator {
232    inner: UniquePtr<bridge::DynamicPathGenerator>,
233}
234
235impl DynamicPathGenerator {
236    pub fn new() -> Self {
237        let inner = NewDynamicPathGenerator();
238        Self { inner }
239    }
240}
241
242impl DynamicGraphGenerator for DynamicPathGenerator {
243    fn generate(&mut self, n_steps: u64) -> Vec<crate::base::GraphEvent> {
244        let mut typs = vec![];
245        let mut us = vec![];
246        let mut vs = vec![];
247        let mut ws = vec![];
248        DynamicPathGeneratorGenerate(
249            self.inner.pin_mut(),
250            n_steps,
251            &mut typs,
252            &mut us,
253            &mut vs,
254            &mut ws,
255        );
256        typs.into_iter()
257            .zip(us)
258            .zip(vs)
259            .zip(ws)
260            .map(|(((t, u), v), w)| GraphEvent {
261                kind: GraphEventType::from(t),
262                u,
263                v,
264                ew: w,
265            })
266            .collect()
267    }
268}
269
270pub struct DynamicPubWebGenerator {
271    inner: UniquePtr<bridge::DynamicPubWebGenerator>,
272}
273
274impl DynamicPubWebGenerator {
275    pub fn new(
276        num_nodes: u64,
277        num_dense_areas: u64,
278        neighbourhood_radius: f64,
279        max_num_neighbours: u64,
280        write_initial_graph_to_stream: bool,
281    ) -> Self {
282        let inner = NewDynamicPubWebGenerator(
283            num_nodes,
284            num_dense_areas,
285            neighbourhood_radius,
286            max_num_neighbours,
287            write_initial_graph_to_stream,
288        );
289        Self { inner }
290    }
291    pub fn get_graph(&self) -> crate::Graph {
292        DynamicPubWebGeneratorGetGraph(&self.inner).into()
293    }
294    pub fn get_coordinates(&self) -> impl Iterator<Item = (f64, f64)> {
295        let mut xs = vec![];
296        let mut ys = vec![];
297        DynamicPubWebGeneratorGetCoordinates(&self.inner, &mut xs, &mut ys);
298        xs.into_iter().zip(ys)
299    }
300    pub fn get_new_coordinates(&self) -> impl Iterator<Item = (u64, (f64, f64))> {
301        let mut ns = vec![];
302        let mut xs = vec![];
303        let mut ys = vec![];
304        DynamicPubWebGeneratorGetNewCoordinates(&self.inner, &mut ns, &mut xs, &mut ys);
305        ns.into_iter().zip(xs.into_iter().zip(ys))
306    }
307}
308
309impl DynamicGraphGenerator for DynamicPubWebGenerator {
310    fn generate(&mut self, n_steps: u64) -> Vec<crate::base::GraphEvent> {
311        let mut typs = vec![];
312        let mut us = vec![];
313        let mut vs = vec![];
314        let mut ws = vec![];
315        DynamicPubWebGeneratorGenerate(
316            self.inner.pin_mut(),
317            n_steps,
318            &mut typs,
319            &mut us,
320            &mut vs,
321            &mut ws,
322        );
323        typs.into_iter()
324            .zip(us)
325            .zip(vs)
326            .zip(ws)
327            .map(|(((t, u), v), w)| GraphEvent {
328                kind: GraphEventType::from(t),
329                u,
330                v,
331                ew: w,
332            })
333            .collect()
334    }
335}
336
337pub struct EdgeSwitchingMarkovChainGenerator {
338    inner: UniquePtr<bridge::EdgeSwitchingMarkovChainGenerator>,
339    _seq: UniquePtr<CxxVector<u64>>,
340}
341
342impl EdgeSwitchingMarkovChainGenerator {
343    pub fn new(
344        sequence: &[u64],
345        ignore_if_not_realizable: bool,
346        num_switches_per_edge: u64,
347    ) -> Self {
348        let seq = MakeCountVector(sequence);
349        let inner = NewEdgeSwitchingMarkovChainGenerator(
350            &seq,
351            ignore_if_not_realizable,
352            num_switches_per_edge,
353        );
354        Self { inner, _seq: seq }
355    }
356}
357
358impl StaticGraphGenerator for EdgeSwitchingMarkovChainGenerator {
359    fn generate(&mut self) -> crate::Graph {
360        EdgeSwitchingMarkovChainGeneratorGenerate(self.inner.pin_mut()).into()
361    }
362}
363
364impl StaticDegreeSequenceGenerator for EdgeSwitchingMarkovChainGenerator {
365    fn is_realizable(&mut self) -> bool {
366        self.inner.pin_mut().isRealizable()
367    }
368
369    fn get_realizable(&self) -> bool {
370        self.inner.getRealizable()
371    }
372}
373
374pub struct ErdosRenyiGenerator {
375    inner: UniquePtr<bridge::ErdosRenyiGenerator>,
376}
377
378impl ErdosRenyiGenerator {
379    pub fn new(n_nodes: u64, prob: f64, directed: bool, self_loops: bool) -> Self {
380        let inner = NewErdosRenyiGenerator(n_nodes, prob, directed, self_loops);
381        Self { inner }
382    }
383}
384
385impl StaticGraphGenerator for ErdosRenyiGenerator {
386    fn generate(&mut self) -> crate::Graph {
387        ErdosRenyiGeneratorGenerate(self.inner.pin_mut()).into()
388    }
389}
390
391pub struct HavelHakimiGenerator {
392    inner: UniquePtr<bridge::HavelHakimiGenerator>,
393    _seq: UniquePtr<CxxVector<u64>>,
394}
395
396impl HavelHakimiGenerator {
397    pub fn new(sequence: &[u64], ignore_if_not_realizable: bool) -> Self {
398        let seq = MakeCountVector(sequence);
399        let inner = NewHavelHakimiGenerator(&seq, ignore_if_not_realizable);
400        Self { inner, _seq: seq }
401    }
402}
403
404impl StaticGraphGenerator for HavelHakimiGenerator {
405    fn generate(&mut self) -> crate::Graph {
406        HavelHakimiGeneratorGenerate(self.inner.pin_mut()).into()
407    }
408}
409
410impl StaticDegreeSequenceGenerator for HavelHakimiGenerator {
411    fn is_realizable(&mut self) -> bool {
412        self.inner.pin_mut().isRealizable()
413    }
414
415    fn get_realizable(&self) -> bool {
416        self.inner.getRealizable()
417    }
418}
419
420pub struct HyperbolicGenerator {
421    inner: UniquePtr<bridge::HyperbolicGenerator>,
422}
423
424impl HyperbolicGenerator {
425    pub fn new(n: u64, avg_degree: f64, exp: f64, t: f64) -> Self {
426        let inner = NewHyperbolicGenerator(n, avg_degree, exp, t);
427        Self { inner }
428    }
429    pub fn generate_advanced(
430        &mut self,
431        angles: &[f64],
432        radii: &[f64],
433        r: f64,
434        t: f64,
435    ) -> crate::Graph {
436        HyperbolicGeneratorGenerateAdvanced(self.inner.pin_mut(), angles, radii, r, t).into()
437    }
438
439    pub fn set_leaf_capacity(&mut self, capacity: u64) {
440        self.inner.pin_mut().setLeafCapacity(capacity)
441    }
442    pub fn set_theoretical_split(&mut self, split: bool) {
443        self.inner.pin_mut().setTheoreticalSplit(split)
444    }
445    pub fn set_balance(&mut self, balance: f64) {
446        self.inner.pin_mut().setBalance(balance)
447    }
448}
449
450impl StaticGraphGenerator for HyperbolicGenerator {
451    fn generate(&mut self) -> crate::Graph {
452        HyperbolicGeneratorGenerate(self.inner.pin_mut()).into()
453    }
454}
455
456pub struct LFRGenerator {
457    inner: UniquePtr<bridge::LFRGenerator>,
458    _seq: UniquePtr<CxxVector<f64>>,
459}
460
461impl LFRGenerator {
462    pub fn new(n: u64) -> Self {
463        let seq = MakeWeightVector(&[]);
464        let inner = NewLFRGenerator(n);
465        Self { inner, _seq: seq }
466    }
467    pub fn set_mu_array(&mut self, mu: &[f64]) {
468        let seq = MakeWeightVector(mu);
469        self.inner.pin_mut().setMuArray(&seq);
470        self._seq = seq;
471    }
472    pub fn set_mut(&mut self, mu: f64) {
473        self.inner.pin_mut().setMu(mu)
474    }
475    pub fn set_mut_with_binomial_distribution(&mut self, mu: f64) {
476        self.inner.pin_mut().setMuWithBinomialDistribution(mu)
477    }
478    pub fn set_degree_sequence(&mut self, seq: &[u64]) {
479        LFRGeneratorSetDegreeSequence(self.inner.pin_mut(), seq)
480    }
481    pub fn set_community_size_sequence(&mut self, seq: &[u64]) {
482        LFRGeneratorSetCommunitySizeSequence(self.inner.pin_mut(), seq)
483    }
484    pub fn set_partition(&mut self, p: crate::Partition) {
485        LFRGeneratorSetPartition(self.inner.pin_mut(), p.inner)
486    }
487    pub fn generate_powerlaw_degree_sequence(
488        &mut self,
489        avg_degree: u64,
490        max_degree: u64,
491        node_degree_exp: f64,
492    ) {
493        self.inner
494            .pin_mut()
495            .generatePowerlawDegreeSequence(avg_degree, max_degree, node_degree_exp)
496    }
497    pub fn generate_powerlaw_community_size_sequence(
498        &mut self,
499        min_community_size: u64,
500        max_community_size: u64,
501        community_size_exp: f64,
502    ) {
503        self.inner.pin_mut().generatePowerlawCommunitySizeSequence(
504            min_community_size,
505            max_community_size,
506            community_size_exp,
507        )
508    }
509    pub fn get_graph(&self) -> crate::Graph {
510        LFRGeneratorGetGraph(&self.inner).into()
511    }
512    pub fn get_partition(&self) -> crate::Partition {
513        LFRGeneratorGetPartition(&self.inner).into()
514    }
515}
516
517impl StaticGraphGenerator for LFRGenerator {
518    fn generate(&mut self) -> crate::Graph {
519        LFRGeneratorGenerate(self.inner.pin_mut()).into()
520    }
521}
522
523impl Algorithm for LFRGenerator {
524    fn run(&mut self) -> miette::Result<()> {
525        self.inner.pin_mut().run().into_diagnostic()
526    }
527
528    fn has_finished(&self) -> bool {
529        self.inner.hasFinished()
530    }
531}
532
533pub struct MocnikGenerator {
534    inner: UniquePtr<bridge::MocnikGenerator>,
535}
536
537impl MocnikGenerator {
538    pub fn new(dim: u64, n: u64, k: f64, weighted: bool) -> Self {
539        let inner = NewMocnikGenerator(dim, n, k, weighted);
540        Self { inner }
541    }
542}
543
544impl StaticGraphGenerator for MocnikGenerator {
545    fn generate(&mut self) -> crate::Graph {
546        MocnikGeneratorGenerate(self.inner.pin_mut()).into()
547    }
548}
549
550pub struct MocnikGeneratorBasic {
551    inner: UniquePtr<bridge::MocnikGeneratorBasic>,
552}
553
554impl MocnikGeneratorBasic {
555    pub fn new(dim: u64, n: u64, k: f64) -> Self {
556        let inner = NewMocnikGeneratorBasic(dim, n, k);
557        Self { inner }
558    }
559}
560
561impl StaticGraphGenerator for MocnikGeneratorBasic {
562    fn generate(&mut self) -> crate::Graph {
563        MocnikGeneratorBasicGenerate(self.inner.pin_mut()).into()
564    }
565}
566
567pub struct PowerlawDegreeSequence {
568    inner: UniquePtr<bridge::PowerlawDegreeSequence>,
569}
570
571impl PowerlawDegreeSequence {
572    pub fn new(min_deg: u64, max_deg: u64, gamma: f64) -> Self {
573        let inner = NewPowerlawDegreeSequence(min_deg, max_deg, gamma);
574        Self { inner }
575    }
576    pub fn get_degree_sequence(&self, num_nodes: u64) -> NodeIter {
577        NodeIter {
578            at: 0,
579            nodes: PowerlawDegreeSequenceGetDegreeSequence(&self.inner, num_nodes),
580        }
581    }
582    pub fn set_minimum_from_average_degree(&mut self, avg_deg: f64) {
583        self.inner.pin_mut().setMinimumFromAverageDegree(avg_deg)
584    }
585    pub fn set_gamma_from_average_degree(&mut self, avg_deg: f64, min_gamma: f64, max_gamma: f64) {
586        self.inner
587            .pin_mut()
588            .setGammaFromAverageDegree(avg_deg, min_gamma, max_gamma)
589    }
590    pub fn set_minimum_degree(&mut self, min_deg: u64) {
591        self.inner.pin_mut().setMinimumDegree(min_deg)
592    }
593    pub fn get_minimum_degree(&mut self) -> u64 {
594        self.inner.getMinimumDegree()
595    }
596    pub fn get_maximum_degree(&mut self) -> u64 {
597        self.inner.getMaximumDegree()
598    }
599    pub fn set_gamma(&mut self, gamma: f64) {
600        self.inner.pin_mut().setGamma(gamma)
601    }
602    pub fn get_gamma(&self) -> f64 {
603        self.inner.getGamma()
604    }
605    pub fn get_degree(&self) -> u64 {
606        self.inner.getDegree()
607    }
608    pub fn get_expected_average_degree(&self) -> f64 {
609        self.inner.getExpectedAverageDegree()
610    }
611}
612
613impl Algorithm for PowerlawDegreeSequence {
614    fn run(&mut self) -> miette::Result<()> {
615        self.inner.pin_mut().run().into_diagnostic()
616    }
617
618    fn has_finished(&self) -> bool {
619        self.inner.hasFinished()
620    }
621}
622
623pub struct PubWebGenerator {
624    inner: UniquePtr<bridge::PubWebGenerator>,
625}
626
627impl PubWebGenerator {
628    pub fn new(
629        num_nodes: u64,
630        num_dense_areas: u64,
631        neighbourhood_radius: f64,
632        max_num_neighbours: u64,
633    ) -> Self {
634        let inner = NewPubWebGenerator(
635            num_nodes,
636            num_dense_areas,
637            neighbourhood_radius,
638            max_num_neighbours,
639        );
640        Self { inner }
641    }
642    pub fn get_coordinates(&self) -> impl Iterator<Item = (f64, f64)> {
643        let mut xs = vec![];
644        let mut ys = vec![];
645        PubWebGeneratorGetCoordinates(&self.inner, &mut xs, &mut ys);
646        xs.into_iter().zip(ys)
647    }
648}
649
650impl StaticGraphGenerator for PubWebGenerator {
651    fn generate(&mut self) -> crate::Graph {
652        PubWebGeneratorGenerate(self.inner.pin_mut()).into()
653    }
654}
655
656pub struct RegularRingLatticeGenerator {
657    inner: UniquePtr<bridge::RegularRingLatticeGenerator>,
658}
659
660impl RegularRingLatticeGenerator {
661    pub fn new(num_nodes: u64, num_neighbours: u64) -> Self {
662        let inner = NewRegularRingLatticeGenerator(num_nodes, num_neighbours);
663        Self { inner }
664    }
665}
666
667impl StaticGraphGenerator for RegularRingLatticeGenerator {
668    fn generate(&mut self) -> crate::Graph {
669        RegularRingLatticeGeneratorGenerate(self.inner.pin_mut()).into()
670    }
671}
672
673pub struct RmatGenerator {
674    inner: UniquePtr<bridge::RmatGenerator>,
675}
676
677impl RmatGenerator {
678    pub fn new(
679        scale: u64,
680        edge_factor: u64,
681        a: f64,
682        b: f64,
683        c: f64,
684        d: f64,
685        weighted: bool,
686        reduce_nodes: u64,
687    ) -> Self {
688        let inner = NewRmatGenerator(scale, edge_factor, a, b, c, d, weighted, reduce_nodes);
689        Self { inner }
690    }
691}
692
693impl StaticGraphGenerator for RmatGenerator {
694    fn generate(&mut self) -> crate::Graph {
695        RmatGeneratorGenerate(self.inner.pin_mut()).into()
696    }
697}
698
699pub struct WattsStrogatzGenerator {
700    inner: UniquePtr<bridge::WattsStrogatzGenerator>,
701}
702
703impl WattsStrogatzGenerator {
704    pub fn new(n_nodes: u64, n_neighbours: u64, p: f64) -> Self {
705        let inner = NewWattsStrogatzGenerator(n_nodes, n_neighbours, p);
706        Self { inner }
707    }
708}
709
710impl StaticGraphGenerator for WattsStrogatzGenerator {
711    fn generate(&mut self) -> crate::Graph {
712        WattsStrogatzGeneratorGenerate(self.inner.pin_mut()).into()
713    }
714}
networkit_rs/generators.rs

networkit_rs/
generators.rs
