What is Reddit's opinion of GnuPlot?

From 3.5 billion Reddit comments

Netspace passes 8,700PiB today. The rate of growth, and its 2nd derivative, are still going up.

The weekly growth is another record, 2,500PiB, which percentage wise is 68%.

It's clear the apparent slowdown of the 2nd derivative last week was transient, presumably due to the v1.1.4 client bug.

Data scraped from the chia explorer netspace graph, smoothed and processed using some hacky code, and rendered using gnuplot.

Data source: ETOPO1 1 Arc-Minute Global Relief Model, NOAA

Visualisation software: gnuplot (pm3d) after processing with GNU Octave.

Just FYI, gnuplot has LaTeX optimized output built in. It can output a ps/eps image together with TeX code for the text lables.

Check out section 5 and 6 of http://www.gnuplot.info/files/tutorial.pdf

Data scraped from the chia explorer netspace graph, smoothed and processed using some hacky code, and rendered using gnuplot.

I'd suggest using a program better than Excel for graphing. One good option is Gnuplot.

One thing you could consider is tracking V-points completed per "mileage" session, and average V-point per climb sent. I feel like that would be a nice compliment to projecting statistics.

I'd also consider tracking the "stopper" moves that occur in a particular V-grade. If you're able to diagnose any recurring weaknesses based on hold types or body positions or distances between holds, you can get a good sense of what you need to work on and the relative severity of each weakness.

There are many, many choices. However, sometimes the most helpful answer is not a list of many but instead only one or two so I'll name gnuplot which is just graphing, and Sage which does all kinds of calculations besides.

I used gnuplot 5.0. Here's my C program and gnuplot script.

#include <stdio.h>

int main(void) { unsigned long count[4][256] = {{0}}; unsigned long n = 0xdeadbeefUL; unsigned long i, j; for (i = 0; i < 10000000UL; i++) { n *= 0x9e3779b1UL; count[0][(n >> 0) & 0xff]++; count[1][(n >> 8) & 0xff]++; count[2][(n >> 16) & 0xff]++; count[3][(n >> 24) & 0xff]++; } for (i = 0; i < 4; i++) for (j = 0; j < 256; j++) printf("%lu %lu %lu\n", i, j, count[i][j]); return 0; }

Build and run:

$ cc -O3 -o prng prng.c $ ./prng > results

gnuplot script:

set term pngcairo enhanced size 1200, 800 set style fill solid set boxwidth 1.0

set multiplot layout 4, 1 \ title "n(0) = 0xdeadbeefUL, n *= 0x9e3779b1UL, 10,000,000 iterations"

set xrange [0:255] set xtics border 32 unset ytics unset key

set title 'byte 0' plot '<grep ^0 results' using 2:3 with boxes set title 'byte 1' plot '<grep ^1 results' using 2:3 with boxes set title 'byte 2' plot '<grep ^2 results' using 2:3 with boxes set title 'byte 3' plot '<grep ^3 results' using 2:3 with boxes

I use gnuplot for much of my graphing, and I know there are several tutorials on curve fitting for it. Here's the top google result:

http://www.duke.edu/~hpgavin/gnuplot.html (See section 7 on that page.)

> Terminal may not be as pretty, but can show the same information.

> Everything you can do in jupyter can be done without jupyter.

yup, jupyter just gave non-terminal users what terminal users already had.

visidata

ttyplot

gnuplot

I find the best approach for recall was to take notes with pen and paper at the time in a separate note book, using a ruler if needed for straight lines.

Then, outside class, type the notes up. Add PDFs of the lecture notes if useful. If putting in graphs, try and generate them rather than draw them - I used gnuplot to graph data and functions at the time; I'd now use matplotlib and Python, but that's personal preference. Either way round, keep the source that generates the graph as well as the graph itself, so that you can regenerate it with tweaks later.

