aziis98
/
asd-2024
mirror of https://github.com/aziis98/asd-2024.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix: added allow dead_code

Browse Source
main
Antonio De Lucreziis 2 months ago
parent 6209477a3f
commit 3fa06496f6
6 changed files with 99 additions and 104 deletions
Show Stats Download Patch File Download Diff File

180
examples/fdg-example/src/stress_majorization.rs
Unescape Escape View File

@ -1,99 +1,99 @@
use std::{
collections::HashMap,
hash::{BuildHasherDefault, Hash},
iter::Sum,
ops::AddAssign,
};
// use std::{
// collections::HashMap,
// hash::{BuildHasherDefault, Hash},
// iter::Sum,
// ops::AddAssign,
// };
// use nalgebra::{Point, SVector};
// use petgraph::stable_graph::NodeIndex;
// type HashFn = BuildHasherDefault<rustc_hash::FxHasher>;
use fdg::Field;
use nalgebra::Point;
#[derive(Debug, Clone)]
pub struct StressMajorizationConfiguration<F: Field> {
pub dt: F,
}
use petgraph::{
algo::{dijkstra, Measure},
graph::NodeIndex,
stable_graph::StableGraph,
};
use StressMajorizationConfiguration as Config;
impl<F: Field> Default for Config<F> {
fn default() -> Self {
Self {
dt: F::from(0.035).unwrap(),
}
}
}
/// A basic implementation
#[derive(Debug)]
pub struct StressMajorization<F: Field, const D: usize> {
pub conf: Config<F>,
pub shortest_path_matrix: HashMap<NodeIndex, HashMap<NodeIndex, F>>,
}
impl<F: Field + Measure + Sum, const D: usize> StressMajorization<F, D> {
pub fn new(conf: Config<F>) -> Self {
Self {
conf,
shortest_path_matrix: HashMap::new(),
}
}
fn apply<N: Clone, E: Clone>(&mut self, graph: &mut StableGraph<(N, Point<F, D>), E>) {
// if self.shortest_path_matrix.is_empty() {
// self.shortest_path_matrix = graph
// .node_indices()
// .map(|idx| {
// (idx, )
// })
// .collect();
// }
// let borrowed_graph: &StableGraph<(N, Point<F, D>), E> = graph;
self.shortest_path_matrix.extend(
graph
.node_indices()
.map(|idx| (idx, dijkstra(graph as &_, idx, None, |_| F::one()))),
)
}
fn calc_stress<N: Clone, E: Clone>(
&mut self,
graph: &mut StableGraph<(N, Point<F, D>), E>,
) -> F {
// graph
// .node_indices()
// .flat_map(|v| {
// graph.node_indices().skip(v.index() + 1).map(move |w| {
// let dist = nalgebra::distance(
// &graph.node_weight(v).unwrap().1,
// &graph.node_weight(w).unwrap().1,
// );
// if dist != F::zero() {
// let dij = self.shortest_path_matrix[&v][&w];
// let sp_diff = self.shortest_path_matrix[&v][&w] - dist;
// dij.simd_sqrt().abs() * sp_diff * sp_diff
// } else {
// F::zero()
// }
// })
// })
// .sum()
F::default()
}
}
// use fdg::Field;
// use nalgebra::Point;
// #[derive(Debug, Clone)]
// pub struct StressMajorizationConfiguration<F: Field> {
// pub dt: F,
// }
// use petgraph::{
// algo::{dijkstra, Measure},
// graph::NodeIndex,
// stable_graph::StableGraph,
// };
// use StressMajorizationConfiguration as Config;
// impl<F: Field> Default for Config<F> {
// fn default() -> Self {
// Self {
// dt: F::from(0.035).unwrap(),
// }
// }
// }
// /// A basic implementation
// #[derive(Debug)]
// pub struct StressMajorization<F: Field, const D: usize> {
// pub conf: Config<F>,
// pub shortest_path_matrix: HashMap<NodeIndex, HashMap<NodeIndex, F>>,
// }
// impl<F: Field + Measure + Sum, const D: usize> StressMajorization<F, D> {
// pub fn new(conf: Config<F>) -> Self {
// Self {
// conf,
// shortest_path_matrix: HashMap::new(),
// }
// }
// fn apply<N: Clone, E: Clone>(&mut self, graph: &mut StableGraph<(N, Point<F, D>), E>) {
// // if self.shortest_path_matrix.is_empty() {
// // self.shortest_path_matrix = graph
// // .node_indices()
// // .map(|idx| {
// // (idx, )
// // })
// // .collect();
// // }
// // let borrowed_graph: &StableGraph<(N, Point<F, D>), E> = graph;
// self.shortest_path_matrix.extend(
// graph
// .node_indices()
// .map(|idx| (idx, dijkstra(graph as &_, idx, None, |_| F::one()))),
// )
// }
// fn calc_stress<N: Clone, E: Clone>(
// &mut self,
// graph: &mut StableGraph<(N, Point<F, D>), E>,
// ) -> F {
// // graph
// // .node_indices()
// // .flat_map(|v| {
// // graph.node_indices().skip(v.index() + 1).map(move |w| {
// // let dist = nalgebra::distance(
// // &graph.node_weight(v).unwrap().1,
// // &graph.node_weight(w).unwrap().1,
// // );
// // if dist != F::zero() {
// // let dij = self.shortest_path_matrix[&v][&w];
// // let sp_diff = self.shortest_path_matrix[&v][&w] - dist;
// // dij.simd_sqrt().abs() * sp_diff * sp_diff
// // } else {
// // F::zero()
// // }
// // })
// // })
// // .sum()
// F::default()
// }
// }
// impl<const D: usize, N, E> Force<f32, D, N, E> for StressMajorization<D> {
// fn apply(&mut self, graph: &mut ForceGraph<f32, D, N, E>) {

