Skip to content

Commit da7224c

Browse files
bgkillasbgkillas
committed
fix clippy
1 parent 091a6dd commit da7224c

2 files changed

Lines changed: 168 additions & 182 deletions

File tree

‎src/app.rs‎

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -169,14 +169,16 @@ impl App {
169169
var: rupl::types::Vec2::new(options.xr.0, options.xr.1),
170170
count_changed: false,
171171
};
172-
let (graph, complex) = data.generate_3d(
172+
let mut graph = Vec::new();
173+
let complex = data.generate_3d(
173174
options.xr.0,
174175
options.yr.0,
175176
options.xr.1,
176177
options.yr.1,
177178
options.samples_3d.0,
178179
options.samples_3d.1,
179180
None,
181+
&mut graph,
180182
);
181183
let names = &[(Vec::new(), "sin(1/z)".to_string())];
182184
let names = get_names(&graph, names);

‎src/data.rs‎

Lines changed: 165 additions & 181 deletions
Original file line numberDiff line numberDiff line change
@@ -384,33 +384,29 @@ impl Data {
384384
buffer.push(GraphType::None)
385385
}
386386
}
387-
buffer
388-
.into_par_iter()
389-
.enumerate()
390-
.map(|(mut i, b)| {
391-
if let Some(n) = n {
392-
i = n;
393-
}
394-
if self.blacklist.contains(&i) {
395-
return false;
396-
}
397-
let Some(data) = &self.data[i] else {
398-
return false;
399-
};
400-
if !data.graph_type.is_3d_o() {
401-
return false;
402-
}
403-
match (data.graph_type.is_3d_i(), data.graph_type.on_var()) {
404-
(true, false) => self.get_3d(data, startx, starty, endx, endy, lenx, leny, b),
405-
(true, true) => self.get_3d(
406-
data, self.var.x, self.var.x, self.var.y, self.var.y, lenx, leny, b,
407-
),
408-
(false, true) => self.get_2d(data, self.var.x, self.var.y, lenx * leny, b),
409-
(false, false) => None,
410-
}
411-
.unwrap_or(false)
412-
})
413-
.any(|b| b)
387+
buffer.into_par_iter().enumerate().any(|(mut i, b)| {
388+
if let Some(n) = n {
389+
i = n;
390+
}
391+
if self.blacklist.contains(&i) {
392+
return false;
393+
}
394+
let Some(data) = &self.data[i] else {
395+
return false;
396+
};
397+
if !data.graph_type.is_3d_o() {
398+
return false;
399+
}
400+
match (data.graph_type.is_3d_i(), data.graph_type.on_var()) {
401+
(true, false) => self.get_3d(data, startx, starty, endx, endy, lenx, leny, b),
402+
(true, true) => self.get_3d(
403+
data, self.var.x, self.var.x, self.var.y, self.var.y, lenx, leny, b,
404+
),
405+
(false, true) => self.get_2d(data, self.var.x, self.var.y, lenx * leny, b),
406+
(false, false) => None,
407+
}
408+
.unwrap_or(false)
409+
})
414410
}
415411
#[allow(clippy::too_many_arguments)]
416412
pub fn get_3d(
@@ -695,139 +691,131 @@ impl Data {
695691
let xs = startx + (slice as f64 + lenx as f64 / 2.0) * dx;
696692
#[cfg(feature = "kalc-lib")]
697693
let x = NumStr::new(Number::from_f64(xs, &self.options));
698-
buffer
699-
.into_par_iter()
700-
.enumerate()
701-
.map(|(mut i, buf)| {
702-
if let Some(n) = n {
703-
i = n;
704-
}
705-
if self.blacklist.contains(&i) {
706-
return false;
707-
}
708-
let Some(data) = &self.data[i] else {
709-
return false;
710-
};
711-
if let Val::Num(Some(c)) = data.graph_type.val {
712-
*buf = GraphType::Constant(c, data.graph_type.inv());
713-
matches!(c, Complex::Complex(_, _) | Complex::Imag(_))
714-
} else {
694+
buffer.into_par_iter().enumerate().any(|(mut i, buf)| {
695+
if let Some(n) = n {
696+
i = n;
697+
}
698+
if self.blacklist.contains(&i) {
699+
return false;
700+
}
701+
let Some(data) = &self.data[i] else {
702+
return false;
703+
};
704+
if let Val::Num(Some(c)) = data.graph_type.val {
705+
*buf = GraphType::Constant(c, data.graph_type.inv());
706+
matches!(c, Complex::Complex(_, _) | Complex::Imag(_))
707+
} else {
708+
#[cfg(feature = "kalc-lib")]
709+
let mut modified = place_var(data.func.clone(), xstr, x.clone());
710+
#[cfg(feature = "kalc-lib")]
711+
let mut modifiedvars = place_funcvar(data.funcvar.clone(), xstr, x.clone());
712+
#[cfg(feature = "kalc-lib")]
713+
simplify(&mut modified, &mut modifiedvars, self.options);
714+
match &data.graph_type.val {
715+
Val::Num(_) => {
716+
let data = (0..=leny)
717+
.into_par_iter()
718+
.map(|i| {
719+
let y = starty + i as f64 * dy;
720+
#[cfg(feature = "kalc-lib")]
721+
let y = NumStr::new(Number::from_f64(y, &self.options));
722+
#[cfg(feature = "kalc-lib")]
723+
if let Ok(Num(n)) = do_math(
724+
place_var(modified.clone(), ystr, y.clone()),
725+
self.options,
726+
place_funcvar(modifiedvars.clone(), ystr, y),
727+
) {
728+
Complex::Complex(
729+
n.number.real().to_f64(),
730+
n.number.imag().to_f64(),
731+
)
732+
} else {
733+
Complex::Complex(f64::NAN, f64::NAN)
734+
}
735+
#[cfg(not(feature = "kalc-lib"))]
736+
f3(xs, y)
737+
})
738+
.collect::<Vec<Complex>>();
739+
#[cfg(feature = "kalc-lib")]
740+
let (a, b) = compact(data);
741+
#[cfg(not(feature = "kalc-lib"))]
742+
let (a, b) = (data, is_complex());
743+
*buf = GraphType::Width3D(a, starx, stary, enx, eny);
744+
b
745+
}
715746
#[cfg(feature = "kalc-lib")]
716-
let mut modified = place_var(data.func.clone(), xstr, x.clone());
747+
Val::Vector(_) => {
748+
*buf = GraphType::None;
749+
false
750+
}
717751
#[cfg(feature = "kalc-lib")]
718-
let mut modifiedvars = place_funcvar(data.funcvar.clone(), xstr, x.clone());
752+
Val::Vector3D => {
753+
*buf = GraphType::None;
754+
false
755+
}
719756
#[cfg(feature = "kalc-lib")]
720-
simplify(&mut modified, &mut modifiedvars, self.options);
721-
match &data.graph_type.val {
722-
Val::Num(_) => {
723-
let data = (0..=leny)
724-
.into_par_iter()
725-
.map(|i| {
726-
let y = starty + i as f64 * dy;
727-
#[cfg(feature = "kalc-lib")]
728-
let y = NumStr::new(Number::from_f64(y, &self.options));
729-
#[cfg(feature = "kalc-lib")]
730-
if let Ok(Num(n)) = do_math(
731-
place_var(modified.clone(), ystr, y.clone()),
732-
self.options,
733-
place_funcvar(modifiedvars.clone(), ystr, y),
734-
) {
735-
Complex::Complex(
736-
n.number.real().to_f64(),
737-
n.number.imag().to_f64(),
738-
)
739-
} else {
740-
Complex::Complex(f64::NAN, f64::NAN)
741-
}
742-
#[cfg(not(feature = "kalc-lib"))]
743-
f3(xs, y)
744-
})
745-
.collect::<Vec<Complex>>();
746-
#[cfg(feature = "kalc-lib")]
747-
let (a, b) = compact(data);
748-
#[cfg(not(feature = "kalc-lib"))]
749-
let (a, b) = (data, is_complex());
750-
*buf = GraphType::Width3D(a, starx, stary, enx, eny);
751-
b
757+
Val::List => {
758+
let mut ndata: Vec<Vec<(f64, f64, Complex)>> = Vec::with_capacity(leny + 1);
759+
for i in 0..=leny {
760+
let xv = starty + i as f64 * dx;
761+
let x = NumStr::new(Number::from_f64(xv, &self.options));
762+
if let Ok(Vector(v)) = do_math(
763+
place_var(modified.clone(), ystr, x.clone()),
764+
self.options,
765+
place_funcvar(modifiedvars.clone(), ystr, x),
766+
) {
767+
let mut v = v.into_iter();
768+
ndata.extend(vec![Vec::new(); v.len().saturating_sub(ndata.len())]);
769+
for data in ndata.iter_mut() {
770+
let n = v
771+
.next()
772+
.map(|n| {
773+
(
774+
xs,
775+
xv,
776+
Complex::Complex(
777+
n.number.real().to_f64(),
778+
n.number.imag().to_f64(),
779+
),
780+
)
781+
})
782+
.unwrap_or((
783+
f64::NAN,
784+
f64::NAN,
785+
Complex::Complex(f64::NAN, f64::NAN),
786+
));
787+
data.push(n)
788+
}
789+
}
752790
}
753-
#[cfg(feature = "kalc-lib")]
754-
Val::Vector(_) => {
755-
*buf = GraphType::None;
791+
let mut b = false;
792+
*buf = GraphType::List(
793+
ndata
794+
.into_iter()
795+
.map(|data| {
796+
let (a, c) = compact_coord3d(data);
797+
b |= c;
798+
GraphType::Coord3D(a)
799+
})
800+
.collect(),
801+
);
802+
b
803+
}
804+
#[cfg(feature = "kalc-lib")]
805+
Val::Matrix(m) => {
806+
if let Mat::D2(m) = m {
807+
*buf = GraphType::Coord(
808+
m.iter().map(|m| (m.x, Complex::Real(m.y))).collect(),
809+
);
756810
false
757-
}
758-
#[cfg(feature = "kalc-lib")]
759-
Val::Vector3D => {
811+
} else {
760812
*buf = GraphType::None;
761813
false
762814
}
763-
#[cfg(feature = "kalc-lib")]
764-
Val::List => {
765-
let mut ndata: Vec<Vec<(f64, f64, Complex)>> =
766-
Vec::with_capacity(leny + 1);
767-
for i in 0..=leny {
768-
let xv = starty + i as f64 * dx;
769-
let x = NumStr::new(Number::from_f64(xv, &self.options));
770-
if let Ok(Vector(v)) = do_math(
771-
place_var(modified.clone(), ystr, x.clone()),
772-
self.options,
773-
place_funcvar(modifiedvars.clone(), ystr, x),
774-
) {
775-
let mut v = v.into_iter();
776-
ndata.extend(vec![
777-
Vec::new();
778-
v.len().saturating_sub(ndata.len())
779-
]);
780-
for data in ndata.iter_mut() {
781-
let n = v
782-
.next()
783-
.map(|n| {
784-
(
785-
xs,
786-
xv,
787-
Complex::Complex(
788-
n.number.real().to_f64(),
789-
n.number.imag().to_f64(),
790-
),
791-
)
792-
})
793-
.unwrap_or((
794-
f64::NAN,
795-
f64::NAN,
796-
Complex::Complex(f64::NAN, f64::NAN),
797-
));
798-
data.push(n)
799-
}
800-
}
801-
}
802-
let mut b = false;
803-
*buf = GraphType::List(
804-
ndata
805-
.into_iter()
806-
.map(|data| {
807-
let (a, c) = compact_coord3d(data);
808-
b |= c;
809-
GraphType::Coord3D(a)
810-
})
811-
.collect(),
812-
);
813-
b
814-
}
815-
#[cfg(feature = "kalc-lib")]
816-
Val::Matrix(m) => {
817-
if let Mat::D2(m) = m {
818-
*buf = GraphType::Coord(
819-
m.iter().map(|m| (m.x, Complex::Real(m.y))).collect(),
820-
);
821-
false
822-
} else {
823-
*buf = GraphType::None;
824-
false
825-
}
826-
}
827815
}
828816
}
829-
})
830-
.any(|b| b)
817+
}
818+
})
831819
}
832820
pub(crate) fn generate_2d(
833821
&self,
@@ -843,37 +831,33 @@ impl Data {
843831
buffer.push(GraphType::None)
844832
}
845833
}
846-
buffer
847-
.into_par_iter()
848-
.enumerate()
849-
.map(|(mut i, b)| {
850-
if let Some(n) = n {
851-
i = n;
852-
}
853-
if self.blacklist.contains(&i) {
854-
return false;
855-
}
856-
let Some(data) = &self.data[i] else {
857-
return false;
858-
};
859-
match (data.graph_type.is_3d_i(), data.graph_type.on_var()) {
860-
(true, true) => self.get_3d(
861-
data,
862-
self.var.x,
863-
self.var.x,
864-
self.var.y,
865-
self.var.y,
866-
len.isqrt(),
867-
len.isqrt(),
868-
b,
869-
),
870-
(false, true) => self.get_2d(data, self.var.x, self.var.y, len, b),
871-
(false, false) => self.get_2d(data, start, end, len, b),
872-
(true, false) => None,
873-
}
874-
.unwrap_or(false)
875-
})
876-
.any(|b| b)
834+
buffer.into_par_iter().enumerate().any(|(mut i, b)| {
835+
if let Some(n) = n {
836+
i = n;
837+
}
838+
if self.blacklist.contains(&i) {
839+
return false;
840+
}
841+
let Some(data) = &self.data[i] else {
842+
return false;
843+
};
844+
match (data.graph_type.is_3d_i(), data.graph_type.on_var()) {
845+
(true, true) => self.get_3d(
846+
data,
847+
self.var.x,
848+
self.var.x,
849+
self.var.y,
850+
self.var.y,
851+
len.isqrt(),
852+
len.isqrt(),
853+
b,
854+
),
855+
(false, true) => self.get_2d(data, self.var.x, self.var.y, len, b),
856+
(false, false) => self.get_2d(data, start, end, len, b),
857+
(true, false) => None,
858+
}
859+
.unwrap_or(false)
860+
})
877861
}
878862
pub(crate) fn get_2d(
879863
&self,

0 commit comments

Comments
 (0)