I found that it was the second step, of typing up my notes, that really helped me learn the material; I had to read my notes, understand them, and write them up as English, and added cross references to other useful material (professor's web pages, text books etc). Because I wasn't under huge time pressure while writing them up, I could take the time to go "huh. This doesn't make sense any more", and find more material or go and ask the TA for help later.

In addition to this, I believe org-mode's tables also supports plotting using GNUplot, which can output PNGs which can be displayed in the framebuffer using fbi.

It depends of the task you want to do:

• gnuplot is a good alternative is you want to make graphs with raw data. Its only purpose is to present data so if that's all you need to do it'll work just fine.

• If you want to replace Matlab then GNU/Octave is the way to go. It uses the same syntax (or almost) so all your previous code should work without modifying it too much.

• R will come in handy if you want to analyze the data. Obviously it'll let you graph it as well.

Easiest may be to output Gnuplot scripts. For examples of what is possible, take a look at the examples. This solution is purely text based, so you don't need to GUI.

For in-app interactive plots in a Qt project, I've used QCustomPlot. However, that was years ago so better solutions may exist.

Created based on the Wikipedia list of terror attacks in france using Gnuplot with the eps output terminal. I then used inkscape to convert the result to svg. I did this instead of using the svg terminal directly because it produces too strong grid lines.

The data are binned by decade. With death numbers and wounded interlaced as red and green columns, with the corresponding numbers on the left y axis. I also show the number of separate attacks per decade as a blue line, with the corresponding numbers on the right y axis. The decades are 2006-2015 inclusive, and so on backwards, so this includes the recent large attack in Paris.

Firstly, here's a simple workaround: Overwrite pgnuplot.exe with gnuplot.exe. Or you can make a link.

Now, pgnuplot.exe appears to be deprecated and has been removed in version 5 of gnuplot. As far as I know, gnuplot.exe seems to do everything pgnuplot.exe does so I'm not entirely sure what the distinction is (historical reasons?).

I booted into Windows today to dig into this problem for a bit. Still haven't figured out everything yet but so far the problem seems to be:

• ~~The Haskell library doesn't invoke pgnuplot.exe correctly: it needs to be invoked with the <code>-persist</code> flag in order for the window to stay.~~

• Having said that, that alone wasn't enough to solve the problem; I'm still investigating why. It works if I invoke it in Command Prompt (pgnuplot -persist myplot.gp) but it still fails in GHCI.

Update: It seems that pgnuplot doesn't like it when you try to pipe in commands while simultaneously feeding in files as input arguments. I get this obscure error message in doing so:

> Can't find the gnuplot window

After inspecting src/win/pgnuplot.c, it seems that when pgnuplot.exe launches gnuplot.exe, it expects a window to appear. However, due to the presence of filenames in the arguments, gnuplot.exe assumed it was batch-mode and thus did not show any windows. It's as if the author of gnuplot altered the behavior of gnuplot.exe some time ago but never updated pgnuplot.exe in the process, perhaps because it was slated to be removed anyway.

You could start a gnuplot subprocess attached to a pipe and then printf() your plot commands to it. That keeps the C side very simple.

Edit: example using POSIX <code>popen()</code>.

If you are researching plotting engines I think the "change of mind" came with "Grammar of graphics" A book that analysed how graphics were made and what was their "language".

If you need to know how these plotting engines born, Gnuplot has some nice info in it's webpage (Just about how gnuplot born, but it's one of the first).

Then it all depends on what exactly do you want to know about plotting engines.

The basic graph (coloured, on white background) was done using gnuplot, output as SVG. Then I loaded that into inkscape, where I added the pseudo-neon effect and also the black rounded rectangle as background.

P.S. Thanks for all the positive comments, I've been reading /r/xcom for tips the past week, so nice to give something back.

Gnuplot is a quite powerful, free and cross-platform program. However, it's not very practical as a stand-alone utility (at least not for the casual user) as it doesn't have a GUI.

Another FOSS alternative is QtiPlot, which I haven't personally used, but apparently is similar to Origin.

What I like to do for my own daily expenses (since no one else is collaborating with me) is just keep a plain CSV file in a Git repository (not GitHub, just ordinary Git). You can attach metadata to commits, and track your commit history as well, which can be handy.

