Plot coordinate pairs: Difference between revisions

 

;Task:

 

Post the resulting image for the following input arrays (taken from [[Time_a_function#Python|Python's Example section on ''Time a function'']]):

 

This task is intended as a subtask for [[Measure relative performance of sorting algorithms implementations]].

<br><br>

 

=={{header|Ada}}==

{{libheader|GtkAda}}

[[Image:Gtkada_plot.png|thumb|right|100px|Example GtkAda plot]]

with Gtk.Main;

with Gtk.Window; use Gtk.Window;

Gtk.Main.Main;

end PlotCoords;

=={{header|ALGOL 68}}==

{{works with|ALGOL 68|Revision 1 - extensions to standard used - PRAGMA READ and Currying}}

{{wont work with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release [http://sourceforge.net/projects/algol68/files/algol68toc/algol68toc-1.8.8d/algol68toc-1.8-8d.fc9.i386.rpm/download 1.8-8d] - due to extensive use of '''format'''[ted] ''transput''.}}

[[Image:Plot_coordinate_pairs-Algol68.gif|thumb|right|100px|Example Algol68 plot]]

# -*- coding: utf-8 -*- #

 

);

 

 

=={{header|AutoHotkey}}==

{{works with|AutoHotkey_L}}(AutoHotkey1.1+)

{{libheader|GDIP}}

#NoEnv

SetBatchLines, -1

Exit:

Gdip_Shutdown(pToken)

 

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

[[Image:Coordinate_pair_bbc.gif|right]]

x() = 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

y() = 2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0

DRAW 100*x(i%),4*y(i%)

ENDIF

 

=={{header|C}}==

 

{{libheader|libplot}}

#include <stdlib.h>

#include <math.h>

pl_flushpl();

pl_closepl();

 

No one would use the previous code to produce a plot (that looks [http://i40.tinypic.com/f2t0l0.png this way]; instead, normally we produce data through a program, then we plot the data using e.g. [[Plot x, y arrays#gnuplot|gnuplot]] or other powerful tools; the result (with gnuplot and without enhancement) could look [http://i41.tinypic.com/2qivbsn.png like this] instead.

===Writing EPS===

[[File:plot-2d-c.png|center]]Following code creates a plot in EPS format, with auto scaling and line/symbol/color controls. Plotting function loosely follows Matlab command style. Not thorough by any means, just to give an idea on how this kind of things can be coded.

#include <math.h>

#include <string.h>

plot(x, y, N, "r-o");

return 0;

 

=={{header|C++}}==

[[File:plot_cpp.png|300px]]

#include <windows.h>

#include <string>

}

//--------------------------------------------------------------------------------------------------

 

=={{header|Clojure}}==

{{libheader|incanter}}

(def x (range 0 10))

(def y '(2.7 2.8 31.4 38.1 58.0 76.2 100.5 130.0 149.3 180.0))

(view (xy-plot x y))

 

{{Out}}

[http://i.imgur.com/0RQaxNl.png]

 

=={{header|EchoLisp}}==

Resulting image [http://www.echolalie.org/echolisp/images/plot-coordinates.png here].

(lib 'plot)

 

(plot-grid 1 20)

(plot-text " Rosetta plot coordinate pairs" 0 10 "white")

=={{header|Erlang}}==

Using [https://github.com/psyeugenic/eplot Eplot] to produce PNG.

 

-module( plot_coordinate_pairs ).

 

PNG = egd_chart:graph( [{File, lists:zip(Xs, Ys)}] ),

file:write_file( File ++ ".png", PNG ).

 

The result looks like [https://github.com/ebengt/rosettacode/blob/master/graphs/plot_coordinate_pairs.png this].

Using the [http://www.ffconsultancy.com/products/fsharp_for_visualization/ F# for Visualization] library:

[[Image:FSViz.png|300px|thumb|right|alt text]]

 

let x = Seq.map float [|0; 1; 2; 3; 4; 5; 6; 7; 8; 9|]

open FlyingFrog.Graphics

 

 

=={{header|gnuplot}}==

[[Image:Plotxy-gnuplot.png|thumb|right|200px|Example gnuplot output]]

 

plot '-' # '-' can be replaced with a filename, to read data from that file.

8 149.3

9 180.0

 

<br clear=right>

 

A program can of course supply commands and data to gnuplot as prepared files. For the spirit of controlling plotting with the native language however, this example shows how commands and data can be prepared programatically and supplied to gnuplot through stdin.

 

import (

w.Close()

g.Wait()

===gonum/plot===

{{libheader|gonum/plot}}

[[File:GoPoints.png|right|Go plot]]

 

import (

log.Fatal(err)

}

 

=={{header|Groovy}}==

[[File:GroovyPlotDemo.png|300px|thumb|right|Screenshot of groovy solution]]

 

import javax.swing.JFrame

import org.jfree.chart.ChartFactory

widget(chart())

}

 

=={{header|Haskell}}==

gnuplot is a package from [http://hackage.haskell.org/packages/hackage.html HackageDB].

 

pnts = [2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0]

 

doPlot = plotPathStyle [ ( Title "plotting dots" )]

 

=={{header|HicEst}}==

 

x = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

WINDOW(WINdowhandle=wh, Width=-300, Height=-300, X=1, TItle='Rosetta')

AXIS(WINdowhandle=wh, Title='x values', Yaxis, Title='y values')

[[File:HicEst_plot_coordinate_pairs.png]]

 

=={{header|Icon}} and {{header|Unicon}}==

[[File:Plotpoints-unicon.gif|thumb|right|Sample Output]]

 

procedure main()

every q[i := 1 to *q] := pix - q[i]

return P

 

{{libheader|Icon Programming Library}}

=={{header|J}}==

{{libheader|plot}}

X=: i.10

Y=: 2.7 2.8 31.4 38.1 58.0 76.2 100.5 130.0 149.3 180.0

[http://www.jsoftware.com/jwiki/RosettaCode/ExamplePlot1 Output of plot.]

 

=={{header|Java}}==

 

import java.awt.event.*;

import java.awt.geom.*;

}

}

=={{header|jq}}==

Using R (non-interactive mode)

 

jq is designed to interoperate with other tools, and in this section we illustrate how jq can be used with R in a simple pipeline: jq will produce a stream of CSV data that will be piped into R operating in non-interactive mode. Assuming the jq and R programs are respectively in plot.jq and plot.R, the pipeline would look like this:

The above would produce the plot as a .pdf file.

 

'''plot.jq'''

# if your version of jq includes transpose as a builtin.

#

def plot(x;y): "A,B", ( [x,y] | transpose | map( @csv ) | .[]);

 

'''plot.R'''

 

x = mydata$A # x-axis

main="Scatterplot Example",

xlab="x-axis label", # x-axis label

 

=={{header|Julia}}==

Using Plots library with PlotlyJS as backend:

 

plotlyjs()

 

 

p = scatter(x, y)

 

=={{header|Kotlin}}==

{{libheader|JFreeChart}}

{{trans|Groovy}}

 

import org.jfree.chart.ChartFactory

}

}

 

{{out}}

Similar to Groovy entry.

</pre>

 

=={{header|Liberty BASIC}}==

First version writes directly to LB's console window.

'Plotting coordinate pairs MainWin - Style

For i = 0 To 9

 

End

The second version uses the more typical graphic window approach, and is written to enable easy adaptation to other data sets.

nomainwin

 

sy = offsetY-y*scaleY 'y is inverted

end function

[http://www.diga.me.uk/PlotCoordPairs.gif LB screen]

 

=={{header|Maple}}==

y := Vector([2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0]):

 

y={2.7,2.8,31.4,38.1,58.0,76.2,100.5,130.0,149.3,180.0};

{{out}}

[http://i43.tinypic.com/2a689yw.png]

 

=={{header|MATLAB}}==

>> y = [2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0];

 

=={{header|Maxima}}==

 

[http://img28.picoodle.com/img/img28/4/2/7/f_qsortrange1m_1b7f493.png qsort-range-10-9.png]

 

=={{header|OCaml}}==

open Graphics

 

ignore(wait_next_event [Key_pressed]);

close_graph();

 

Using the [http://forge.ocamlcore.org/projects/archimedes/ Archimedes] library,

one can write:

[[Image:Archimedes.png|300px|thumb|right|Archimedes plot (graphics output).]]

module A = Archimedes

 

A.Array.y vp y;

A.close vp

 

=={{header|Octave}}==

y = [2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0];

plot(x,y,"o");

 

=={{header|Ol}}==

; define input arrays

(define x '(0 1 2 3 4 5 6 7 8 9))

(define y '(2.7 2.8 31.4 38.1 58.0 76.2 100.5 130.0 149.3 180.0))

 

(glOrtho 0 10 0 200 0 1)

 

(glClear GL_COLOR_BUFFER_BIT)

(glColor3f 0 1 0)

(glBegin GL_LINE_STRIP)

 

=={{header|PARI/GP}}==

 

=={{header|Perl}}==

{{libheader|GD::Graph}}

 

@data = (

[2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0],

);

 

 

{{libheader|Imager::Plot}}

use Imager::Plot;

 

$img->box(filled => 1, color => 'white');

$plot->Render(Image => $img, Xoff => 50, Yoff => 350);

 

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

[[Image: Plotxy-picoLisp.png|thumb|right|200px|Example picoLisp output]]

 

(scl 1)

 

(plot "plot.ps" 300 200 (2.7 2.8 31.4 38.1 58.0 76.2 100.5 130.0 149.3 180.0))

 

=={{header|PostScript}}==

/x [0 1 2 3 4 5 6 7 8 9] def

/y [2.7 2.8 31.4 38.1 58.0 76.2 100.5 130.0 149.3 180.0] def

}repeat

stroke

 

=={{header|PureBasic}}==

x.i

y.f

serie_y:

Data.f 2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0

[[File:PureBasic PlotData.png]]

 

 

Interactive session:

>>> y = [2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0]

 

>>> pylab.plot(x, y, 'bo')

>>> pylab.savefig('qsort-range-10-9.png')

See some other examples:

* [http://matplotlib.org/examples/pylab_examples/simple_plot.html simple plot]

 

==={{libheader|VPython}}===

from visual import *

from visual.graph import *

label(display=plot1.display, text="Look here",

pos=(6,100.5), xoffset=30,yoffset=-20 )

 

=={{header|R}}==

R has several different plotting paradigms. First we define the data.

===Base graphics===

===Lattice/grid graphics===

{{libheader|lattice}}

===Grammar of graphics===

{{libheader|ggplot2}}

 

=={{header|Racket}}==

Racket has a built-in plotting library

(require plot)

 

 

(plot-new-window? #t)

 

This opens a new window with this image (with interactive zooming)

 

And this

(require plot)

 

 

(plot-new-window? #t)

 

opens a new window with this image

[[File:LinesRacket.png]]

 

=={{header|REXX}}==

===without point labels===

Example usage:

x = 0 1 2 3 4 5 6 7 8 9

y = 2.7 2.8 31.4 38.1 58.0 76.2 100.5 130.0 149.3 180.0

end /*j*/ /*$≡ 0,2.7 1,2.8 2,31.4 3,38.1 ··· */

call '$PLOT' $ /*invoke the REXX program: $PLOT */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

===with point labels===

x = 0 1 2 3 4 5 6 7 8 9

y = 2.7 2.8 31.4 38.1 58.0 76.2 100.5 130.0 149.3 180.0

end /*j*/ /*$≡ 0,2.7 1,2.8 2,31.4 3,38.1 ··· */

call '$PLOT' $ '(LABELDatapoints' /*invoke the REXX program: $PLOT */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

 

=={{header|Ring}}==

# Project : Plot coordinate pairs

 

label1 { setpicture(p1) show() }

return

Output:

 

https://www.dropbox.com/s/q6tra0cqoty4pya/Plot.jpg?dl=0

 

=={{header|Ruby}}==

[[File:Ruby.plotxy.png|300px|thumb|right|gnuplot of x,y arrays]]

 

 

x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

end

end

 

=={{header|Scala}}==

{{libheader|Scala}}

import scala.swing.{ MainFrame, Panel, Rectangle }

import java.awt.{ Color, Graphics2D, geom }

contents = ui

}

 

=={{header|Scilab}}==

--> y = [2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0];

 

=={{header|Sidef}}==

{{trans|Perl}}

 

var data = [

 

var format = 'png'

 

=={{header|Stata}}==

input x y

0 2.7

 

lines y x

 

=={{header|Tcl}}==

[[File:Tcl_Plotxy.png|thumb|right|150px|Screenshot for Tcl code]]

This solution does not use existing plotting packages, but constructs the graphics from bare-metal Tk code.

 

# The actual plotting engine

package require Img

set im [image create photo -data .c]

Of course, if we were generating an encapsulated postscript version, we would be able to do that directly.

 

[[File:Plotxy-TI-89.png|thumb|right|200px|TI-89 screenshot]]

 

PlotsOff

NewPlot 1, 1, x, y

 

=={{header|Ursala}}==

Here's the way to do it just as a quick check (all default settings

and dots connected with straight lines).

#import flo

#import fit

#output dot'tex' latex_document+ plot

 

([http://i25.tinypic.com/33oi74j.jpg output])

 

labeled.

 

 

visualization[

scattered: true,

points: ~&p/x y,

([http://i32.tinypic.com/x1x6cz.jpg output])

 

=={{header|XPL0}}==

[[File:PlotXPL0.png|140px|thumb|right|Output]]

 

 

def ScrW=640, ScrH=480, VidMode=$101;

if ChIn(1) then []; \wait for key

SetVid(3); \restore text

 

=={{header|Yorick}}==

y = [2.7, 2.8, 31.4, 38.1, 58.0, 76.2, 100.5, 130.0, 149.3, 180.0];

window, 0;

plmk, y, x;

window, 1;

<gallery>

File:Plotxy-yorick-plmk.png|Output with plmk

 

A program can of course supply commands and data to gnuplot as prepared files. For the spirit of controlling plotting with the native language however, this example shows how commands and data can be prepared programmatically and supplied to gnuplot through stdin.

cmd:=0'|

#set term wxt # X11

gnuplot:=System.popen("gnuplot","w");

gnuplot.write(cmd); gnuplot.flush();