Plot coordinate pairs: Difference between revisions

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program areaPlot64.s */

.include "../includeARM64.inc"

 

{{Output}}

<pre>

=={{header|Action!}}==

{{libheader|Action! Tool Kit}}

 

DEFINE PTR="CARD"

DO UNTIL CH#$FF OD

CH=$FF

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Plot_coordinate_pairs.png Screenshot from Atari 8-bit computer]

{{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}}==

{{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}}

{{Trans|Go}}

Boost.Process is part of [https://github.com/MaiconSoft/DelphiBoostLib DelphiBoostLib].

program Plot_coordinate_pairs;

 

plot.Free;

readln;

 

=={{header|EasyLang}}==

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

#

n = len x[]

m = 0

.

sty = m div 9

.

.

 

=={{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|Factor}}==

{{works with|Factor|0.99 2019-01-23}}

ui.gadgets ui.gadgets.charts ui.gadgets.charts.lines ;

 

line new COLOR: blue >>color

9 <iota> { 2.7 2.8 31.4 38.1 58 76.2 100.5 130 149.3 180 } zip

 

=={{header|Fōrmulæ}}==

 

 

 

 

=={{header|FreeBASIC}}==

{{trans|Liberty BASIC}}

===Text mode===

For i = 0 To 9

x(i) = i

Locate (21 - (y(i)/ 10)), (x(i) * 4) + 2 : Print "."

Next i

 

 

=={{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}}==

 

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}}

 

=={{header|Lambdatalk}}==

1) define X & Y:

 

 

4) the result can be seen in http://lambdaway.free.fr/lambdawalks/?view=plot4

 

=={{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|Lua}}==

{{libheader|LÖVE}}

 

w_width = love.graphics.getWidth()

w_height = love.graphics.getHeight()

end

 

=={{header|M2000 Interpreter}}==

Result image [https://4.bp.blogspot.com/-8XdIVaW79lU/W_iCUBmj92I/AAAAAAAAHbA/TxMl_P22yckQ1Wdi4zsu6k_QVNRZpqJCgCLcBGAs/s1600/graph222.png here]

 

Module Pairs {

\\ written in version 9.5 rev. 13

}

Pairs

 

=={{header|Maple}}==

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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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|Nim}}==

===Using gnuplot===

 

The library launches “gnuplot” which does the plotting. From “gnuplot”, it is possible to save the drawing into a PDF, a SVG or an image (BMP, PNG) file.

 

 

let

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

 

 

===Using ggplotnim===

{{libheader|ggplotnim}}

This library doesn’t use an external process to does the plotting. It uses a syntax mostly compliant with “ggplot2” syntax.

 

let

geomLine() +

themeOpaque() +

 

=={{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))

(map glVertex2f x y)

(glEnd)))

 

=={{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],

);

 

binmode $fh;

 

{{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

{{works with|Rakudo|2018.03}}

Generate an SVG image file.

use SVG::Plot;

 

values => [@y,],

title => 'Coordinate Pairs',

[[File:Coordinate-pairs-perl6.svg]]

 

===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|VBA}}==

Using Excel

Dim chrt As Chart

Set chrt = ActiveSheet.Shapes.AddChart.Chart

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

plot_coordinate_pairs x, y

 

=={{header|Wren}}==

{{libheader|DOME}}

import "dome" for Window

import "math" for Point

}

 

 

=={{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();