When I actually need to do computations on it or make plots, I have my choice of using a LibreOffice template file with no data, but formulas written into it, and LibreOffice can read CSV files into a spreadsheet in like 2 or 3 mouse clicks, so I populate the template with the latest CSV data and it generates the reports as soon as it is populated.

Or I can use CLI tools like GNU Plot, and also xsv which provides an SQL-like set of commands on CSV data. Between XSV and GNU Plot, I can generate HTML reports with a roughly 150-line Bash script.

It's a few additional steps, but I find it generally easier to maintain than an always-on Nextcloud instance.

Dunno what Desmos is but Gnuplot is a portable command-line driven graphing utility for Linux, OS/2, MS Windows, OSX, VMS, and many other platforms.

http://www.gnuplot.info/

License is not one of the 'standard' open source licenses but it probably qualifies, source is available and modifications are allowed to be redistributed.

Try Gnuplot http://www.gnuplot.info/ it’s quite easy to use and simple stuff f with it, but it’s really powerful, with curve fitting with any formula you want. Much more easy to start than Octave/Matlpot or Python.

There are a number of options depending on what you're expecting. If you want to work in a CLI but plot to a GUI window, <code>octave</code> offers some GUI plotting front-ends that might meet your need. It's a powerful tool for doing symbolic math, similar to Mathematica or Derive.

For other use cases, you can manipulate data and pipe results out to <code>gnuplot</code> for rendering graph data to various image formats.

Another option is to render data/graphs to the graphviz format for rendering. <code>@thingskatedid</code> had a good thread on Twitter about generating such data, rendering it to SVG format, and rendering those SVGs into a terminal in turn. You might also be able to get gnuplot to render to SVG, convert to PNG, and render the PNG to the terminal as that thread demonstrates. But the common theme is the pipeline of data → render to $FORMAT → render $FORMAT to the GUI or convert to a format that can be displayed on a terminal.

Look into rtl_power_fftw. It can be run for hours on any host (including a Raspberry Pi) and the spectrum results examined later.

I'm using this script to integrate results over 24 hours. Generates PNG graphs using gnuplot:

#!/bin/bash
reset
# rtl_power_fftw parameters
SAMPLE_RATE=2400000
FFT_SIZE=1024
START_FREQ=929000000
STEP=$(($SAMPLE_RATE / 2))
END_FREQ=939000000
INTEGRATION_TIME=86400
# Working and output paths
BASE_PATH="/workdrive/rtl_power_fftw/plot/"
WORK_PATH="$BASE_PATH/$START_FREQ-$END_FREQ"
# Exit if base path doesn't exist
if [[ ! -e $BASE_PATH ]]; then
echo "Base path doesn't exist! Exiting."
exit
fi
# Create work path if needed
mkdir -p $WORK_PATH
# Show frequency hops
for i in \seq $START_FREQ $STEP $END_FREQ`; do echo "Tune to $i for $INTEGRATION_TIME seconds" done # Do it for i in `seq $START_FREQ $STEP $END_FREQ`; do ./rtl_power_fftw -b $FFT_SIZE -f $i -g 496 -r $SAMPLE_RATE -t $INTEGRATION_TIME | `
tee "$WORK_PATH/$i.txt" | \
gnuplot -e "set term pngcairo size 1600,900; \
set key font ',8'; \
set xtics font 'Verdana,8'; \
set format x '%.3s%c'; \
unset key; \
set xtics 125000; \
set grid x y; \
show grid; \
set yrange [-70:0]; \
plot '-' w l" > "$WORK_PATH/$i.png"
done

I use Gnuplot for all my plotting and from C++ call it via gnuplot-iostream. It does contour plots no problem.

The API isn't amazing, but it does a ton of different plot types and you can call it from absolutely anywhere so you're not having to learn a new plotting suite and install a ton of dependencies for every language. Simple plots are simple and complex plots are possible.

Since this is a library which you'd use... it should be trivial to output to an image file. A lot more work if you wanted to make a CLI to describe the plots, but then there's gnuplot.