6
examples/graphs-1/src/gd.rs
Unescape Escape View File

@ -1,6 +1,8 @@
#![allow(dead_code)]
use std::collections::HashMap;
struct Graph {
pub struct Graph {
edges_from: Vec<u32>,
edges_to: Vec<u32>,
}
@ -27,7 +29,7 @@ impl Graph {
}
pub fn update(
graph: &Graph,
_graph: &Graph,
xs: &Vec<f32>,
ys: &Vec<f32>,
desired_distance_matrix: &HashMap<usize, HashMap<usize, f32>>,

9
examples/graphs-1/src/main.rs
Unescape Escape View File

@ -1,13 +1,6 @@
use std::{
collections::HashMap,
env,
io::{BufRead, BufReader},
ops::AddAssign,
time::Instant,
};
use std::{collections::HashMap, env, ops::AddAssign, time::Instant};
use asd::{gfa::Entry, parser};
use indicatif::ProgressIterator;
use macroquad::{prelude::*, rand, ui::root_ui};
use nalgebra::{Point2, SVector};
use petgraph::{algo::dijkstra, graph::NodeIndex, stable_graph::StableGraph};

1
src/gfa.rs
Unescape Escape View File

@ -15,6 +15,7 @@ impl Display for Orientation {
}
}
#[allow(dead_code)]
#[derive(Debug)]
pub enum Entry {
Header {

2
src/graph.rs
Unescape Escape View File

@ -6,7 +6,7 @@ use std::{
rc::Rc,
};
use indicatif::{ProgressIterator, ProgressStyle};
use indicatif::ProgressIterator;
#[derive(Debug)]
pub struct AdjacencyGraph<V>

5
src/parser.rs
Unescape Escape View File

@ -1,9 +1,8 @@
#![allow(dead_code)]
use std::{
borrow::Cow,
io::{self, BufRead, BufReader, Read},
str::FromStr,
thread,
time::Duration,
};
use indicatif::ProgressIterator;

Write Preview
Loading…
Cancel
Save