xrange | A pure-Python implementation of the xrange builtin | Performance Testing library

What I found so far: a commonly used method, e.g. in finite element simulations, is meshing or triangulation. The following is an attempt of a gnuplot implementation of the "Delaunay Triangulation" of a set of points. https://en.wikipedia.org/wiki/Delaunay_triangulation However, I'm aware that gnuplot is not really the tool for such a task.

So, probably, there are better solutions which I am not aware of. I am curious to learn about them.

Delaunay triangulation:

The following code is certainly not the most efficient way to get the triangulation, improvements are welcome

Procedure (short version):

1. sort your N data points by increasing x and if identical x then by increasing y
2. find the first m>=3 points which are not collinear
3. loop points from m to N

3.1) find all hull points whose connections to point m+1 do not intersect with any current hull segment

3.2) connect these hull points to point m+1 and modify the hull accordingly

1. loop all inner edges

4.1) find the 2 triangles containing the current edge. These form a quadrangle

4.2) if the quadrangle is convex, check if the diagonal needs to be flipped ("Lawson-flip")

4.3) start over with 4) until no flips are necessary anymore

In order to color the triangles

1. split each triangle into 3 quadrangles using the centroid as a 4th point

1. color the 3 sub-quadrangles according to the z-value of the respective data point

Comments:

• gnuplot has no native sort capability (especially sorting by >=2 columns), so you have to use sort (already included on Linux, on Windows you have to install, e.g. CoreUtils from GnuWin.
• Flipping the edges will take some time. I guess, it scales with O(n^2). So, above 100 datapoints it becomes unpractial, because it will simply take too long. But there seem to be algorithms which should run in O(n log n).
• Improvements are welcome, or maybe even an implementation in gnuplot would be great ;-)

Code:

As I understand, you have several questions:

1. fit a column versus another column while limiting the range by a third column
2. simplify the label with the fitting results
3. avoid warning: "Ignoring sample range in non-samples data"

ad 1: write a filter function, e.g. myRange(colD,colR,min,max) which returns NaN outside the desired range. colD is the data column, colR is the column for the range, min,max are the limits of the range.

ad 2: you can use newline \n in a label and use enhanced text. Check help enhanced. You can make a box around using set style textbox, might not work for all terminals, check help textbox. Still a bit confusing but certainly simpler than drawing many manually placed labels and arrows and boxes.

ad 3: again limit your plot via your filter function (see ad 1)

So, the following code:

1. plots the data in the full range
2. fits the data in a limited range, limited by a 3rd column
3. plots the fit in a given range, here: [0:0.58]
4. plots the residual in a limited range, limited by a 3rd column
5. places a label with the results

Maybe there are simpler solutions which I am currently not aware of.

Code:

In order to remove the rtics do set rtics scale 0.

You can set the starting angle for polar graph (check help theta), however, only to {right|top|left|bottom} and not to 45°, but this still wouldn't help you here. So, probably you have to set the labels "manually". Maybe there is an automatic way which I am not aware of. Check the following example.

Code:

It seems that using timedata inside stats is not implemented in gnuplot, at least in version 5.5. I found an (ugly) workaround based on gnuplot: xdata time & calculations that transforms the input time and the range definitions into seconds from 1.1.1970, compares whether the input value is larger than the lower bound and smaller than the upper bound; if yes, returns the actual y value, if not, returns NaN, which is then ignored by stats.

The multiprocessing module does provide true parallelism. The creation of Process objects and inter-process communication may create some overhead, so given T original time your parallel processed time will be (T/N)+x, where N is the number of Processes and x is the overhead. The larger the data, the more negligible x is.

On a side note, I'd suggeste looking into using Pools.

The map function does the chopping for you.

If you separate your sets by two empty lines you can easily address them via index (check help index). If you don't know the number of sets (or blocks) you can do stats (check help stats). You will find the number of blocks in the variable STATS_blocks (to see all variables type show var STATS). Check the following example as starting point for further optimization.

Attention: the option optimize in term gif might result in wrong colors (see: gnuplot: viewing angle dependent colors with 3D circles in GIF terminal) So, either don't optimize or export all frames as PNG (e.g. via term pngcairo) and use another software to create an animated GIF out of them.

Code:

The command defining f defines it as a symbolic function:

My understanding is that if you "plot" an image, it has to be within a graph. For your case, you could use multiplot, check help multiplot. You simply set the origins and sizes and remove the border and labels for the second plot. Furthermore, in order to avoid distortion you set the plot size ratio of the second plot the same as as your image (in your case 973 x 673 pixels). Check the following example as a starting point for further tweaking.

Code:

If we look at the training code, and the authors' paper,* we see that the loss function is a sum of two losses:

1. the raw model output (vector of probabilities for each bin category):