gnuplot. With help from sites like this, you'll be programmatically styling your ticmarks within the Postscript output in no time at all!

Octave is a great program to use, and the syntax for the most part is very similar to that of Matlab's.

Matlab has arguably one of the industry's best plotting packages built in. They have invested a ton of time and money into developing their plotting tools.

Octave, being open source, does not have such resources to "re-invent the wheel." Thus, when you plot something on Octave, the command is translated from the Matlab-like syntax that you enter, to commands for the program GnuPlot.

GnuPlot, by the way, is another excellent plotting package. It's been around for decades, and has many features that Matlab's plotting can't quite replicate. However, not all of this functionality is implemented in Octave. By striving to be "Matlab-like," Octave misses some of the features in GnuPlot.

Your first place to look should be the Octave manual, section on 3D plotting. Best to use the Octave manual here, instead of the Matlab manual, because there are subtle differences in the plot commands. It is quite likely that you can do everything you need from the information provided there.

If you cannot find what you need in Octave's features, then download yourself a copy of GnuPlot, and play with it. They have a great Gallary on their website, to see what kind of plots can be made, and what the code looks like to generate them. You will need to save your computations in Octave into a text file, and then write a code in GnuPlot that reads this file and plots the data as you desire.

I prefer tikz myself, but there is also Asymptote which also does a great job.

gnuplot also makes some very nice graphics that can be included.

I think matplotlib uses gnuplot, but don't quote me on it.

You can multiplot in gnuplot. And 3D plot. Lifesaver: http://www.gnuplot.info/demo/ and http://www.gnuplotting.org/

It's a finicky job to get it 100%, but once it's there you can reuse the entire file and just substitute the source data references, I.e. write once, use many.

What's the deployment environment?

GNUplot is fantastic at 'plotting data' and can 'print', or output, a variety of formats including eps, png, and especially for you.. svg

Based on data from this wikipedia table, and plotted using gnuplot.

This is a quick plot I made because a discussion on Hacker News again brought up how hard it has become to compare the so-called technology nodes - number like 5nm, 7nm or 10nm etc.. One of the main factors in processing speed is transistor density, and as this plot shows, it's not straightforward to translate the technology node number into transistor density after 14 nm or so. Lately Intel has been significantly denser than the number would indicate, while TSMC and especially Samsung are consistently low relative to their quoted node number. Their 7nm is close to Intel's 10 nm in density. However, they are still denser in absolute terms because Intel doesn't have anything smaller than 10 nm yet.

>I want to say that a lot of people in this field use AWK/grep/sed on a daily basis. Working with files consisting of hundreds of millions of lines is pretty common for us.

Does that mean your colleagues also use awk/sed/grep to parse the data? Just curious, can you say how large the files are in MB/GB? Since you're parsing the data, does that mean you're making charts/graphs?

