Fix issue #5. Add Type2D::XBar and Type2D::YBar

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pgfplots"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2021"
 license = "MIT"
 description = "A Rust library to generate publication-quality figures"

examples/rectangle_integration.rs

@@ -1,5 +1,5 @@
 use pgfplots::axis::{
- plot::{Plot2D, PlotKey},
+ plot::{Plot2D, PlotKey, Type2D},
  Axis, AxisKey,
 };
 
@@ -19,7 +19,10 @@ fn main() {
  .map(|i| (f64::from(i), f64::from(i * i)).into())
  .collect();
  // Currently have to "guess" the bar width. Still pending the \compat key
- rectangles.add_key(PlotKey::Custom(String::from("ybar, bar width=19.5")));
+ rectangles.add_key(PlotKey::Type2D(Type2D::YBar {
+ bar_width: 19.5,
+ bar_shift: 0.0,
+ }));
  rectangles.add_key(PlotKey::Custom(String::from("fill=gray!20")));
  rectangles.add_key(PlotKey::Custom(String::from("draw opacity=0.5")));
 

src/axis/plot.rs

@@ -6,7 +6,6 @@ use crate::ShowPdfError;
 
 // Only imported for documentation. If you notice that this is no longer the
 // case, please change it.
-#[cfg(feature = "inclusive")]
 #[allow(unused_imports)]
 use crate::Picture;
 
@@ -210,10 +209,10 @@ impl Plot2D {
 pub enum Type2D {
  /// Coordinates are simply connected by straight lines.
  SharpPlot,
- /// Interpolate smoothly between successive points. The internal [`f64`]
- /// corresponds to the tension; recommended initial value is
- /// `Type2D::Smooth(0.55)`. A higher value results in more "round" curves.
- Smooth(f64),
+ /// Interpolate smoothly between successive points. The `tension` controls
+ /// how "smooth" a plot is; recommended initial value is `Type2D::Smooth{
+ /// tension: 0.55 }`. A higher value results in more "round" curves.
+ Smooth { tension: f64 },
  /// Coordinates are connected with horizontal and vertical lines. Marks are
  /// placed to the left of each horizontal line.
  ConstLeft,
@@ -229,6 +228,34 @@ pub enum Type2D {
  JumpRight,
  /// Variant of [`Type2D::ConstMid`] which does not draw vertical lines.
  JumpMid,
+ /// Draw horizontal bars between the *y = 0* line and each coordinate. The
+ /// `bar_width` field controls the width of the horizontal bars, and
+ /// `bar_shift` controls the vertical shift. Unless you are plotting
+ /// multiple bars in the same [`Axis`], you most likely want
+ /// `bar_shift: 0.0`.
+ ///
+ /// # Note
+ ///
+ /// By default, `bar_width` and `bar_shift` are assumed to be in `pt` units.
+ /// If you want them to be interpreted as axis units (this is most likely
+ /// what you want), you need to add the plot to an [`Axis`], add the
+ /// [`Axis`] to a [`Picture`], and set `compat=1.7` or higher on the
+ /// [`Picture`].
+ XBar { bar_width: f64, bar_shift: f64 },
+ /// Draw vertical bars between the *x = 0* line and each coordinate. The
+ /// `bar_width` field controls the width of the vertical bars, and
+ /// `bar_shift` controls the horizontal shift. Unless you are plotting
+ /// multiple bars in the same [`Axis`], you most likely want
+ /// `bar_shift: 0.0`.
+ ///
+ /// # Note
+ ///
+ /// By default, `bar_width` and `bar_shift` are assumed to be in `pt` units.
+ /// If you want them to be interpreted as axis units (this is most likely
+ /// what you want), you need to add the plot to an [`Axis`], add the
+ /// [`Axis`] to a [`Picture`], and set `compat=1.7` or higher on the
+ /// [`Picture`].
+ YBar { bar_width: f64, bar_shift: f64 },
  /// Similar to [`Type2D::XBar`] except that it draws a single horizontal
  /// lines instead of rectangles.
  XComb,
@@ -242,13 +269,21 @@ impl fmt::Display for Type2D {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  match self {
  Type2D::SharpPlot => write!(f, "sharp plot"),
- Type2D::Smooth(tension) => write!(f, "smooth, tension={tension}"),
+ Type2D::Smooth { tension } => write!(f, "smooth, tension={tension}"),
  Type2D::ConstLeft => write!(f, "const plot mark left"),
  Type2D::ConstRight => write!(f, "const plot mark right"),
  Type2D::ConstMid => write!(f, "const plot mark mid"),
  Type2D::JumpLeft => write!(f, "jump mark left"),
  Type2D::JumpRight => write!(f, "jump mark right"),
  Type2D::JumpMid => write!(f, "jump mark mid"),
+ Type2D::XBar {
+ bar_width,
+ bar_shift,
+ } => write!(f, "xbar, bar width={bar_width}, bar shift={bar_shift}"),
+ Type2D::YBar {
+ bar_width,
+ bar_shift,
+ } => write!(f, "ybar, bar width={bar_width}, bar shift={bar_shift}"),
  Type2D::XComb => write!(f, "xcomb"),
  Type2D::YComb => write!(f, "ycomb"),
  Type2D::OnlyMarks => write!(f, "only marks"),

src/axis/plot/tests.rs

@@ -20,11 +20,45 @@ fn error_character_to_string() {
  );
 }
 
+// This test is here only to let us know if we added an enum variant
+// but we forgot to add unit tests for it
+//
+// If this fails, it is because you added a new variant.
+// Please do the following:
+// 1) Add a unit test for the new variant you added (see examples below).
+// 2) AFTER doing (1), add the new variant to the match.
+#[test]
+fn plot_type2d_tested() {
+ let type_2d = Type2D::OnlyMarks;
+ match type_2d {
+ Type2D::SharpPlot => (),
+ Type2D::Smooth { tension: _ } => (),
+ Type2D::ConstLeft => (),
+ Type2D::ConstRight => (),
+ Type2D::ConstMid => (),
+ Type2D::JumpLeft => (),
+ Type2D::JumpRight => (),
+ Type2D::JumpMid => (),
+ Type2D::XBar {
+ bar_width: _,
+ bar_shift: _,
+ } => (),
+ Type2D::YBar {
+ bar_width: _,
+ bar_shift: _,
+ } => (),
+ Type2D::XComb => (),
+ Type2D::YComb => (),
+ Type2D::OnlyMarks => (),
+ }
+ assert!(true);
+}
+
 #[test]
 fn type_2d_to_string() {
  assert_eq!(Type2D::SharpPlot.to_string(), String::from("sharp plot"));
  assert_eq!(
- Type2D::Smooth(0.55).to_string(),
+ Type2D::Smooth { tension: 0.55 }.to_string(),
  String::from("smooth, tension=0.55")
  );
  assert_eq!(
@@ -45,6 +79,38 @@ fn type_2d_to_string() {
  String::from("jump mark right")
  );
  assert_eq!(Type2D::JumpMid.to_string(), String::from("jump mark mid"));
+ assert_eq!(
+ Type2D::XBar {
+ bar_width: 0.5,
+ bar_shift: 1.0
+ }
+ .to_string(),
+ String::from("xbar, bar width=0.5, bar shift=1")
+ );
+ assert_eq!(
+ Type2D::XBar {
+ bar_shift: 1.0,
+ bar_width: 0.5
+ }
+ .to_string(),
+ String::from("xbar, bar width=0.5, bar shift=1")
+ );
+ assert_eq!(
+ Type2D::YBar {
+ bar_width: 0.5,
+ bar_shift: 1.0
+ }
+ .to_string(),
+ String::from("ybar, bar width=0.5, bar shift=1")
+ );
+ assert_eq!(
+ Type2D::YBar {
+ bar_shift: 1.0,
+ bar_width: 0.5
+ }
+ .to_string(),
+ String::from("ybar, bar width=0.5, bar shift=1")
+ );
  assert_eq!(Type2D::XComb.to_string(), String::from("xcomb"));
  assert_eq!(Type2D::YComb.to_string(), String::from("ycomb"));
  assert_eq!(Type2D::OnlyMarks.to_string(), String::from("only marks"));