No worries if you want to stick with Travis for CI, but thought I'd throw it up to see what you thought. Since it's coming from a fork you won't see the CI running, but see this PR on my fork for what it'd look like for future PRs if you merged.

Hi

I've started using this library in some test code I've been writing and I've reached a few places where I would like to be able to create a scatter plot.

Would it be possible/easy to implement scatter plots into this library?

Thanks

This PR adds a binary of the same name to the crate. It introduces a breaking change in the API. Resolves #21, resolves #20.

Changes

• Add src/main.rs.

• Change Shape::Continous in src/lib.rs.

  Before:

  pub enum Shape<'a> {
     Continuous(fn(f32) -> f32),
     ...
  }
  

  After:

  pub enum Shape<'a> {
     Continuous(Box<dyn FnMut(f32) -> f32 + 'a>),
     ...
  }
  

  This is a breaking change in the API, so the minor version must be increased. I explained the motivation behind it in #21. I don't believe it is possible to add a dynamic math expression parser without introducing this change.

  I also added #![feature(box_syntax)] on top of every example and box before each closure, including the examples in documentation and README.md. If you do not wish to include this line each time you can switch to stable syntax: Box::new(...). Alternative solutions are provided in #21.

  This change is incompatible with #14 (no_std support) as it requires allocating Boxes. A possible solution is to use references or generic types in Shape. Another solution is to move drawing logic from Chart to shapes and introduce a Shape trait instead of an enum with predefined types in its fields.

• Change version in Cargo.toml to 0.6.0.

• Set edition = "2018" in Cargo.toml. Add bin and lib sections to Cargo.toml.

  This makes configuring a separate binary and library easier. I also removed each extern crate since they are not necessary in the 2018 edition.

• Use clap to parse args and display pretty info about the binary.

• Use meval to parse math expressions.

Behavior

Basic usage (prints the formula and displays the plot)

$ textplots 'e ^ (1 / x)'

Error info on no formula

$ textplots
error: The following required arguments were not provided:
    <FORMULA>
    
USAGE:
    textplots <FORMULA>
        
For more information try --help

--help

$ textplots --help
textplots 0.6.0
Alexey Suslov <[email protected]>
Terminal plotting library.

USAGE:
    textplots <FORMULA>
    
FLAGS:
    -h, --help       Prints help information
    -V, --version    Prints version information

ARGS:
    <FORMULA>    Formula to plot

Error info on unknown variable

$ textplots 'y'
Evaluation error: unknown variable `y`.

Error on unexpected token

$ textplots `100x`
Parse error: Unexpected token at byte 3.

Possible future development