You may like (gnuplot)[http://www.gnuplot.info/] as another command line tool.

I'm having a little trouble with "prepare academic figures".

If you are crafting graphics from raw data, R works and so does a bunch of other data >> graphics packages. I don't think inkscape or Illustrator are known for this so I'll move on after mentioning this:

http://www.gnuplot.info/

If you have the graphics and the data, but you just want it in a clear document lyx is pretty awesome.

https://www.lyx.org/

It has a lot of options, but you should be able to use it after reading the intro documentation. As I recall there are two documents the webpage mentions to get you started. The output can be pushed to more formats than you will ever want. It works on Linux as well as the lesser OSs in case you need to share the workload.

GNU Plot and Matlab worked very well for me. They'll easily handle what you you have to do. GNU Plot is FOSS and much quicker to install than Matlab, if you just need to make some graphs I'd go with GNU Plot.

Here you go! gnuplot is very powerful, but the syntax can be either really complex/strange, or, in this case, super simple (I mean, the plotting itself is only one line).

\documentclass{article} \usepackage{gnuplottex} \begin{document}

\begin{figure}[h] \begin{gnuplot} set terminal cairolatex pdf set size square unset key # hide legend unset xtics # no x-axis ticks unset ytics # no y-axis ticks set title '$f$ vs. $r$' set xlabel '$r$' set ylabel '$f$' # plot y=1/x over 0<x<1 as a line with width 2px plot [0:1] 1/x with lines linewidth 2 \end{gnuplot} \end{figure}

\end{document}

Compile it with pdflatex -shell-escape foo.tex to get this.

You might want to check out GNUPLOT. It is free and has a simple scripting language. It is used in many science departments around the world and there are many tutorials available for it. The plots it creates are publication quality, but it does a lot more than just plotting.

GNUPLOT ---> http://www.gnuplot.info/

Which shell are you running this script in? Are you trying to run it at the main command shell (ie: bash) or within gnuplot itself? I suspect the former. I copied the script you posted and called it 'test.gnu'. See below:

me@ubuntu:/tmp/test$ bash test.gnu test.gnu: line 5: syntax error near unexpected token x' test.gnu: line 5:f(x) = a*x+b' me@ubuntu:/tmp/test$

You should be running it using gnuplot:

me@ubuntu:/tmp/test$ gnuplot test.gnu "test.gnu", line 12: warning: Skipping unreadable file "dadoscalibracao" "test.gnu", line 12: Can't read data file

me@ubuntu:/tmp/test$

Obviously I get the 'unreadable file' error because the script tries to read a file of yours that I don't have on my system. You can also run it from within gnuplot directly:

me@ubuntu:/tmp/test$ gnuplot

G N U P L O T Version 4.6 patchlevel 4 last modified 2013-10-02 Build System: Linux x86_64

Copyright (C) 1986-1993, 1998, 2004, 2007-2013 Thomas Williams, Colin Kelley and many others

gnuplot home: http://www.gnuplot.info faq, bugs, etc: type "help FAQ" immediate help: type "help" (plot window: hit 'h')

Terminal type set to 'unknown' gnuplot> load "test.gnu" "test.gnu", line 12: warning: Skipping unreadable file "dadoscalibracao" "test.gnu", line 12: Can't read data file

gnuplot>

> What exactly is the -persist flag doing?

It's a flag for gnuplot which tells it to not close the window when it's done rendering.

After a second look, I don't think -persist is actually needed, since the library already includes a pause command at the very end of the input, which achieves roughly the same effect.

> how do I properly use it in ghci syntax?

You can't because the Haskell library doesn't provide a means to do so.

There are some flags you have to pass into gnuplot to make it stay, but it's been a while since I've used gnuplot so you'll have to look at the docs and play around a bit. You'll have to see if the library provides a means to do that as well.

> I don't think it's coincidence they called it "gnuplot". Probably it was intended to be used alongside the GNU system, even if it was not really part of the project or followed the same license.

Nope, the name’s a compromise between more or less silly alternatives.

Not rudimentary at all. Most of the tables I work with are to keep track of running calculations, their parameters, and statuses. It's simply easier for me to have it in one window with text-based notes interspersed than having to deal with an extra window on my desktop and extra CPU drain from an application as resource-heavy as excel.

Also, for data analysis, instead of excel-based tools, I use grace, gnuplot, and, most recently, matplotlib within python. Previously I would have a mess of scripts scattered about the directory structure of my data to plot this or that. With org-mode, every script is embedded and callable from the same file and sits right next to my analysis notes.

That is true, but if a good effort was taken to pick the good releases of software projects, the bug often belongs to that project, not really to archlinux itself.(Infact isn't the point of archlinux that people choose packages themselves?)

Bugs can be 'the obvious' way to suck though. 'Frameworks' can get stuff written for them.. stuck in a framework. People might not want to install the framework, or the framework is hard to install/heavy.

For instance i find gnuplot kindah sucks for not having a C interface. Cute reason for the name, but the name is still annoying.

Maybe GNUplot? I haven't used it, but I believe it does what you're asking. It does require some coding, but I think creating scatter plots is a common application that templates may exist for.