• Custom math parsing errors.
• Multiple plots.
• Colors (#10).
• Receiving input from pipes.

Just something quick to be able to throw a Y-axis label on the generated plot. Happy to change anything if you don't like the implementation, I went with the Option<String> to make it work safely with existing code.

I cannot set these and the defaults aren't always pretty:

⡁⣾    ⣾    ⡀          ⣾  ⢀⢾       ⢰⠉⡇     204.3
⠄⣿   ⡸⢸   ⢸⡇         ⢠⢻  ⡎⢸       ⢸ ⡇    
⠂⣿   ⡇⢸   ⢸⡇  ⢀      ⡸⢸  ⡇⢸       ⢸ ⡇    
⡁⣿   ⡇⢸   ⢸⡇  ⣿      ⡇⢸  ⡇⢸       ⢸ ⡇    
⠄⣿   ⡇⢸   ⢸⡇  ⣿      ⡇⢸  ⡇⢸       ⢸ ⡇    
⠂⠏⡆  ⡇⢸   ⢸⢣  ⣿      ⡇⢸  ⡇⢸  ⡀    ⢸ ⢱    
⡁ ⡇  ⡇⢸   ⢸⢸ ⢀⢿      ⡇⢸  ⡇⢸ ⢸⡇    ⢸ ⢸    
⠄ ⡇  ⡇⢸   ⢸⢸ ⢸⢸      ⡇⢸  ⡇⢸ ⢸⡇    ⢸ ⢸    
⠂ ⡇  ⡇⢸   ⢸⢸ ⢸⢸      ⡇⢸  ⡇⢸ ⡇⡇    ⡎ ⢸    
⡁ ⡇  ⡇⢸ ⢀⡄⢸⢸ ⢸⢸      ⡇⢸  ⡇⢸ ⡇⡇   ⢰⠁ ⢸    
⠄ ⠑⠒⠒⠃⠈⠒⠃⠑⠚⠈⠒⠚⠘⠤⠒⠒⠒⠒⠒⠃⠈⠒⠒⠃ ⠉⠁⠑⠒⠒⠒⠚  ⠈⠒⠒⠒⠄
⠂                                        
⡁                                        
⠄                                        
⠂                                        
⡁                                        
⠄                                        
⠂                                        
⡁                                        
⠄                                        
⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁⠈ ⠁  10.0

I would like to be able to set these as well as perhaps a method to shrink wrap to the min and max from the slice.

This PR adds a new method, to_string(), which will return an owned String of the rendered plot. This String can then be used with custom logging or reporting methods instead of just being piped to stdout.

Instead of impl'ing the From/Into trait(s) a to_string() method was used which is more consistent with the std library's conversion to strings.

Issue: https://github.com/loony-bean/textplots-rs/issues/29

Here https://crates.io/crates/textplots the project erroneously has the category "Command line utilities".

Could you please remove it?

Thanks, Yuri

Hi! I really like this crate. Would you consider adding a binary so that it could be used as a standalone CLI tool? It would be perfect in a situation where I want to plot something quickly. I know the implementation would require parsing math expressions, handling input/output etc. which may be beyond the scope of this crate so I understand if that's not your goal.

Chart::display() output directly with println!()

It would be nice to be able to return a String. That allows for example to transfer over a network or include a log file.

It seems relatively staightforward to use format!() instead and allow this additional method. The issue might be more a consistent API pattern (display() vs display_string() etc) across the library for similiar situations.

There's a nasty bug that renders badly any chart involving multiple lineplots.

I made a simple example to illustrate the problem.

All the lines should be parallel to each other, and there should be only one x axis displayed. But an axis gets displayed per lineplot, and all the lines converge to the same point.

extern crate textplots;
use textplots::{Chart, Plot, Shape};

fn main() {
    let (mut l1, mut l2, mut l3) = (vec![], vec![], vec![]);
    for n in -2..=2 {
        l1.push((n as f32, n as f32));
        l2.push((n as f32, n as f32 - 1.));
        l3.push((n as f32, n as f32 - 2.));
    }
    println!("\nf(x)=x; f(x)=x-1; f(x)=x-2");
    Chart::new(120, 80, -2., 2.)
        .lineplot(Shape::Lines(l1.as_slice()))
        .lineplot(Shape::Lines(l2.as_slice()))
        .lineplot(Shape::Lines(l3.as_slice()))
        .nice();

    let (mut l4, mut l5, mut l6) = (vec![], vec![], vec![]);
    for n in -2..=2 {
        l4.push((n as f32, n as f32));
        l5.push((n as f32, n as f32 + 1.));
        l6.push((n as f32, n as f32 + 2.));
    }
    println!("\nf(x)=x; f(x)=x+1; f(x)=x+2");
    Chart::new(120, 80, -2., 2.)
        .lineplot(Shape::Lines(l4.as_slice()))
        .lineplot(Shape::Lines(l5.as_slice()))
        .lineplot(Shape::Lines(l6.as_slice()))
        .nice();
}

Related: #8

They should only intersect at 0,0

⠑⢄                     ⣀⠤⠔⠒⠊⠉⠉⡉⠉⠉⠒⠒⠤⢄⡀                    ⢀⠔  100.0
  ⠑⢄⡀              ⢀⡠⠒⠉       ⠄      ⠈⠑⠢⣀               ⣀⠔⠁
    ⠈⠢⡀          ⡠⠔⠁          ⠂          ⠑⠤⡀          ⡠⠊
      ⠈⠑⢄⡀     ⡠⠊             ⡁            ⠈⠢⡀     ⣀⠔⠉
         ⠈⠒⢄⡀⡠⠊               ⠄              ⠈⠢⡀⣀⠔⠊
           ⢀⠎⠑⠢⢄⡀             ⠂             ⣀⠤⠒⠙⢄
          ⡔⠁    ⠈⠑⠢⠤⣀⡀        ⡁        ⣀⡠⠤⠒⠉     ⠱⡀
⠄⠠ ⠄⠠ ⠄⠠⢠⠎⠠ ⠄⠠ ⠄⠠ ⠄⠠ ⠌⠩⠑⠖⠲⠢⠤⠤⠤⠤⠤⠤⠤⠲⠒⠖⠩⠉⠄⠠ ⠄⠠ ⠄⠠ ⠄⠠⠈⢆⠠ ⠄⠠ ⠄⠠ ⠄
       ⡰⠁                     ⠂                     ⠣⡀
     ⢀⠜                       ⡁                      ⠑⡄
    ⢀⠎                        ⠄                       ⠘⢄
   ⢠⠃                         ⠂                        ⠈⢆
  ⡠⠃                          ⡁                         ⠈⢢
 ⡰⠁                           ⠄                           ⢣
⡰⠁                            ⠂                            ⠣
⠁                             ⠁                               -100.0
-10.0                                                    10.0

extern crate textplots;

use textplots::{Chart, Plot, Shape};

fn main() {
    Chart::default()
    .lineplot( Shape::Continuous( |x| { (-x.powf(2.0)) } ))
    .lineplot( Shape::Continuous( |x| { (x.powf(2.0)) } ))
    .display();
}

Hello, I've poked around a little bit, but can tend to miss stuff, so sorry if I have.

I'm looking to plot without the axis at all. I don't mind attempting to contribute to add this feature myself, but I wanted to check here first. Here is what my plots are looking like:

I would like both the axis, as well as the axis labels to be omitted. Is this possible? And if not, would it be desirable to add in to this library?

I've added the option of using colors also when displaying points. This is done by using the set_colored from drawille. The change follows the same notation as for Continuous I've also added an example sparse_color to illustrate a minimal use.

This adds the ability to specify a callback for formatting the min/max labels for both the x and y axis. This allows formatting the x axis as dates (#9) or adding units, and including colored strings.

I have also included a commit that changes the rendering order so that the axes are printed behind the plots. This prevents the white of the axes resetting the color of the plots. If you want, I can split this up into multiple PRs.

Example Code (from and to are chrono::NaiveDate):

        let mut chart = Chart::new(200, 40, 0.0, (to - from).num_days() as f32)
            .xaxis_formatter(move |x| format!("{}", from.clone() + Duration::days(x as i64)))
            .yaxis_formatter(move |y| format!("{:.1} {}", y, unit.clone().white()));

Result (without reordering commit):

Result (with reordering commit):

I'm using textplots as a lightweight lib only. Would it be possible to either split it into two crates, or use features, to have a structopt and meval dependencies free build?

⡁                             ⡇                                                             3.0
⠄                             ⡇                                                            
⠂                             ⡇                                                            
⡁                             ⡇                                                            
⠄                             ⡇                                                            
⠂                             ⡇                                                            
⡁                             ⡇                                                            
⠄                             ⡇                                                            
⠂                             ⡇                                                            
⡁                             ⡇                                                            
⠄                             ⡏⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⡇                              
⠂                             ⡇                             ⡇                              
⡁                             ⡇                             ⡇                              
⠄                             ⡇                             ⡇                              
⠂                             ⡇                             ⡇                              
⡁                             ⡇                             ⡇                              
⠄                             ⡇                             ⡇                              
⠂                             ⡇                             ⡇                              
⡁                             ⡇                             ⡇                              
⠄                             ⡇                             ⡇                              
                              ⠁                             ⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁ 1.0
0.0                                                                                    3.0

The first bar is missing its roof.

Hi

I updated my dependencies recently and code which was previously working on textplots 0.5.0 is no longer working on textplots 0.5.4

My problem is essentially that I want to break up the method chains with a loop.

let lines: Vec<_> = points.iter().map(|p| Shape::Lines(p)).collect();
for line in lines.iter() {
    chart.lineplot(line);
}
chart.display();

This strategy doesn't compile anymore.

error[E0499]: cannot borrow `chart` as mutable more than once at a time
   --> tests/bayesian_regression.rs:245:17
    |
245 |                 chart.lineplot(line);
    |                 ^^^^^ mutable borrow starts here in previous iteration of loop

error[E0499]: cannot borrow `chart` as mutable more than once at a time
   --> tests/bayesian_regression.rs:247:13
    |
245 |                 chart.lineplot(line);
    |                 ----- first mutable borrow occurs here
246 |             }
247 |             chart.display();
    |             ^^^^^
    |             |
    |             second mutable borrow occurs here
    |             first borrow later used here

I notice that the Chart used to take Shapes by value https://docs.rs/textplots/0.5.0/textplots/trait.Plot.html and it now borrows them https://docs.rs/textplots/0.5.4/textplots/trait.Plot.html

Would it be possible for you to add a second plot method which didn't return the mutable reference from the method? https://docs.rs/textplots/0.5.4/src/textplots/lib.rs.html#334

I think the returned mutable borrow while I still have the first is causing my problem.