├── .github
    └── workflows
    │   └── test.yml
├── .gitignore
├── Changes
├── LICENSE
├── META6.json
├── README.md
├── dist.ini
├── histogram.png
├── lib
    └── Chart
    │   ├── Gnuplot.pm6
    │   └── Gnuplot
    │       ├── Arrow.pm6
    │       ├── Border.pm6
    │       ├── CustomBuilder.pm6
    │       ├── Grid.pm6
    │       ├── Label.pm6
    │       ├── Legend.pm6
    │       ├── Object.pm6
    │       ├── Output.pm6
    │       ├── Range.pm6
    │       ├── Subset.pm6
    │       ├── Terminal.pm6
    │       ├── Tics.pm6
    │       ├── Timestamp.pm6
    │       ├── Title.pm6
    │       └── Util.pm6
├── notebooks
    └── synopsis.ipynb
├── recprec.png
├── sinx.png
├── surface.dem.00.png
└── t
    ├── 01-basic.t
    ├── 02-terminal.t
    ├── 03-plot.t
    ├── 04-splot.t
    ├── 05-label.t
    ├── 06-range.t
    ├── 07-tics.t
    ├── 08-legend.t
    ├── 09-border.t
    ├── 10-grid.t
    ├── 11-timestamp.t
    ├── 12-rectangle.t
    ├── 13-ellipse.t
    ├── 14-circle.t
    ├── 15-polygon.t
    ├── 16-title.t
    ├── 17-arrow.t
    └── 18-multiplot.t


/.github/workflows/test.yml:
--------------------------------------------------------------------------------
 1 | name: test
 2 | 
 3 | on:
 4 |   push:
 5 |     branches:
 6 |       - '*'
 7 |     tags-ignore:
 8 |       - '*'
 9 |   pull_request:
10 | 
11 | jobs:
12 |   raku:
13 |     strategy:
14 |       matrix:
15 |         os:
16 |           - ubuntu-latest
17 |           - macOS-latest
18 |         raku-version:
19 |           - 'latest'
20 |     runs-on: ${{ matrix.os }}
21 |     steps:
22 |       - uses: actions/checkout@v2
23 |       - uses: Raku/setup-raku@v1
24 |         with:
25 |           raku-version: ${{ matrix.raku-version }}
26 |       - name: Install Dependencies
27 |         run: zef install --/test --test-depends --deps-only .
28 |       - name: Install App::Prove6
29 |         run: zef install --/test App::Prove6
30 |       - name: Build gnuplot
31 |         run: zef build .
32 |       - name: Run Tests
33 |         run: prove6 -l t
34 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | /blib/
 2 | /src/*.o
 3 | /src/Makefile
 4 | /.panda-work
 5 | /resources/*.so
 6 | /resources/*.dylib
 7 | .precomp/
 8 | /Chart-Gnuplot-*
 9 | /gnuplot-*
10 | /example/*
11 | *.svg
12 | /notebooks/.ipynb_checkpoints/
13 | /notebooks/jupyter.log
14 | /notebooks/nohup.out
15 | 


--------------------------------------------------------------------------------
/Changes:
--------------------------------------------------------------------------------
  1 | Revision history for Chart-Gnuplot
  2 | 
  3 | {{$NEXT}}
  4 | 
  5 | 0.0.21  2023-03-20T13:31:50+09:00
  6 |     - Fixes:
  7 |       - Fix debug option as it enables to output both user input and reply from gnuplot [#47]
  8 |     - Additions:
  9 |     - Efficiency:
 10 | 
 11 | 0.0.20  2021-05-01T13:26:55+09:00
 12 |     - Fixes:
 13 |       - Set TEXDIR explicitly for removing dependence on kpsewhich [#44]
 14 |       - Use github actions instead of travis ci [#43]
 15 |     - Additions:
 16 |     - Efficiency:
 17 | 
 18 | 0.0.19  2020-07-26T15:43:28+09:00
 19 |     - Fixes:
 20 |       - Set pt instead of lt for recall-precision curve plotting
 21 |     - Additions:
 22 |     - Efficiency:
 23 | 
 24 | 0.0.18  2020-07-26T15:13:15+09:00
 25 |     - Fixes:
 26 |     - Additions:
 27 |       - Use travis-ci.com instead of travis-ci.org
 28 |       - Add recall-precision curve example
 29 |     - Efficiency:
 30 | 
 31 | 0.0.17  2020-01-03T01:55:08+09:00
 32 |     - Fixes:
 33 |     - Additions:
 34 |     - Efficiency:
 35 |        - Make debug mode faster [dfcc8]
 36 | 
 37 | 0.0.16  2019-12-24T00:56:00+09:00
 38 |     - Fixes:
 39 |        - Replace p6/perl6 with raku
 40 |     - Additions:
 41 |     - Efficiency:
 42 | 
 43 | 0.0.15  2019-12-17T00:42:51+09:00
 44 |     - Fixes:
 45 |        - Add CustomBuilder to the build-depends
 46 |     - Additions:
 47 |     - Efficiency:
 48 | 
 49 | 0.0.14  2019-11-15T08:16:21+09:00
 50 |     - Fixes:
 51 |        - Fix some build errors caused by zef changes
 52 |     - Additions:
 53 |     - Efficiency:
 54 | 
 55 | 0.0.13  2019-11-14T23:09:50+09:00
 56 |     - Fixes:
 57 |        - Add missing build dependency
 58 |     - Additions:
 59 |     - Efficiency:
 60 | 
 61 | 0.0.12  2019-11-14T22:17:47+09:00
 62 |     - Fixes:
 63 |        - Fix broken gnuplot download link [d2758]
 64 |        - Use CustomBuiler [d8cca]
 65 |     - Additions:
 66 |     - Efficiency:
 67 | 
 68 | 0.0.11  2018-12-13T09:19:48+09:00
 69 |     - Fixes:
 70 |        - Fix delegation construction (tics, timestamp, title) [#39]
 71 |     - Additions:
 72 |     - Efficiency:
 73 | 
 74 | 0.0.10  2018-12-13T08:20:16+09:00
 75 |     - Fixes:
 76 |        - Fix typo clabel -> cblabel [#38]
 77 |     - Additions:
 78 |     - Efficiency:
 79 | 
 80 | 0.0.9  2018-12-13T08:04:14+09:00
 81 |     - Fixes:
 82 |        - Fix type constraint for tics [#36]
 83 |        - Use handles [#35]
 84 |     - Additions:
 85 |        - Add type constraint [#37]
 86 |     - Efficiency:
 87 | 
 88 | 0.0.8  2018-12-04T22:41:01+09:00
 89 |     - Fixes:
 90 |        - Use AnyTicsTic instead of AnyTicsTics [#34]
 91 |     - Additions:
 92 |     - Efficiency:
 93 | 
 94 | 0.0.7  2018-12-03T22:41:28+09:00
 95 |     - Fixes:
 96 |        - Use gnuplot 5.2.5 since it's 5.0.5 link is broken [#32]
 97 |        - Use the upstream Zef::Extract instead of an user-modified Zef::Extract [#32]
 98 |     - Additions:
 99 |     - Efficiency:
100 | 
101 | 0.0.6  2018-07-23T01:31:44+09:00
102 |     - Fixes:
103 |        - Add --test-depends [a402011]
104 |     - Additions:
105 |     - Efficiency:
106 | 
107 | 0.0.5  2018-07-19T22:44:12+09:00
108 |     - Fixes:
109 |        - Add missing num-plot increment [e613d9e]
110 |     - Additions:
111 |     - Efficiency:
112 | 
113 | 0.0.4  2018-05-01T20:56:08+09:00
114 |     - Fixes:
115 |        - Add missing y2label method [#30]
116 |     - Additions:
117 |     - Efficiency:
118 | 
119 | 0.0.3  2018-04-01T16:07:27+09:00
120 |     - Fixes:
121 |        - Make sure dispose correctly [#27]
122 |        - Fix subset related portions of the code [#28]
123 |     - Additions:
124 |        - Add the user-defined subset description [#29]
125 |     - Efficiency:
126 | 
127 | 0.0.2
128 |     - Fixes:
129 |        - Use svg instead of png [#20]
130 |        - Employ delegation [#21]
131 |        - Fix Build.pm [#22]
132 |        - Use a more practical example for synopsis [#23]
133 |     - Additions:
134 |        - Add aliases for pt, ps [#19]
135 |        - Add smooth argument [c531dcb]
136 |     - Efficiency:
137 | 
138 | 0.0.1
139 |     - Initial version
140 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | raku-Chart-Gnuplot -- A Raku Gnuplot bindings
 2 | Copyright (C) 2017 titsuki
 3 | 
 4 | This program is free software: you can redistribute it and/or modify
 5 | it under the terms of the GNU General Public License as published by
 6 | the Free Software Foundation, either version 3 of the License, or
 7 | (at your option) any later version.
 8 | 
 9 | This program is distributed in the hope that it will be useful,
10 | but WITHOUT ANY WARRANTY; without even the implied warranty of
11 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 | GNU General Public License for more details.
13 | 
14 | You should have received a copy of the GNU General Public License
15 | along with this program.  If not, see <http://www.gnu.org/licenses/>.
16 | 


--------------------------------------------------------------------------------
/META6.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "author": "cpan:TITSUKI",
 3 |   "authors": [
 4 |     "Itsuki Toyota"
 5 |   ],
 6 |   "build-depends": [
 7 |     "zef",
 8 |     "Distribution::Builder::MakeFromJSON",
 9 |     "Chart::Gnuplot::CustomBuilder"
10 |   ],
11 |   "builder": "Chart::Gnuplot::CustomBuilder",
12 |   "depends": [
13 |   ],
14 |   "description": "A Raku bindings for gnuplot",
15 |   "license": "GPL-3.0",
16 |   "name": "Chart::Gnuplot",
17 |   "perl": "6.c",
18 |   "provides": {
19 |     "Chart::Gnuplot": "lib/Chart/Gnuplot.pm6",
20 |     "Chart::Gnuplot::Arrow": "lib/Chart/Gnuplot/Arrow.pm6",
21 |     "Chart::Gnuplot::Border": "lib/Chart/Gnuplot/Border.pm6",
22 |     "Chart::Gnuplot::CustomBuilder": "lib/Chart/Gnuplot/CustomBuilder.pm6",
23 |     "Chart::Gnuplot::Grid": "lib/Chart/Gnuplot/Grid.pm6",
24 |     "Chart::Gnuplot::Label": "lib/Chart/Gnuplot/Label.pm6",
25 |     "Chart::Gnuplot::Legend": "lib/Chart/Gnuplot/Legend.pm6",
26 |     "Chart::Gnuplot::Object": "lib/Chart/Gnuplot/Object.pm6",
27 |     "Chart::Gnuplot::Output": "lib/Chart/Gnuplot/Output.pm6",
28 |     "Chart::Gnuplot::Range": "lib/Chart/Gnuplot/Range.pm6",
29 |     "Chart::Gnuplot::Subset": "lib/Chart/Gnuplot/Subset.pm6",
30 |     "Chart::Gnuplot::Terminal": "lib/Chart/Gnuplot/Terminal.pm6",
31 |     "Chart::Gnuplot::Tics": "lib/Chart/Gnuplot/Tics.pm6",
32 |     "Chart::Gnuplot::Timestamp": "lib/Chart/Gnuplot/Timestamp.pm6",
33 |     "Chart::Gnuplot::Title": "lib/Chart/Gnuplot/Title.pm6",
34 |     "Chart::Gnuplot::Util": "lib/Chart/Gnuplot/Util.pm6"
35 |   },
36 |   "resources": [
37 |   ],
38 |   "source-url": "git://github.com/titsuki/raku-Chart-Gnuplot.git",
39 |   "tags": [
40 |   ],
41 |   "test-depends": [
42 |   ],
43 |   "version": "0.0.21"
44 | }
45 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | [![Actions Status](https://github.com/titsuki/raku-Chart-Gnuplot/workflows/test/badge.svg)](https://github.com/titsuki/raku-Chart-Gnuplot/actions)
  2 | 
  3 | NAME
  4 | ====
  5 | 
  6 | Chart::Gnuplot - A Raku bindings for gnuplot
  7 | 
  8 | SYNOPSIS
  9 | ========
 10 | 
 11 | ### SOURCE
 12 | 
 13 |     use Chart::Gnuplot;
 14 |     use Chart::Gnuplot::Subset;
 15 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("histogram.png"));
 16 | 
 17 |     my @data = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
 18 |     Year Male Female
 19 |     1950 100 90
 20 |     1960 100 90
 21 |     1970 80 70
 22 |     1980 130 140
 23 |     1990 140 120
 24 |     2000 200 210
 25 |     2010 240 230
 26 |     2020 400 420
 27 |     EOF
 28 | 
 29 |     my ($header, *@body) = @data;
 30 | 
 31 |     $gnu.command("set style histogram clustered");
 32 |     $gnu.legend(:left);
 33 |     my AnyTicsTic @tics = (@body>>.[0]).pairs.map(-> (:key($pos), :value($year)) { %(:label($year), :pos($pos)) });
 34 |     $gnu.xtics(:tics(@tics));
 35 |     $gnu.xlabel(:label($header[0]));
 36 |     $gnu.plot(:vertices(@body), :using([2]), :style("histogram"), :title($header[1]), :fill("solid 1.0"));
 37 |     $gnu.plot(:vertices(@body), :using([3]), :style("histogram"), :title($header[2]), :fill("solid 1.0"));
 38 | 
 39 |     $gnu.dispose;
 40 | 
 41 | ### OUTPUT
 42 | 
 43 | <img src="histogram.png" alt="histogram">
 44 | 
 45 | DESCRIPTION
 46 | ===========
 47 | 
 48 | Chart::Gnuplot is a Raku naive bindings for gnuplot. Chart::Gnuplot runs `gnuplot` using `Proc::Async` and enables you to plot chart or graph with Rakuish interface.
 49 | 
 50 | SUBSET
 51 | ------
 52 | 
 53 | Defined as:
 54 | 
 55 |     subset FalseOnly of Bool is export where { $_ ~~ Bool:U or $_ === False };
 56 |     subset TrueOnly of Bool is export where { $_ ~~ Bool:U or $_ === True};
 57 |     subset LabelRotate of Cool is export where { $_ ~~ Cool:U or $_ ~~ Real or $_ === False };
 58 |     subset AnyLabelRotate of Cool is export where { $_ ~~ Cool:U or $_ eq "parallel" or $_ ~~ Real or $_ === False };
 59 |     subset LegendMax of Cool is export where { $_ ~~ Cool:U or $_ eq "auto" or $_ ~~ Real };
 60 |     subset AnyTicsRotate of Cool is export where { $_ ~~ Cool:U or $_ ~~ Real or $_ === False };
 61 |     subset AnyTicsOffset of Mu is export where { $_ ~~ Mu:U or $_ ~~ FalseOnly or ($_ ~~ List and $_.all ~~ Pair|Real) };
 62 |     subset AnyTicsTic of Mu is export where { $_ ~~ Mu:U or $_ ~~ Hash and .<label>:exists and .<pos>:exists and .keys.grep(* eq "label"|"pos"|"level").elems == .keys.elems };
 63 | 
 64 | METHODS
 65 | -------
 66 | 
 67 | ### terminal
 68 | 
 69 | Defined as:
 70 | 
 71 |     method terminal($terminal)
 72 | 
 73 | Tells gnuplot what kind of output to generate.
 74 | 
 75 | ### plot
 76 | 
 77 | Defined as:
 78 | 
 79 |     multi method plot(
 80 |             :$title, :$ignore, :@range, :@vertices!, :$smooth,
 81 |             :@using,
 82 |             Str :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 83 |             :pt(:$pointtype), :ps(:$pointsize), :$fill, FalseOnly :$hidden3d, FalseOnly :$contours,
 84 |             FalseOnly :$surface, :$palette,
 85 |             :&writer? = -> $msg { self.command: $msg }
 86 |     )
 87 | 
 88 |     multi method plot(
 89 |           :$title, :$ignore, :@range, :$function!, :$smooth,
 90 |           Str :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 91 |           :pt(:$pointtype), :ps(:$pointsize), :$fill, FalseOnly :$hidden3d, FalseOnly :$contours,
 92 |           FalseOnly :$surface, :$palette,
 93 |           :&writer? = -> $msg { self.command: $msg }
 94 |     )
 95 | 
 96 | Draws a 2-dimensional plot.
 97 | 
 98 | ### splot
 99 | 
100 | Defined as:
101 | 
102 |     multi method splot(
103 |           :@range,
104 |           :@vertices!, :$smooth,
105 |           :$binary, :$matrix, :$index, :$every,
106 |           :$title, :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
107 |           :$pointtype, :$pointsize, :$fill, FalseOnly :$hidden3d, FalseOnly :$contours,
108 |           FalseOnly :$surface, :$palette, :&writer? = -> $msg { self.command: $msg }
109 |     )
110 | 
111 |     multi method splot(
112 |           :@range,
113 |           :$function!, :$smooth,
114 |           :$title, :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
115 |           :$pointtype, :$pointsize, :$fill, FalseOnly :$hidden3d, FalseOnly :$contours,
116 |           FalseOnly :$surface, :$palette, :&writer? = -> $msg { self.command: $msg }
117 |     )
118 | 
119 | Draws a 3-dimensional plot.
120 | 
121 | ### label
122 | 
123 | Defined as:
124 | 
125 |     method label(
126 |            :$tag, Str :$label-text, :$at, TrueOnly :$left, TrueOnly :$center, TrueOnly :$right,
127 |            LabelRotate :$rotate, :$font-name, :$font-size, FalseOnly :$enhanced,
128 |            TrueOnly :$front, TrueOnly :$back, :$textcolor, FalseOnly :$point, :$line-type, :$point-type, :$point-size, :$offset,
129 |            TrueOnly :$boxed, TrueOnly :$hypertext, :&writer? = -> $msg { self.command: $msg }
130 |     )
131 | 
132 | Places the text string at the corresponding 2D or 3D position.
133 | 
134 | ### xlabel
135 | 
136 | Defined as:
137 | 
138 |     method xlabel(
139 |            Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
140 |            Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
141 |     )
142 | 
143 | Sets the x-axis label.
144 | 
145 | ### ylabel
146 | 
147 | Defined as:
148 | 
149 |     method ylabel(
150 |            Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
151 |            Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
152 |     )
153 | 
154 | Sets the y-axis label.
155 | 
156 | ### zlabel
157 | 
158 | Defined as:
159 | 
160 |     method zlabel(
161 |            Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
162 |            Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
163 |     )
164 | 
165 | Sets the z-axis label.
166 | 
167 | ### x2label
168 | 
169 | Defined as:
170 | 
171 |     method x2label(
172 |            Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
173 |            Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
174 |     )
175 | 
176 | Sets the x2-axis label.
177 | 
178 | ### y2label
179 | 
180 | Defined as:
181 | 
182 |     method y2label(
183 |            Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
184 |            Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
185 |     )
186 | 
187 | Sets the y2-axis label.
188 | 
189 | ### cblabel
190 | 
191 | Defined as:
192 | 
193 |     method cblabel(
194 |            Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
195 |            Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
196 |     )
197 | 
198 | Sets the cb-axis label.
199 | 
200 | ### xrange
201 | 
202 | Defined as:
203 | 
204 |     multi method xrange(
205 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
206 |           :&writer? = -> $msg { self.command: $msg }
207 |     )
208 | 
209 |     multi method xrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
210 | 
211 | Sets the horizontal range that will be displayed.
212 | 
213 | ### yrange
214 | 
215 | Defined as:
216 | 
217 |     multi method yrange(
218 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
219 |           :&writer? = -> $msg { self.command: $msg }
220 |     )
221 | 
222 |     multi method yrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
223 | 
224 | Sets the vertical range that will be displayed.
225 | 
226 | ### zrange
227 | 
228 | Defined as:
229 | 
230 |     multi method zrange(
231 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
232 |           :&writer? = -> $msg { self.command: $msg }
233 |     )
234 | 
235 |     multi method zrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
236 | 
237 | Sets the range that will be displayed on the z axis.
238 | 
239 | ### x2range
240 | 
241 | Defined as:
242 | 
243 |     multi method x2range(
244 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
245 |           :&writer? = -> $msg { self.command: $msg }
246 |     )
247 | 
248 |     multi method x2range(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
249 | 
250 | Sets the range that will be displayed on the x2 axis.
251 | 
252 | ### y2range
253 | 
254 | Defined as:
255 | 
256 |     multi method y2range(
257 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
258 |           :&writer? = -> $msg { self.command: $msg }
259 |     )
260 | 
261 |     multi method y2range(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
262 | 
263 | Sets the range that will be displayed on the y2 axis.
264 | 
265 | ### cbrange
266 | 
267 | Defined as:
268 | 
269 |     multi method cbrange(
270 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
271 |           :&writer? = -> $msg { self.command: $msg }
272 |     )
273 | 
274 |     multi method cbrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
275 | 
276 | Sets the range of values which are colored.
277 | 
278 | ### rrange
279 | 
280 | Defined as:
281 | 
282 |     multi method rrange(
283 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
284 |           :&writer? = -> $msg { self.command: $msg }
285 |     )
286 | 
287 |     multi method rrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
288 | 
289 | Sets the range that will be displayed on the r axis.
290 | 
291 | ### trange
292 | 
293 | Defined as:
294 | 
295 |     multi method trange(
296 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
297 |           :&writer? = -> $msg { self.command: $msg }
298 |     )
299 | 
300 |     multi method trange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
301 | 
302 | Sets the parametric range used to compute x and y values when in parametric or polar modes.
303 | 
304 | ### urange
305 | 
306 | Defined as:
307 | 
308 |     multi method urange(
309 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
310 |           :&writer? = -> $msg { self.command: $msg }
311 |     )
312 | 
313 |     multi method urange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
314 | 
315 | Set the parametric ranges used to compute x, y, and z values when in splot parametric mode.
316 | 
317 | ### vrange
318 | 
319 | Defined as:
320 | 
321 |     multi method vrange(
322 |           :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
323 |           :&writer? = -> $msg { self.command: $msg }
324 |     )
325 | 
326 |     multi method vrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
327 | 
328 | Set the parametric ranges used to compute x, y, and z values when in splot parametric mode.
329 | 
330 | ### xtics
331 | 
332 | Defined as:
333 | 
334 |     method xtics(
335 |            TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
336 |            TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
337 |            TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
338 |            TrueOnly :$add,
339 |            TrueOnly :$autofreq,
340 |            :$incr,
341 |            :$start, :$end,
342 |            :@tics where Array[AnyTicsTic] | Array[],
343 |            :$format, :$font-name, :$font-size, Bool :$enhanced,
344 |            TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
345 |            TrueOnly :$rangelimited,
346 |            :$textcolor, :&writer? = -> $msg { self.command: $msg }
347 |     )
348 | 
349 | Controls the major (labeled) tics on the x axis.
350 | 
351 | ### ytics
352 | 
353 | Defined as:
354 | 
355 |     method ytics(
356 |            TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
357 |            TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
358 |            TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
359 |            TrueOnly :$add,
360 |            TrueOnly :$autofreq,
361 |            :$incr,
362 |            :$start, :$end,
363 |            :@tics where Array[AnyTicsTic] | Array[],
364 |            :$format, :$font-name, :$font-size, Bool :$enhanced,
365 |            TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
366 |            TrueOnly :$rangelimited,
367 |            :$textcolor, :&writer? = -> $msg { self.command: $msg }
368 |     )
369 | 
370 | Controls the major (labeled) tics on the y axis.
371 | 
372 | ### ztics
373 | 
374 | Defined as:
375 | 
376 |     method ztics(
377 |            TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
378 |            TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
379 |            TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
380 |            TrueOnly :$add,
381 |            TrueOnly :$autofreq,
382 |            :$incr,
383 |            :$start, :$end,
384 |            :@tics where Array[AnyTicsTic] | Array[],
385 |            :$format, :$font-name, :$font-size, Bool :$enhanced,
386 |            TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
387 |            TrueOnly :$rangelimited,
388 |            :$textcolor, :&writer? = -> $msg { self.command: $msg }
389 |     )
390 | 
391 | Controls the major (labeled) tics on the z axis.
392 | 
393 | ### x2tics
394 | 
395 | Defined as:
396 | 
397 |     method x2tics(
398 |            TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
399 |            TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
400 |            TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
401 |            TrueOnly :$add,
402 |            TrueOnly :$autofreq,
403 |            :$incr,
404 |            :$start, :$end,
405 |            :@tics where Array[AnyTicsTic] | Array[],
406 |            :$format, :$font-name, :$font-size, Bool :$enhanced,
407 |            TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
408 |            TrueOnly :$rangelimited,
409 |            :$textcolor, :&writer? = -> $msg { self.command: $msg }
410 |     )
411 | 
412 | Controls the major (labeled) tics on the x2 axis.
413 | 
414 | ### y2tics
415 | 
416 | Defined as:
417 | 
418 |     method y2tics(
419 |            TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
420 |            TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
421 |            TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
422 |            TrueOnly :$add,
423 |            TrueOnly :$autofreq,
424 |            :$incr,
425 |            :$start, :$end,
426 |            :@tics where Array[AnyTicsTic] | Array[],
427 |            :$format, :$font-name, :$font-size, Bool :$enhanced,
428 |            TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
429 |            TrueOnly :$rangelimited,
430 |            :$textcolor, :&writer? = -> $msg { self.command: $msg }
431 |     )
432 | 
433 | Controls the major (labeled) tics on the y2 axis.
434 | 
435 | ### cbtics
436 | 
437 | Defined as:
438 | 
439 |     method cbtics(
440 |            TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
441 |            TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
442 |            TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
443 |            TrueOnly :$add,
444 |            TrueOnly :$autofreq,
445 |            :$incr,
446 |            :$start, :$end,
447 |            :@tics where Array[AnyTicsTic] | Array[],
448 |            :$format, :$font-name, :$font-size, Bool :$enhanced,
449 |            TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
450 |            TrueOnly :$rangelimited,
451 |            :$textcolor, :&writer? = -> $msg { self.command: $msg }
452 |     )
453 | 
454 | Controls the major (labeled) tics on the color box axis.
455 | 
456 | ### legend
457 | 
458 | Defined as:
459 | 
460 |     method legend(
461 |            TrueOnly :$on, TrueOnly :$off, TrueOnly :$default, TrueOnly :$inside, TrueOnly :$outside, TrueOnly :$lmargin, TrueOnly :$rmargin, TrueOnly :$tmargin, TrueOnly :$bmargin,
462 |            :$at,
463 |            TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$top, TrueOnly :$bottom,
464 |            TrueOnly :$vertical, TrueOnly :$horizontal, TrueOnly :$Left, TrueOnly :$Right,
465 |            Bool :$opaque, Bool :$reverse, Bool :$invert,
466 |            :$samplen, :$spacing, :$width, :$height,
467 |            TrueOnly :$autotitle, TrueOnly :$columnheader, :$title, :$font-name, :$font-size, :$textcolor,
468 |            Bool :$box, :$linestyle, :$linetype, :$linewidth,
469 |            LegendMax :$maxcols, LegendMax :$maxrows, :&writer? = -> $msg { self.command: $msg }
470 |     )
471 | 
472 | Enables a key (or legend) containing a title and a sample (line, point, box) for each plot in the graph.
473 | 
474 | ### border
475 | 
476 | Defined as:
477 | 
478 |     method border(
479 |            :$integer, TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind,
480 |            :lw(:$linewidth), :ls(:$linestyle), :lt(:$linetype), :&writer? = -> $msg { self.command: $msg }
481 |     )
482 | 
483 | Controls the display of the graph borders for the plot and splot commands.
484 | 
485 | ### grid
486 | 
487 | Defined as:
488 | 
489 |     method grid(
490 |            Bool :$xtics, TrueOnly :$mxtics, Bool :$ytics, TrueOnly :$mytics, Bool :$ztics, TrueOnly :$mztics,
491 |            Bool :$x2tics, TrueOnly :$mx2tics, Bool :$y2tics, TrueOnly :$my2tics, Bool :$cbtics, TrueOnly :$mcbtics,
492 |            :$polar, TrueOnly :$layerdefault, TrueOnly :$front, TrueOnly :$back,
493 |            :ls(:@linestyle), :lt(:@linetype), :lw(:@linewidth), :&writer? = -> $msg { self.command: $msg }
494 |     )
495 | 
496 | Allows grid lines to be drawn on the plot.
497 | 
498 | ### timestamp
499 | 
500 | Defined as:
501 | 
502 |     method timestamp(
503 |             Str :$format, TrueOnly :$top, TrueOnly :$bottom, Bool :$rotate,
504 |             :$offset, :$font-name, :$font-size, :$textcolor, :&writer? = -> $msg { self.command: $msg }
505 |     )
506 | 
507 | Places the time and date of the plot in the left margin.
508 | 
509 | ### rectangle
510 | 
511 | Defined as:
512 | 
513 |     multi method rectangle(
514 |           :$index!, :$from, :$to,
515 |           TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
516 |           TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
517 |     )
518 | 
519 |     multi method rectangle(
520 |           :$index, :$from, :$rto,
521 |           TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
522 |           TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
523 |     )
524 | 
525 | Defines a single rectangle which will appear in all subsequent 2D plot.
526 | 
527 | ### ellipse
528 | 
529 | Defined as:
530 | 
531 |     method ellipse(
532 |            :$index, :center(:$at), :$w!, :$h!,
533 |            TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
534 |            TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
535 |     )
536 | 
537 | Defines a single ellipse which will appear in all subsequent 2D plot.
538 | 
539 | ### circle
540 | 
541 | Defined as:
542 | 
543 |     method circle(
544 |            :$index, :center(:$at), :$radius!,
545 |            TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
546 |            TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
547 |     )
548 | 
549 | Defines a single circle which will appear in all subsequent 2D plot.
550 | 
551 | ### polygon
552 | 
553 | Defined as:
554 | 
555 |     method polygon(
556 |            :$index, :$from, :@to,
557 |            TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
558 |            TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
559 |     )
560 | 
561 | Defines a single polygon which will appear in all subsequent 2D plot.
562 | 
563 | ### title
564 | 
565 | Defined as:
566 | 
567 |     method title(
568 |            Str :$text, :$offset, :$font-name, :$font-size, :tc(:$textcolor), :$colorspec, Bool :$enhanced,
569 |            :&writer? = -> $msg { self.command: $msg }
570 |     )
571 | 
572 | Produces a plot title that is centered at the top of the plot.
573 | 
574 | ### arrow
575 | 
576 | Defined as:
577 | 
578 |     multi method arrow(
579 |           :$tag, :$from, :$to, Bool :$head, TrueOnly :$backhead, TrueOnly :$heads,
580 |           :$head-length, :$head-angle, :$back-angle,
581 |           Bool :$filled, TrueOnly :$empty, TrueOnly :$border,
582 |           TrueOnly :$front, TrueOnly :$back,
583 |           :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor), :dt(:$dashtype), :&writer? = -> $msg { self.command: $msg }
584 |     )
585 | 
586 | Places an arrow on a plot.
587 | 
588 | ### multiplot
589 | 
590 | Defined as:
591 | 
592 |     multi method arrow(
593 |           :$tag, :$from, :$rto, Bool :$head, TrueOnly :$backhead, TrueOnly :$heads,
594 |           :$head-length, :$head-angle, :$back-angle,
595 |           Bool :$filled, TrueOnly :$empty, TrueOnly :$border,
596 |           TrueOnly :$front, TrueOnly :$back,
597 |           :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor), :dt(:$dashtype), :&writer? = -> $msg { self.command: $msg }
598 |     )
599 | 
600 | Places gnuplot in the multiplot mode, in which several plots are placed next to each other on the same page or screen window.
601 | 
602 | ### command
603 | 
604 | Defined as:
605 | 
606 |     method command(Str $command)
607 | 
608 | Runs a given `$command`. If there are no appropriate interfaces, this method will be a good alternative.
609 | 
610 | EXAMPLES
611 | ========
612 | 
613 | 3D surface from a grid (matrix) of Z values
614 | -------------------------------------------
615 | 
616 | ### SOURCE
617 | 
618 |     use Chart::Gnuplot;
619 | 
620 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("surface.dem.00.png"));
621 |     $gnu.title(:text("3D surface from a grid (matrix) of Z values"));
622 |     $gnu.xrange(:min(-0.5), :max(4.5));
623 |     $gnu.yrange(:min(-0.5), :max(4.5));
624 |     $gnu.grid;
625 |     $gnu.command("set hidden3d");
626 | 
627 |     my @grid = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
628 |     5 4 3 1 0
629 |     2 2 0 0 1
630 |     0 0 0 1 0
631 |     0 0 0 2 3
632 |     0 1 2 4 3
633 |     EOF
634 | 
635 |     $gnu.splot(:vertices(@grid), :style("lines"), :title(False), :matrix);
636 |     $gnu.dispose;
637 | 
638 | ### OUTPUT
639 | 
640 | <img src="surface.dem.00.png" alt="3D surface from a grid (matrix) of Z values">
641 | 
642 | sin(x)
643 | ------
644 | 
645 | ### SOURCE
646 | 
647 |     use Chart::Gnuplot;
648 | 
649 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("sinx.png"));
650 |     $gnu.title(:text("sin(x) curve"));
651 |     $gnu.plot(:function('sin(x)'));
652 |     $gnu.dispose;
653 | 
654 | ### OUTPUT
655 | 
656 | <img src="sinx.png" alt="sin(x)">
657 | 
658 | Recall-Precision Curve
659 | ----------------------
660 | 
661 | ### SOURCE
662 | 
663 |     use v6;
664 |     use Chart::Gnuplot;
665 | 
666 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("recprec.png"));
667 |     $gnu.title(:text("Recall-Precision Curve"));
668 |     $gnu.ylabel(:label("Precision"));
669 |     $gnu.xlabel(:label("Recall"));
670 |     $gnu.xrange(:min(0.0), :max(1.0));
671 |     $gnu.yrange(:min(0.0), :max(1.0));
672 | 
673 |     my @methodA = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
674 |     0.0 1.0
675 |     0.1 0.95
676 |     0.2 0.9
677 |     0.3 0.85
678 |     0.4 0.82
679 |     0.5 0.6
680 |     0.6 0.55
681 |     0.7 0.51
682 |     0.8 0.4
683 |     0.9 0.38
684 |     1.0 0.35
685 |     EOF
686 | 
687 |     my @methodB = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
688 |     0.0 1.0
689 |     0.1 0.95
690 |     0.2 0.8
691 |     0.3 0.5
692 |     0.4 0.4
693 |     0.5 0.3
694 |     0.6 0.2
695 |     0.7 0.1
696 |     0.8 0.08
697 |     0.9 0.05
698 |     1.0 0.05
699 |     EOF
700 | 
701 |     my %methodA = %(:vertices(@methodA), :style("linespoints"), :title("proposed"), :lc(qw/rgb "green"/), :pt(10));
702 |     my %methodB = %(:vertices(@methodB), :style("linespoints"), :title("baseline"), :lc(qw/rgb "red"/), :pt(13));
703 | 
704 |     $gnu.plot(|%methodA);
705 |     $gnu.plot(|%methodB);
706 |     $gnu.dispose;
707 | 
708 | ### OUTPUT
709 | 
710 | <img src="recprec.png" alt="recall precision curve">
711 | 
712 | How to use Chart::Gnuplot on jupyter?
713 | =====================================
714 | 
715 | One way to do this is:
716 | 
717 |   * 1. Write a svg image as a tmp file.
718 | 
719 |   * 2. Read this tmp file and remove the first superfluous line.
720 | 
721 | If you haven't setup Raku kernel yet, use [Jupyter::Kernel](https://github.com/bduggan/raku-jupyter-kernel).
722 | 
723 | ### SOURCE
724 | 
725 |     use Chart::Gnuplot;
726 |     use Chart::Gnuplot::Subset;
727 |     use File::Temp;
728 | 
729 |     my ($filename, $filehandle);
730 | 
731 |     # NOTE: Shouldn't remove both ENTER and LEAVE blocks. File::Temp's auto-unlink doesn't seem to work on jupyter.
732 |     ENTER {
733 |       ($filename, $filehandle) = tempfile(:tempdir("/tmp"), :suffix(".svg"));
734 |     }
735 | 
736 |     LEAVE {
737 |       $filehandle.close;
738 |       $filename.IO.unlink;
739 |     }
740 | 
741 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename($filename));
742 | 
743 |     my @data = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
744 |     Year Male Female
745 |     1950 100 90
746 |     1960 100 90
747 |     1970 80 70
748 |     1980 130 140
749 |     1990 140 120
750 |     2000 200 210
751 |     2010 240 230
752 |     2020 400 420
753 |     EOF
754 | 
755 |     my ($header, *@body) = @data;
756 | 
757 |     $gnu.command("set style histogram clustered");
758 |     $gnu.legend(:left);
759 |     my AnyTicsTic @tics = (@body>>.[0]).pairs.map(-> (:key($pos), :value($year)) { %(:label($year), :pos($pos)) });
760 |     $gnu.xtics(:tics(@tics));
761 |     $gnu.xlabel(:label($header[0]));
762 |     $gnu.plot(:vertices(@body), :using([2]), :style("histogram"), :title($header[1]), :fill("solid 1.0"));
763 |     $gnu.plot(:vertices(@body), :using([3]), :style("histogram"), :title($header[2]), :fill("solid 1.0"));
764 |     $gnu.dispose;
765 | 
766 |     $filehandle.lines[1..*].join("\n");
767 | 
768 | The example ipynb file is here: [/notebooks/synopsis.ipynb](/notebooks/synopsis.ipynb).
769 | 
770 | AUTHOR
771 | ======
772 | 
773 | titsuki <titsuki@cpan.org>
774 | 
775 | COPYRIGHT AND LICENSE
776 | =====================
777 | 
778 | Copyright 2017 titsuki
779 | 
780 | This library is free software; you can redistribute it and/or modify it under the GNU General Public License version 3.0.
781 | 
782 | 


--------------------------------------------------------------------------------
/dist.ini:
--------------------------------------------------------------------------------
 1 | name = Chart-Gnuplot
 2 | 
 3 | [ReadmeFromPod]
 4 | ; disable = true
 5 | filename = lib/Chart/Gnuplot.pm6
 6 | 
 7 | [PruneFiles]
 8 | ; match = ^ 'xt/'
 9 | 
10 | [Badges]
11 | provider = github-actions/test
12 | 


--------------------------------------------------------------------------------
/histogram.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/titsuki/raku-Chart-Gnuplot/490a4b7a15975742a0438d66de3753879836b2d8/histogram.png


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot.pm6:
--------------------------------------------------------------------------------
   1 | use v6;
   2 | unit class Chart::Gnuplot:ver<0.0.21>;
   3 | 
   4 | use Chart::Gnuplot::Arrow;
   5 | use Chart::Gnuplot::Border;
   6 | use Chart::Gnuplot::Grid;
   7 | use Chart::Gnuplot::Label;
   8 | use Chart::Gnuplot::Legend;
   9 | use Chart::Gnuplot::Object;
  10 | use Chart::Gnuplot::Output;
  11 | use Chart::Gnuplot::Range;
  12 | use Chart::Gnuplot::Terminal;
  13 | use Chart::Gnuplot::Tics;
  14 | use Chart::Gnuplot::Timestamp;
  15 | use Chart::Gnuplot::Title;
  16 | use Chart::Gnuplot::Util;
  17 | use Chart::Gnuplot::Subset;
  18 | 
  19 | has $!gnuplot;
  20 | has Bool $.persist;
  21 | has $.debug;
  22 | has %.options;
  23 | has Int $!num-plot;
  24 | has $!promise;
  25 | has $!msg-channel;
  26 | has $!msg-supply;
  27 | has &!writer;
  28 | 
  29 | has Chart::Gnuplot::Arrow $!arrow handles <arrow>;
  30 | has Chart::Gnuplot::Border $!border handles <border>;
  31 | has Chart::Gnuplot::Grid $!grid handles <grid>;
  32 | has Chart::Gnuplot::Label $!label handles <label xlabel ylabel zlabel x2label y2label cblabel>;
  33 | has Chart::Gnuplot::Legend $!legend handles <legend>;
  34 | has Chart::Gnuplot::Object $!object handles <rectangle ellipse circle polygon>;
  35 | has Chart::Gnuplot::Output $.output;
  36 | has Chart::Gnuplot::Range $!range handles <xrange yrange zrange x2range y2range cbrange rrange trange urange vrange>;
  37 | has Chart::Gnuplot::Terminal $!terminal;
  38 | has Chart::Gnuplot::Tics $!tics handles <xtics ytics ztics x2tics y2tics cbtics>;
  39 | has Chart::Gnuplot::Timestamp $!timestamp handles <timestamp>;
  40 | has Chart::Gnuplot::Title $!title handles <title>;
  41 | 
  42 | submethod BUILD(:$terminal!, Str :$filename, :$!persist = True, :$!debug = False, :&!writer? = -> $msg { self.command: $msg }, :$stderr = $*ERR) {
  43 |     my $HOME = qq:x/echo \$HOME/.subst(/\s*/,"",:g);
  44 |     my $prefix = "$HOME/.p6chart-gnuplot";
  45 | 
  46 |     my @opts;
  47 |     @opts.push('-persist') if $!persist;
  48 |     $!gnuplot = Proc::Async.new(:w, "$prefix/bin/gnuplot", @opts.join(" "));
  49 | 
  50 |     if $!debug {
  51 |         $!msg-channel = Channel.new;
  52 |         $!msg-supply = $!msg-channel.Supply;
  53 |         $!gnuplot.stderr.act(-> $v { $!msg-channel.send($v); });
  54 |         $!gnuplot.stdout.act(-> $v { $!msg-channel.send($v); });
  55 |         $!msg-supply.tap(-> $v { $stderr.print: $v } );
  56 |     } else {
  57 |         $!gnuplot.stderr.act({;});
  58 |         $!gnuplot.stdout.act({;});
  59 |     }
  60 |     $!promise = $!gnuplot.start;
  61 |     $!num-plot = 0;
  62 | 
  63 |     $!arrow = Chart::Gnuplot::Arrow.new(:&!writer);
  64 |     $!border = Chart::Gnuplot::Border.new(:&!writer);
  65 |     $!grid = Chart::Gnuplot::Grid.new(:&!writer);
  66 |     $!label = Chart::Gnuplot::Label.new(:&!writer);
  67 |     $!legend = Chart::Gnuplot::Legend.new(:&!writer);
  68 |     $!object = Chart::Gnuplot::Object.new(:&!writer);
  69 |     $!output = Chart::Gnuplot::Output.new(:$filename, :&!writer);
  70 |     $!range = Chart::Gnuplot::Range.new(:&!writer);
  71 |     $!terminal = Chart::Gnuplot::Terminal.new(:type($terminal), :&!writer);
  72 |     $!tics = Chart::Gnuplot::Tics.new(:&!writer);
  73 |     $!timestamp = Chart::Gnuplot::Timestamp.new(:&!writer);
  74 |     $!title = Chart::Gnuplot::Title.new(:&!writer);
  75 | }
  76 | 
  77 | submethod DESTROY {
  78 |     $!gnuplot.close-stdin;
  79 |     await $!promise;
  80 | }
  81 | 
  82 | method terminal($terminal, :&writer? = -> $msg { self.command: $msg }) {
  83 |     $!terminal.writer(&writer).type($terminal).set;
  84 | }
  85 | 
  86 | multi method plot(:$title, :$ignore, :@range, :@vertices!, :$smooth,
  87 |                   :@using,
  88 |                   Str :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
  89 |                   :pt(:$pointtype), :ps(:$pointsize), :$fill, FalseOnly :$hidden3d, FalseOnly :$contours, FalseOnly :$surface, :$palette,
  90 |                   :&writer? = -> $msg { self.command: $msg }) {
  91 |     my @args;
  92 | 
  93 |     my $tmpvariable = '$mydata' ~ ($*PID, time, @vertices.WHERE).join;
  94 |     &writer(sprintf("%s << EOD", $tmpvariable));
  95 |     for ^@vertices.elems -> $r {
  96 |         &writer(@vertices[$r;*].join(" "));
  97 |     }
  98 |     &writer("EOD");
  99 | 
 100 |     for @range {
 101 |         @args.push(sprintf("[%s]", $_.join(":")));
 102 |     }
 103 | 
 104 |     @args.push($tmpvariable);
 105 |     @args.push("using " ~ @using.join(":")) if @using.elems > 0;
 106 |     @args.push(sprintf("smooth %s", $smooth)) if $smooth.defined;
 107 |     @args.push("with " ~ $style) if $style.defined;
 108 | 
 109 |     if $title.defined {
 110 |         given $title {
 111 |             when * ~~ Str { @args.push(sprintf("title \"%s\"", $title)) }
 112 |             when * == False { @args.push(sprintf("notitle")) }
 113 |         }
 114 |     }
 115 | 
 116 |     @args.push(sprintf("notitle [%s]", $ignore)) if $ignore.defined;
 117 | 
 118 |     @args.push("linestyle " ~ $linestyle) if $linestyle.defined;
 119 |     @args.push("linetype " ~ $linetype) if $linetype.defined;
 120 |     @args.push("linewidth " ~ $linewidth) if $linewidth.defined;
 121 |     @args.push("linecolor " ~ $linecolor) if $linecolor.defined;
 122 |     @args.push("pointtype " ~ $pointtype) if $pointtype.defined;
 123 |     @args.push("pointsize " ~ $pointsize) if $pointsize.defined;
 124 |     @args.push("fill " ~ $fill) if $fill.defined;
 125 |     @args.push("nohidden3d") if $hidden3d.defined and $hidden3d == False;
 126 |     @args.push("nocontours") if $contours.defined and $contours == False;
 127 |     @args.push("nosurface") if $surface.defined and $surface == False;
 128 |     @args.push("palette") if $palette.defined;
 129 | 
 130 |     $!terminal.writer(&writer).set;
 131 |     $!output.writer(&writer).set;
 132 | 
 133 |     my $cmd = do given $!num-plot {
 134 |         when * > 0 { "replot" }
 135 |         default { "plot" }
 136 |     };
 137 |     &writer(sprintf("%s %s",$cmd, @args.grep(* ne "").join(" ")));
 138 |     $!num-plot++;
 139 | }
 140 | 
 141 | multi method plot(:$title, :$ignore, :@range, :$function!, :$smooth,
 142 |                   Str :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 143 |                   :pt(:$pointtype), :ps(:$pointsize), :$fill, FalseOnly :$hidden3d, FalseOnly :$contours, FalseOnly :$surface, :$palette,
 144 |                   :&writer? = -> $msg { self.command: $msg }) {
 145 |     my @args;
 146 | 
 147 |     for @range {
 148 |         @args.push(sprintf("[%s]", $_.join(":")));
 149 |     }
 150 |     
 151 |     @args.push($function) if $function.defined;
 152 | 
 153 |     if $title.defined {
 154 |         given $title {
 155 |             when * ~~ Str { @args.push(sprintf("title \"%s\"", $title)) }
 156 |             when * == False { @args.push(sprintf("notitle")) }
 157 |         }
 158 |     }
 159 | 
 160 |     @args.push(sprintf("notitle [%s]", $ignore)) if $ignore.defined;
 161 |     @args.push(sprintf("smooth %s", $smooth)) if $smooth.defined;
 162 |     @args.push("with " ~ $style) if $style.defined;
 163 | 
 164 |     @args.push("linestyle " ~ $linestyle) if $linestyle.defined;
 165 |     @args.push("linetype " ~ $linetype) if $linetype.defined;
 166 |     @args.push("linewidth " ~ $linewidth) if $linewidth.defined;
 167 |     @args.push("linecolor " ~ $linecolor) if $linecolor.defined;
 168 |     @args.push("pointtype " ~ $pointtype) if $pointtype.defined;
 169 |     @args.push("pointsize " ~ $pointsize) if $pointsize.defined;
 170 |     @args.push("fill " ~ $fill) if $fill.defined;
 171 |     @args.push("nohidden3d") if $hidden3d.defined and $hidden3d == False;
 172 |     @args.push("nocontours") if $contours.defined and $contours == False;
 173 |     @args.push("nosurface") if $surface.defined and $surface == False;
 174 |     @args.push("palette") if $palette.defined;
 175 | 
 176 |     $!terminal.writer(&writer).set;
 177 |     $!output.writer(&writer).set;
 178 | 
 179 |     my $cmd = do given $!num-plot {
 180 |         when * > 0 { "replot" }
 181 |         default { "plot" }
 182 |     };
 183 | 
 184 |     &writer(sprintf("%s %s", $cmd, @args.grep(* ne "").join(" ")));
 185 |     $!num-plot++;
 186 | }
 187 | 
 188 | multi method splot(:@range,
 189 |                    :@vertices!, :$smooth,
 190 |                    :$binary, :$matrix, :$index, :$every,
 191 |                    :$title, :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 192 |                    :pt(:$pointtype), :ps(:$pointsize), :$fill, FalseOnly :$hidden3d, FalseOnly :$contours, FalseOnly :$surface, :$palette, :&writer? = -> $msg { self.command: $msg }) {
 193 |     my @args;
 194 | 
 195 |     for @range {
 196 |         @args.push(sprintf("[%s]", $_.join(":")));
 197 |     }
 198 | 
 199 |     my $tmpvariable = '$mydata' ~ ($*PID, time, @vertices.WHERE).join;
 200 |     &writer(sprintf("%s << EOD", $tmpvariable));
 201 |     for ^@vertices.elems -> $r {
 202 |         &writer(@vertices[$r;*].join(" "));
 203 |     }
 204 |     &writer("EOD");
 205 | 
 206 |     @args.push($tmpvariable);
 207 | 
 208 |     @args.push("binary") if $binary.defined;
 209 |     @args.push("matrix") if $matrix.defined;
 210 |     @args.push("index") if $index.defined;
 211 |     @args.push("every") if $every.defined;
 212 | 
 213 |     if $title.defined {
 214 |         given $title {
 215 |             when * ~~ Str { @args.push(sprintf("title \"%s\"", $title)) }
 216 |             when * == False { @args.push(sprintf("notitle")) }
 217 |         }
 218 |     }
 219 | 
 220 |     @args.push(sprintf("smooth %s", $smooth)) if $smooth.defined;
 221 |     @args.push("with " ~ $style) if $style.defined;
 222 | 
 223 |     @args.push("linestyle " ~ $linestyle) if $linestyle.defined;
 224 |     @args.push("linetype " ~ $linetype) if $linetype.defined;
 225 |     @args.push("linewidth " ~ $linewidth) if $linewidth.defined;
 226 |     @args.push("linecolor " ~ $linecolor) if $linecolor.defined;
 227 |     @args.push("pointtype " ~ $pointtype) if $pointtype.defined;
 228 |     @args.push("pointsize " ~ $pointsize) if $pointsize.defined;
 229 |     @args.push("fill " ~ $fill) if $fill.defined;
 230 |     @args.push("nohidden3d") if $hidden3d.defined and $hidden3d == False;
 231 |     @args.push("nocontours") if $contours.defined and $contours == False;
 232 |     @args.push("nosurface") if $surface.defined and $surface == False;
 233 |     @args.push("palette") if $palette.defined;
 234 | 
 235 |     $!terminal.writer(&writer).set;
 236 |     $!output.writer(&writer).set;
 237 | 
 238 |     my $cmd = do given $!num-plot {
 239 |         when * > 0 { "replot" }
 240 |         default { "splot" }
 241 |     };
 242 |     &writer(sprintf("%s %s", $cmd, @args.grep(* ne "").join(" ")));
 243 |     $!num-plot++;
 244 | }
 245 | 
 246 | multi method splot(:@range,
 247 |                    :$function!, :$smooth,
 248 |                    :$title, :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 249 |                    :pt(:$pointtype), :ps(:$pointsize), :$fill, FalseOnly :$hidden3d, FalseOnly :$contours, FalseOnly :$surface, :$palette, :&writer? = -> $msg { self.command: $msg }) {
 250 |     my @args;
 251 | 
 252 |     for @range {
 253 |         @args.push(sprintf("[%s]", $_.join(":")));
 254 |     }
 255 | 
 256 |     @args.push($function) if $function.defined;
 257 | 
 258 |     if $title.defined {
 259 |         given $title {
 260 |             when * ~~ Str { @args.push(sprintf("title \"%s\"", $title)) }
 261 |             when * == False { @args.push(sprintf("notitle")) }
 262 |         }
 263 |     }
 264 | 
 265 |     @args.push(sprintf("smooth %s", $smooth)) if $smooth.defined;
 266 |     @args.push("with " ~ $style) if $style.defined;
 267 | 
 268 |     @args.push("linestyle " ~ $linestyle) if $linestyle.defined;
 269 |     @args.push("linetype " ~ $linetype) if $linetype.defined;
 270 |     @args.push("linewidth " ~ $linewidth) if $linewidth.defined;
 271 |     @args.push("linecolor " ~ $linecolor) if $linecolor.defined;
 272 |     @args.push("pointtype " ~ $pointtype) if $pointtype.defined;
 273 |     @args.push("pointsize " ~ $pointsize) if $pointsize.defined;
 274 |     @args.push("fill " ~ $fill) if $fill.defined;
 275 |     @args.push("nohidden3d") if $hidden3d.defined and $hidden3d == False;
 276 |     @args.push("nocontours") if $contours.defined and $contours == False;
 277 |     @args.push("nosurface") if $surface.defined and $surface == False;
 278 |     @args.push("palette") if $palette.defined;
 279 | 
 280 |     $!terminal.writer(&writer).set;
 281 |     $!output.writer(&writer).set;
 282 | 
 283 |     my $cmd = do given $!num-plot {
 284 |         when * > 0 { "replot" }
 285 |         default { "splot" }
 286 |     };
 287 |     &writer(sprintf("%s %s", $cmd, @args.grep(* ne "").join(" ")));
 288 |     $!num-plot++;
 289 | }
 290 | 
 291 | method multiplot(:$title, :$font-name, :$font-size, Bool :$enhanced, :@layout, :$rowsfirst, :$columnsfirst,
 292 |                  :$downwards, :$upwards, :$scale, :$offset, :$margins,
 293 |                  :$spacing, :&writer = -> $msg { self.command: $msg }) {
 294 |     my @args;
 295 | 
 296 |     @args.push(sprintf("title \"%s\"", $title)) if $title.defined;
 297 |     @args.push(tweak-fontargs(:$font-name, :$font-size));
 298 |     @args.push($enhanced ?? "enhanced" !! "noenhanced") if $enhanced.defined;
 299 |     @args.push("layout " ~ @layout.join(",")) if @layout.elems > 0;
 300 |     @args.push("rowsfirst") if $rowsfirst.defined;
 301 |     @args.push("columnsfirst") if $columnsfirst.defined;
 302 |     @args.push("downwards") if $downwards.defined;
 303 |     @args.push("upwards") if $upwards.defined;
 304 |     @args.push("scale " ~ $scale.join(",")) if $scale.defined;
 305 |     @args.push(tweak-coordinate(:name("offset"), :coordinate($offset)));
 306 |     @args.push("margins " ~ $margins.join(",")) if $margins.elems == 4;
 307 |     @args.push("spacing " ~ $spacing.join(",")) if $spacing.defined;
 308 | 
 309 |     &writer(sprintf("set multiplot %s", @args.grep(* ne "").join(" ")));
 310 | }
 311 | 
 312 | method dispose {
 313 |     self.command: "exit";
 314 |     $!gnuplot.close-stdin;
 315 |     try sink await $!promise;
 316 | }
 317 | 
 318 | method command(Str $command, :$stderr = $*ERR) {
 319 |     if $!debug {
 320 |         $stderr.say: $command;
 321 |     }
 322 |     try sink await $!gnuplot.say: $command;
 323 | }
 324 | 
 325 | =begin pod
 326 | 
 327 | =head1 NAME
 328 | 
 329 | Chart::Gnuplot - A Raku bindings for gnuplot
 330 | 
 331 | =head1 SYNOPSIS
 332 | 
 333 | =head3 SOURCE
 334 | 
 335 |     use Chart::Gnuplot;
 336 |     use Chart::Gnuplot::Subset;
 337 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("histogram.png"));
 338 |     
 339 |     my @data = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
 340 |     Year Male Female
 341 |     1950 100 90
 342 |     1960 100 90
 343 |     1970 80 70
 344 |     1980 130 140
 345 |     1990 140 120
 346 |     2000 200 210
 347 |     2010 240 230
 348 |     2020 400 420
 349 |     EOF
 350 |     
 351 |     my ($header, *@body) = @data;
 352 |     
 353 |     $gnu.command("set style histogram clustered");
 354 |     $gnu.legend(:left);
 355 |     my AnyTicsTic @tics = (@body>>.[0]).pairs.map(-> (:key($pos), :value($year)) { %(:label($year), :pos($pos)) });
 356 |     $gnu.xtics(:tics(@tics));
 357 |     $gnu.xlabel(:label($header[0]));
 358 |     $gnu.plot(:vertices(@body), :using([2]), :style("histogram"), :title($header[1]), :fill("solid 1.0"));
 359 |     $gnu.plot(:vertices(@body), :using([3]), :style("histogram"), :title($header[2]), :fill("solid 1.0"));
 360 |     
 361 |     $gnu.dispose;
 362 | 
 363 | =head3 OUTPUT
 364 | 
 365 | =begin para
 366 | 
 367 |     <img src="histogram.png" alt="histogram">
 368 | 
 369 | =end para
 370 | 
 371 | =head1 DESCRIPTION
 372 | 
 373 | Chart::Gnuplot is a Raku naive bindings for gnuplot. Chart::Gnuplot runs C<gnuplot> using C<Proc::Async> and enables you to plot chart or graph with Rakuish interface.
 374 | 
 375 | 
 376 | =head2 SUBSET
 377 | 
 378 | Defined as:
 379 | 
 380 |         subset FalseOnly of Bool is export where { $_ ~~ Bool:U or $_ === False };
 381 |         subset TrueOnly of Bool is export where { $_ ~~ Bool:U or $_ === True};
 382 |         subset LabelRotate of Cool is export where { $_ ~~ Cool:U or $_ ~~ Real or $_ === False };
 383 |         subset AnyLabelRotate of Cool is export where { $_ ~~ Cool:U or $_ eq "parallel" or $_ ~~ Real or $_ === False };
 384 |         subset LegendMax of Cool is export where { $_ ~~ Cool:U or $_ eq "auto" or $_ ~~ Real };
 385 |         subset AnyTicsRotate of Cool is export where { $_ ~~ Cool:U or $_ ~~ Real or $_ === False };
 386 |         subset AnyTicsOffset of Mu is export where { $_ ~~ Mu:U or $_ ~~ FalseOnly or ($_ ~~ List and $_.all ~~ Pair|Real) };
 387 |         subset AnyTicsTic of Mu is export where { $_ ~~ Mu:U or $_ ~~ Hash and .<label>:exists and .<pos>:exists and .keys.grep(* eq "label"|"pos"|"level").elems == .keys.elems };
 388 | 
 389 | =head2 METHODS
 390 | 
 391 | =head3 terminal
 392 | 
 393 | Defined as:
 394 | 
 395 |         method terminal($terminal)
 396 | 
 397 | Tells gnuplot what kind of output to generate.
 398 | 
 399 | =head3 plot
 400 | 
 401 | Defined as:
 402 | 
 403 |         multi method plot(
 404 |                 :$title, :$ignore, :@range, :@vertices!, :$smooth,
 405 |                 :@using,
 406 |                 Str :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 407 |                 :pt(:$pointtype), :ps(:$pointsize), :$fill, FalseOnly :$hidden3d, FalseOnly :$contours,
 408 |                 FalseOnly :$surface, :$palette,
 409 |                 :&writer? = -> $msg { self.command: $msg }
 410 |         )
 411 | 
 412 |         multi method plot(
 413 |               :$title, :$ignore, :@range, :$function!, :$smooth,
 414 |               Str :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 415 |               :pt(:$pointtype), :ps(:$pointsize), :$fill, FalseOnly :$hidden3d, FalseOnly :$contours,
 416 |               FalseOnly :$surface, :$palette,
 417 |               :&writer? = -> $msg { self.command: $msg }
 418 |         )
 419 | 
 420 | Draws a 2-dimensional plot.
 421 | 
 422 | =head3 splot
 423 | 
 424 | Defined as:
 425 | 
 426 |         multi method splot(
 427 |               :@range,
 428 |               :@vertices!, :$smooth,
 429 |               :$binary, :$matrix, :$index, :$every,
 430 |               :$title, :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 431 |               :$pointtype, :$pointsize, :$fill, FalseOnly :$hidden3d, FalseOnly :$contours,
 432 |               FalseOnly :$surface, :$palette, :&writer? = -> $msg { self.command: $msg }
 433 |         )
 434 | 
 435 |         multi method splot(
 436 |               :@range,
 437 |               :$function!, :$smooth,
 438 |               :$title, :$style, :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor),
 439 |               :$pointtype, :$pointsize, :$fill, FalseOnly :$hidden3d, FalseOnly :$contours,
 440 |               FalseOnly :$surface, :$palette, :&writer? = -> $msg { self.command: $msg }
 441 |         )
 442 | 
 443 | Draws a 3-dimensional plot.
 444 | 
 445 | =head3 label
 446 | 
 447 | Defined as:
 448 | 
 449 |         method label(
 450 |                :$tag, Str :$label-text, :$at, TrueOnly :$left, TrueOnly :$center, TrueOnly :$right,
 451 |                LabelRotate :$rotate, :$font-name, :$font-size, FalseOnly :$enhanced,
 452 |                TrueOnly :$front, TrueOnly :$back, :$textcolor, FalseOnly :$point, :$line-type, :$point-type, :$point-size, :$offset,
 453 |                TrueOnly :$boxed, TrueOnly :$hypertext, :&writer? = -> $msg { self.command: $msg }
 454 |         )
 455 | 
 456 | Places the text string at the corresponding 2D or 3D position.
 457 | 
 458 | =head3 xlabel
 459 | 
 460 | Defined as:
 461 | 
 462 |        method xlabel(
 463 |               Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
 464 |               Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
 465 |        )
 466 | 
 467 | Sets the x-axis label.
 468 | 
 469 | =head3 ylabel
 470 | 
 471 | Defined as:
 472 | 
 473 |        method ylabel(
 474 |               Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
 475 |               Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
 476 |        )
 477 | 
 478 | Sets the y-axis label.
 479 | 
 480 | =head3 zlabel
 481 | 
 482 | Defined as:
 483 | 
 484 |        method zlabel(
 485 |               Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
 486 |               Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
 487 |        )
 488 | 
 489 | Sets the z-axis label.
 490 | 
 491 | =head3 x2label
 492 | 
 493 | Defined as:
 494 | 
 495 |        method x2label(
 496 |               Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
 497 |               Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
 498 |        )
 499 | 
 500 | Sets the x2-axis label.
 501 | 
 502 | =head3 y2label
 503 | 
 504 | Defined as:
 505 | 
 506 |        method y2label(
 507 |               Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
 508 |               Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
 509 |        )
 510 | 
 511 | Sets the y2-axis label.
 512 | 
 513 | =head3 cblabel
 514 | 
 515 | Defined as:
 516 | 
 517 |        method cblabel(
 518 |               Str :$label, :$offset, :$font-name, :$font-size, :$textcolor,
 519 |               Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }
 520 |        )
 521 | 
 522 | Sets the cb-axis label.
 523 | 
 524 | =head3 xrange
 525 | 
 526 | Defined as:
 527 | 
 528 |         multi method xrange(
 529 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 530 |               :&writer? = -> $msg { self.command: $msg }
 531 |         )
 532 | 
 533 |         multi method xrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 534 | 
 535 | Sets the horizontal range that will be displayed.
 536 | 
 537 | =head3 yrange
 538 | 
 539 | Defined as:
 540 | 
 541 |         multi method yrange(
 542 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 543 |               :&writer? = -> $msg { self.command: $msg }
 544 |         )
 545 | 
 546 |         multi method yrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 547 | 
 548 | Sets the vertical range that will be displayed.
 549 | 
 550 | =head3 zrange
 551 | 
 552 | Defined as:
 553 | 
 554 |         multi method zrange(
 555 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 556 |               :&writer? = -> $msg { self.command: $msg }
 557 |         )
 558 | 
 559 |         multi method zrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 560 | 
 561 | Sets the range that will be displayed on the z axis.
 562 | 
 563 | =head3 x2range
 564 | 
 565 | Defined as:
 566 | 
 567 |         multi method x2range(
 568 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 569 |               :&writer? = -> $msg { self.command: $msg }
 570 |         )
 571 | 
 572 |         multi method x2range(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 573 | 
 574 | Sets the range that will be displayed on the x2 axis.
 575 | 
 576 | =head3 y2range
 577 | 
 578 | Defined as:
 579 | 
 580 |         multi method y2range(
 581 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 582 |               :&writer? = -> $msg { self.command: $msg }
 583 |         )
 584 | 
 585 |         multi method y2range(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 586 | 
 587 | Sets the range that will be displayed on the y2 axis.
 588 | 
 589 | =head3 cbrange
 590 | 
 591 | Defined as:
 592 | 
 593 |         multi method cbrange(
 594 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 595 |               :&writer? = -> $msg { self.command: $msg }
 596 |         )
 597 | 
 598 |         multi method cbrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 599 | 
 600 | Sets the range of values which are colored.
 601 | 
 602 | =head3 rrange
 603 | 
 604 | Defined as:
 605 | 
 606 |         multi method rrange(
 607 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 608 |               :&writer? = -> $msg { self.command: $msg }
 609 |         )
 610 | 
 611 |         multi method rrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 612 | 
 613 | Sets the range that will be displayed on the r axis.
 614 | 
 615 | =head3 trange
 616 | 
 617 | Defined as:
 618 | 
 619 |         multi method trange(
 620 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 621 |               :&writer? = -> $msg { self.command: $msg }
 622 |         )
 623 | 
 624 |         multi method trange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 625 | 
 626 | Sets the parametric range used to compute x and y values when in parametric or polar modes.
 627 | 
 628 | =head3 urange
 629 | 
 630 | Defined as:
 631 | 
 632 |         multi method urange(
 633 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 634 |               :&writer? = -> $msg { self.command: $msg }
 635 |         )
 636 | 
 637 |         multi method urange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 638 | 
 639 | Set the parametric ranges used to compute x, y, and z values when in splot parametric mode.
 640 | 
 641 | =head3 vrange
 642 | 
 643 | Defined as:
 644 | 
 645 |         multi method vrange(
 646 |               :$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend,
 647 |               :&writer? = -> $msg { self.command: $msg }
 648 |         )
 649 | 
 650 |         multi method vrange(TrueOnly :$restore, :&writer? = -> $msg { self.command: $msg })
 651 | 
 652 | Set the parametric ranges used to compute x, y, and z values when in splot parametric mode.
 653 | 
 654 | =head3 xtics
 655 | 
 656 | Defined as:
 657 | 
 658 |         method xtics(
 659 |                TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
 660 |                TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
 661 |                TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
 662 |                TrueOnly :$add,
 663 |                TrueOnly :$autofreq,
 664 |                :$incr,
 665 |                :$start, :$end,
 666 |                :@tics where Array[AnyTicsTic] | Array[],
 667 |                :$format, :$font-name, :$font-size, Bool :$enhanced,
 668 |                TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
 669 |                TrueOnly :$rangelimited,
 670 |                :$textcolor, :&writer? = -> $msg { self.command: $msg }
 671 |         )
 672 | 
 673 | Controls the major (labeled) tics on the x axis.
 674 | 
 675 | =head3 ytics
 676 | 
 677 | Defined as:
 678 | 
 679 |         method ytics(
 680 |                TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
 681 |                TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
 682 |                TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
 683 |                TrueOnly :$add,
 684 |                TrueOnly :$autofreq,
 685 |                :$incr,
 686 |                :$start, :$end,
 687 |                :@tics where Array[AnyTicsTic] | Array[],
 688 |                :$format, :$font-name, :$font-size, Bool :$enhanced,
 689 |                TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
 690 |                TrueOnly :$rangelimited,
 691 |                :$textcolor, :&writer? = -> $msg { self.command: $msg }
 692 |         )
 693 | 
 694 | Controls the major (labeled) tics on the y axis.
 695 | 
 696 | =head3 ztics
 697 | 
 698 | Defined as:
 699 | 
 700 |         method ztics(
 701 |                TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
 702 |                TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
 703 |                TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
 704 |                TrueOnly :$add,
 705 |                TrueOnly :$autofreq,
 706 |                :$incr,
 707 |                :$start, :$end,
 708 |                :@tics where Array[AnyTicsTic] | Array[],
 709 |                :$format, :$font-name, :$font-size, Bool :$enhanced,
 710 |                TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
 711 |                TrueOnly :$rangelimited,
 712 |                :$textcolor, :&writer? = -> $msg { self.command: $msg }
 713 |         )
 714 | 
 715 | Controls the major (labeled) tics on the z axis.
 716 | 
 717 | =head3 x2tics
 718 | 
 719 | Defined as:
 720 | 
 721 |         method x2tics(
 722 |                TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
 723 |                TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
 724 |                TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
 725 |                TrueOnly :$add,
 726 |                TrueOnly :$autofreq,
 727 |                :$incr,
 728 |                :$start, :$end,
 729 |                :@tics where Array[AnyTicsTic] | Array[],
 730 |                :$format, :$font-name, :$font-size, Bool :$enhanced,
 731 |                TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
 732 |                TrueOnly :$rangelimited,
 733 |                :$textcolor, :&writer? = -> $msg { self.command: $msg }
 734 |         )
 735 | 
 736 | Controls the major (labeled) tics on the x2 axis.
 737 | 
 738 | =head3 y2tics
 739 | 
 740 | Defined as:
 741 | 
 742 |         method y2tics(
 743 |                TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
 744 |                TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
 745 |                TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
 746 |                TrueOnly :$add,
 747 |                TrueOnly :$autofreq,
 748 |                :$incr,
 749 |                :$start, :$end,
 750 |                :@tics where Array[AnyTicsTic] | Array[],
 751 |                :$format, :$font-name, :$font-size, Bool :$enhanced,
 752 |                TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
 753 |                TrueOnly :$rangelimited,
 754 |                :$textcolor, :&writer? = -> $msg { self.command: $msg }
 755 |         )
 756 | 
 757 | Controls the major (labeled) tics on the y2 axis.
 758 | 
 759 | =head3 cbtics
 760 | 
 761 | Defined as:
 762 | 
 763 |         method cbtics(
 764 |                TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
 765 |                TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
 766 |                TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
 767 |                TrueOnly :$add,
 768 |                TrueOnly :$autofreq,
 769 |                :$incr,
 770 |                :$start, :$end,
 771 |                :@tics where Array[AnyTicsTic] | Array[],
 772 |                :$format, :$font-name, :$font-size, Bool :$enhanced,
 773 |                TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
 774 |                TrueOnly :$rangelimited,
 775 |                :$textcolor, :&writer? = -> $msg { self.command: $msg }
 776 |         )
 777 | 
 778 | Controls the major (labeled) tics on the color box axis.
 779 | 
 780 | =head3 legend
 781 | 
 782 | Defined as:
 783 | 
 784 |         method legend(
 785 |                TrueOnly :$on, TrueOnly :$off, TrueOnly :$default, TrueOnly :$inside, TrueOnly :$outside, TrueOnly :$lmargin, TrueOnly :$rmargin, TrueOnly :$tmargin, TrueOnly :$bmargin,
 786 |                :$at,
 787 |                TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$top, TrueOnly :$bottom,
 788 |                TrueOnly :$vertical, TrueOnly :$horizontal, TrueOnly :$Left, TrueOnly :$Right,
 789 |                Bool :$opaque, Bool :$reverse, Bool :$invert,
 790 |                :$samplen, :$spacing, :$width, :$height,
 791 |                TrueOnly :$autotitle, TrueOnly :$columnheader, :$title, :$font-name, :$font-size, :$textcolor,
 792 |                Bool :$box, :$linestyle, :$linetype, :$linewidth,
 793 |                LegendMax :$maxcols, LegendMax :$maxrows, :&writer? = -> $msg { self.command: $msg }
 794 |         )
 795 | 
 796 | Enables a key (or legend) containing a title and a sample (line, point, box) for each plot in the graph.
 797 | 
 798 | =head3 border
 799 | 
 800 | Defined as:
 801 | 
 802 |         method border(
 803 |                :$integer, TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind,
 804 |                :lw(:$linewidth), :ls(:$linestyle), :lt(:$linetype), :&writer? = -> $msg { self.command: $msg }
 805 |         )
 806 | 
 807 | Controls the display of the graph borders for the plot and splot commands.
 808 | 
 809 | =head3 grid
 810 | 
 811 | Defined as:
 812 | 
 813 |         method grid(
 814 |                Bool :$xtics, TrueOnly :$mxtics, Bool :$ytics, TrueOnly :$mytics, Bool :$ztics, TrueOnly :$mztics,
 815 |                Bool :$x2tics, TrueOnly :$mx2tics, Bool :$y2tics, TrueOnly :$my2tics, Bool :$cbtics, TrueOnly :$mcbtics,
 816 |                :$polar, TrueOnly :$layerdefault, TrueOnly :$front, TrueOnly :$back,
 817 |                :ls(:@linestyle), :lt(:@linetype), :lw(:@linewidth), :&writer? = -> $msg { self.command: $msg }
 818 |         )
 819 | 
 820 | Allows grid lines to be drawn on the plot.
 821 | 
 822 | =head3 timestamp
 823 | 
 824 | Defined as:
 825 | 
 826 |         method timestamp(
 827 |                 Str :$format, TrueOnly :$top, TrueOnly :$bottom, Bool :$rotate,
 828 |                 :$offset, :$font-name, :$font-size, :$textcolor, :&writer? = -> $msg { self.command: $msg }
 829 |         )
 830 | 
 831 | Places the time and date of the plot in the left margin.
 832 | 
 833 | =head3 rectangle
 834 | 
 835 | Defined as:
 836 | 
 837 |         multi method rectangle(
 838 |               :$index!, :$from, :$to,
 839 |               TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
 840 |               TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
 841 |         )
 842 | 
 843 |         multi method rectangle(
 844 |               :$index, :$from, :$rto,
 845 |               TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
 846 |               TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
 847 |         )
 848 | 
 849 | Defines a single rectangle which will appear in all subsequent 2D plot.
 850 |  
 851 | =head3 ellipse
 852 | 
 853 | Defined as:
 854 | 
 855 |         method ellipse(
 856 |                :$index, :center(:$at), :$w!, :$h!,
 857 |                TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
 858 |                TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
 859 |         )
 860 | 
 861 | Defines a single ellipse which will appear in all subsequent 2D plot.
 862 | 
 863 | =head3 circle
 864 | 
 865 | Defined as:
 866 | 
 867 |         method circle(
 868 |                :$index, :center(:$at), :$radius!,
 869 |                TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
 870 |                TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
 871 |         )
 872 | 
 873 | Defines a single circle which will appear in all subsequent 2D plot.
 874 | 
 875 | =head3 polygon
 876 | 
 877 | Defined as:
 878 | 
 879 |         method polygon(
 880 |                :$index, :$from, :@to,
 881 |                TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
 882 |                TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = -> $msg { self.command: $msg }
 883 |         )
 884 | 
 885 | Defines a single polygon which will appear in all subsequent 2D plot.
 886 | 
 887 | =head3 title
 888 | 
 889 | Defined as:
 890 | 
 891 |         method title(
 892 |                Str :$text, :$offset, :$font-name, :$font-size, :tc(:$textcolor), :$colorspec, Bool :$enhanced,
 893 |                :&writer? = -> $msg { self.command: $msg }
 894 |         )
 895 | 
 896 | Produces a plot title that is centered at the top of the plot.
 897 | 
 898 | =head3 arrow
 899 | 
 900 | Defined as:
 901 | 
 902 |         multi method arrow(
 903 |               :$tag, :$from, :$to, Bool :$head, TrueOnly :$backhead, TrueOnly :$heads,
 904 |               :$head-length, :$head-angle, :$back-angle,
 905 |               Bool :$filled, TrueOnly :$empty, TrueOnly :$border,
 906 |               TrueOnly :$front, TrueOnly :$back,
 907 |               :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor), :dt(:$dashtype), :&writer? = -> $msg { self.command: $msg }
 908 |         )
 909 | 
 910 | Places an arrow on a plot.
 911 | 
 912 | =head3 multiplot
 913 | 
 914 | Defined as:
 915 | 
 916 |         multi method arrow(
 917 |               :$tag, :$from, :$rto, Bool :$head, TrueOnly :$backhead, TrueOnly :$heads,
 918 |               :$head-length, :$head-angle, :$back-angle,
 919 |               Bool :$filled, TrueOnly :$empty, TrueOnly :$border,
 920 |               TrueOnly :$front, TrueOnly :$back,
 921 |               :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor), :dt(:$dashtype), :&writer? = -> $msg { self.command: $msg }
 922 |         )
 923 | 
 924 | Places gnuplot in the multiplot mode, in which several plots are placed next to each other on the same page or screen window.
 925 | 
 926 | =head3 command
 927 | 
 928 | Defined as:
 929 | 
 930 |         method command(Str $command)
 931 | 
 932 | Runs a given C<$command>. If there are no appropriate interfaces, this method will be a good alternative.
 933 | 
 934 | =head1 EXAMPLES
 935 | 
 936 | =head2 3D surface from a grid (matrix) of Z values
 937 | 
 938 | =head3 SOURCE
 939 | 
 940 |     use Chart::Gnuplot;
 941 | 
 942 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("surface.dem.00.png"));
 943 |     $gnu.title(:text("3D surface from a grid (matrix) of Z values"));
 944 |     $gnu.xrange(:min(-0.5), :max(4.5));
 945 |     $gnu.yrange(:min(-0.5), :max(4.5));
 946 |     $gnu.grid;
 947 |     $gnu.command("set hidden3d");
 948 | 
 949 |     my @grid = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
 950 |     5 4 3 1 0
 951 |     2 2 0 0 1
 952 |     0 0 0 1 0
 953 |     0 0 0 2 3
 954 |     0 1 2 4 3
 955 |     EOF
 956 | 
 957 |     $gnu.splot(:vertices(@grid), :style("lines"), :title(False), :matrix);
 958 |     $gnu.dispose;
 959 | 
 960 | =head3 OUTPUT
 961 | 
 962 | =begin para
 963 | 
 964 |     <img src="surface.dem.00.png" alt="3D surface from a grid (matrix) of Z values">
 965 | 
 966 | =end para
 967 | 
 968 | =head2 sin(x)
 969 | 
 970 | =head3 SOURCE
 971 | 
 972 |     use Chart::Gnuplot;
 973 | 
 974 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("sinx.png"));
 975 |     $gnu.title(:text("sin(x) curve"));
 976 |     $gnu.plot(:function('sin(x)'));
 977 |     $gnu.dispose;
 978 | 
 979 | =head3 OUTPUT
 980 | 
 981 | =begin para
 982 | 
 983 |     <img src="sinx.png" alt="sin(x)">
 984 | 
 985 | =end para
 986 | 
 987 | =head2 Recall-Precision Curve
 988 | 
 989 | =head3 SOURCE
 990 | 
 991 |     use v6;
 992 |     use Chart::Gnuplot;
 993 | 
 994 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("recprec.png"));
 995 |     $gnu.title(:text("Recall-Precision Curve"));
 996 |     $gnu.ylabel(:label("Precision"));
 997 |     $gnu.xlabel(:label("Recall"));
 998 |     $gnu.xrange(:min(0.0), :max(1.0));
 999 |     $gnu.yrange(:min(0.0), :max(1.0));
1000 | 
1001 |     my @methodA = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
1002 |     0.0 1.0
1003 |     0.1 0.95
1004 |     0.2 0.9
1005 |     0.3 0.85
1006 |     0.4 0.82
1007 |     0.5 0.6
1008 |     0.6 0.55
1009 |     0.7 0.51
1010 |     0.8 0.4
1011 |     0.9 0.38
1012 |     1.0 0.35
1013 |     EOF
1014 | 
1015 |     my @methodB = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
1016 |     0.0 1.0
1017 |     0.1 0.95
1018 |     0.2 0.8
1019 |     0.3 0.5
1020 |     0.4 0.4
1021 |     0.5 0.3
1022 |     0.6 0.2
1023 |     0.7 0.1
1024 |     0.8 0.08
1025 |     0.9 0.05
1026 |     1.0 0.05
1027 |     EOF
1028 | 
1029 |     my %methodA = %(:vertices(@methodA), :style("linespoints"), :title("proposed"), :lc(qw/rgb "green"/), :pt(10));
1030 |     my %methodB = %(:vertices(@methodB), :style("linespoints"), :title("baseline"), :lc(qw/rgb "red"/), :pt(13));
1031 | 
1032 |     $gnu.plot(|%methodA);
1033 |     $gnu.plot(|%methodB);
1034 |     $gnu.dispose;
1035 | 
1036 | =head3 OUTPUT
1037 | 
1038 | =begin para
1039 | 
1040 |     <img src="recprec.png" alt="recall precision curve">
1041 | 
1042 | =end para
1043 | 
1044 | =head1 How to use Chart::Gnuplot on jupyter?
1045 | 
1046 | One way to do this is:
1047 | 
1048 | =item 1. Write a svg image as a tmp file.
1049 | =item 2. Read this tmp file and remove the first superfluous line.
1050 | 
1051 | If you haven't setup Raku kernel yet, use L<Jupyter::Kernel|https://github.com/bduggan/raku-jupyter-kernel>.
1052 | 
1053 | =head3 SOURCE
1054 | 
1055 |     use Chart::Gnuplot;
1056 |     use Chart::Gnuplot::Subset;
1057 |     use File::Temp;
1058 | 
1059 |     my ($filename, $filehandle);
1060 | 
1061 |     # NOTE: Shouldn't remove both ENTER and LEAVE blocks. File::Temp's auto-unlink doesn't seem to work on jupyter.
1062 |     ENTER {
1063 |       ($filename, $filehandle) = tempfile(:tempdir("/tmp"), :suffix(".svg"));
1064 |     }
1065 | 
1066 |     LEAVE {
1067 |       $filehandle.close;
1068 |       $filename.IO.unlink;
1069 |     }
1070 | 
1071 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename($filename));
1072 | 
1073 |     my @data = (q:to/EOF/).split("\n", :skip-empty)>>.split(" ", :skip-empty);
1074 |     Year Male Female
1075 |     1950 100 90
1076 |     1960 100 90
1077 |     1970 80 70
1078 |     1980 130 140
1079 |     1990 140 120
1080 |     2000 200 210
1081 |     2010 240 230
1082 |     2020 400 420
1083 |     EOF
1084 | 
1085 |     my ($header, *@body) = @data;
1086 | 
1087 |     $gnu.command("set style histogram clustered");
1088 |     $gnu.legend(:left);
1089 |     my AnyTicsTic @tics = (@body>>.[0]).pairs.map(-> (:key($pos), :value($year)) { %(:label($year), :pos($pos)) });
1090 |     $gnu.xtics(:tics(@tics));
1091 |     $gnu.xlabel(:label($header[0]));
1092 |     $gnu.plot(:vertices(@body), :using([2]), :style("histogram"), :title($header[1]), :fill("solid 1.0"));
1093 |     $gnu.plot(:vertices(@body), :using([3]), :style("histogram"), :title($header[2]), :fill("solid 1.0"));
1094 |     $gnu.dispose;
1095 | 
1096 |     $filehandle.lines[1..*].join("\n");
1097 | 
1098 | The example ipynb file is here: L</notebooks/synopsis.ipynb|/notebooks/synopsis.ipynb>.
1099 | 
1100 | =head1 AUTHOR
1101 | 
1102 | titsuki <titsuki@cpan.org>
1103 | 
1104 | =head1 COPYRIGHT AND LICENSE
1105 | 
1106 | Copyright 2017 titsuki
1107 | 
1108 | This library is free software; you can redistribute it and/or modify it under the GNU General Public License version 3.0.
1109 | 
1110 | =end pod
1111 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Arrow.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Arrow:ver<0.0.21>;
 3 | 
 4 | use Chart::Gnuplot::Util;
 5 | use Chart::Gnuplot::Subset;
 6 | 
 7 | has &!writer;
 8 | 
 9 | submethod BUILD(:&!writer) { }
10 | 
11 | method writer(&writer) {
12 |     &!writer = &writer;
13 |     self
14 | }
15 | 
16 | multi method arrow(
17 |     :$tag, :$from, :$to, Bool :$head, TrueOnly :$backhead, TrueOnly :$heads,
18 |     :$head-length, :$head-angle, :$back-angle,
19 |     Bool :$filled, TrueOnly :$empty, TrueOnly :$border,
20 |     TrueOnly :$front, TrueOnly :$back,
21 |     :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor), :dt(:$dashtype), :&writer? = &!writer
22 | ) {
23 |     my @args;
24 | 
25 |     @args.push($tag) if $tag.defined;
26 |     @args.push(tweak-coordinate(:name("from"), :coordinate($from)));
27 |     @args.push(tweak-coordinate(:name("to"), :coordinate($to)));
28 |     @args.push($head ?? "head" !! "nohead") if $head.defined;
29 |     @args.push("backhead") if $backhead.defined;
30 |     @args.push("heads") if $heads.defined;
31 |     if $head-length.defined and $head-angle.defined {
32 |         if $back-angle.defined {
33 |             @args.push(sprintf("size %s", ($head-length, $head-angle, $back-angle).join(",")));
34 |         } else {
35 |             @args.push(sprintf("size %s", ($head-length, $head-angle).join(",")));
36 |         }
37 |     }
38 | 
39 |     @args.push($filled ?? "filled" !! "nofilled") if $filled.defined;
40 |     @args.push("empty") if $empty.defined;
41 |     @args.push("border") if $border.defined;
42 |     @args.push("front") if $front.defined;
43 |     @args.push("back") if $back.defined;
44 |     @args.push("linestyle " ~ $linestyle) if $linestyle.defined;
45 |     @args.push("linetype " ~ $linetype) if $linetype.defined;
46 |     @args.push("linewidth " ~ $linewidth) if $linewidth.defined;
47 |     @args.push("linecolor " ~ $linecolor) if $linecolor.defined;
48 |     @args.push("dashtype " ~ $dashtype) if $dashtype.defined;
49 | 
50 |     &writer(sprintf("set arrow %s", @args.grep(* ne "").join(" ")));
51 | }
52 | 
53 | multi method arrow(
54 |     :$tag, :$from, :$rto, Bool :$head, TrueOnly :$backhead, TrueOnly :$heads,
55 |     :$head-length, :$head-angle, :$back-angle,
56 |     Bool :$filled, TrueOnly :$empty, TrueOnly :$border,
57 |     TrueOnly :$front, TrueOnly :$back,
58 |     :ls(:$linestyle), :lt(:$linetype), :lw(:$linewidth), :lc(:$linecolor), :dt(:$dashtype), :&writer? = &!writer
59 | ) {
60 |     my @args;
61 | 
62 |     @args.push($tag) if $tag.defined;
63 |     @args.push(tweak-coordinate(:name("from"), :coordinate($from)));
64 |     @args.push(tweak-coordinate(:name("rto"), :coordinate($rto)));
65 |     @args.push($head ?? "head" !! "nohead") if $head.defined;
66 |     @args.push("backhead") if $backhead.defined;
67 |     @args.push("heads") if $heads.defined;
68 |     if $head-length.defined and $head-angle.defined {
69 |         if $back-angle.defined {
70 |             @args.push(sprintf("size %s", ($head-length, $head-angle, $back-angle).join(",")));
71 |         } else {
72 |             @args.push(sprintf("size %s", ($head-length, $head-angle).join(",")));
73 |         }
74 |     }
75 | 
76 |     @args.push($filled ?? "filled" !! "nofilled") if $filled.defined;
77 |     @args.push("empty") if $empty.defined;
78 |     @args.push("border") if $border.defined;
79 |     @args.push("front") if $front.defined;
80 |     @args.push("back") if $back.defined;
81 |     @args.push("linestyle " ~ $linestyle) if $linestyle.defined;
82 |     @args.push("linetype " ~ $linetype) if $linetype.defined;
83 |     @args.push("linewidth " ~ $linewidth) if $linewidth.defined;
84 |     @args.push("linecolor " ~ $linecolor) if $linecolor.defined;
85 |     @args.push("dashtype " ~ $dashtype) if $dashtype.defined;
86 | 
87 |     &writer(sprintf("set arrow %s", @args.grep(* ne "").join(" ")));
88 | }
89 | 
90 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Border.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Border:ver<0.0.21>;
 3 | 
 4 | use Chart::Gnuplot::Subset;
 5 | 
 6 | has &!writer;
 7 | 
 8 | submethod BUILD(:&!writer) { }
 9 | 
10 | method writer(&writer) {
11 |     &!writer = &writer;
12 |     self
13 | }
14 | 
15 | method border(:$integer, TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind,
16 |               :lw(:$linewidth), :ls(:$linestyle), :lt(:$linetype), :&writer? = &!writer) {
17 |     my @args;
18 |     @args.push($integer) if $integer.defined;
19 |     @args.push("front") if $front.defined;
20 |     @args.push("back") if $back.defined;
21 |     @args.push("behind") if $behind.defined;
22 |     @args.push("linewidth " ~ $linewidth) if $linewidth.defined;
23 |     @args.push("linestyle " ~ $linestyle) if $linestyle.defined;
24 |     @args.push("linetype " ~ $linetype) if $linetype.defined;
25 | 
26 |     &writer(sprintf("set border %s", @args.grep(* ne "").join(" ")));
27 | }
28 | 
29 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/CustomBuilder.pm6:
--------------------------------------------------------------------------------
 1 | # The portions of the code are licensed under the Artistic License 2.0:
 2 | # zef ( https://github.com/ugexe/zef ) by ugexe
 3 | 
 4 | # Relicensed under the GPL:
 5 | # p6-ChartGnuplot by titsuki
 6 | 
 7 | use Zef;
 8 | use Zef::Fetch;
 9 | use Zef::Extract;
10 | use Distribution::Builder::MakeFromJSON;
11 | 
12 | class Chart::Gnuplot::CustomBuilder:ver<0.0.21> is Distribution::Builder::MakeFromJSON {
13 |     method build(IO() $work-dir = $*CWD) {
14 |         my $workdir = ~$work-dir;
15 |         if $*DISTRO.is-win {
16 |             die "Sorry, this binding doesn't support windows";
17 |         }
18 |         my $HOME = qq:x/echo \$HOME/.subst(/\s*/,"",:g);
19 |         my $prefix = "$HOME/.p6chart-gnuplot";
20 |         self!install-gnuplot($workdir, $prefix);
21 |     }
22 | 
23 |     method !install-gnuplot($workdir, $prefix) {
24 |         my $goback = $*CWD;
25 |         chdir($workdir);
26 | 
27 |         my @fetch-backends = [
28 |             { module => "Zef::Service::Shell::wget" },
29 |             { module => "Zef::Service::Shell::curl" },
30 |         ];
31 |         my $fetcher      = Zef::Fetch.new(:backends(@fetch-backends));
32 |         my $uri          = 'http://mirrors.ctan.org/graphics/gnuplot/5.2.6/gnuplot-5.2.6.tar.gz';
33 |         my $archive-file = "gnuplot-5.2.6.tar.gz".IO.e
34 |         ?? "gnuplot-5.2.6.tar.gz"
35 |         !! $fetcher.fetch(Candidate.new(:$uri), "gnuplot-5.2.6.tar.gz");
36 | 
37 |         my @extract-backends = [
38 |             { module => "Zef::Service::Shell::tar" },
39 |             { module => "Zef::Service::Shell::p5tar" },
40 |         ];
41 |         my $extractor = Zef::Extract.new(:backends(@extract-backends));
42 |         my $extract-dir = $extractor.extract(Candidate.new(:uri($archive-file)), $*CWD);
43 |         chdir("gnuplot-5.2.6");
44 |         shell("./configure --prefix=$prefix --with-latex --with-texdir={$prefix}/share/texmf/tex/latex/gnuplot");
45 |         shell("make");
46 |         shell("make install");
47 |         chdir($goback);
48 |     }
49 | }
50 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Grid.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Grid:ver<0.0.21>;
 3 | 
 4 | use Chart::Gnuplot::Subset;
 5 | 
 6 | has &!writer;
 7 | 
 8 | submethod BUILD(:&!writer) { }
 9 | 
10 | method writer(&writer) {
11 |     &!writer = &writer;
12 |     self
13 | }
14 | 
15 | method grid(Bool :$xtics, TrueOnly :$mxtics, Bool :$ytics, TrueOnly :$mytics, Bool :$ztics, TrueOnly :$mztics,
16 |             Bool :$x2tics, TrueOnly :$mx2tics, Bool :$y2tics, TrueOnly :$my2tics, Bool :$cbtics, TrueOnly :$mcbtics,
17 |             :$polar, TrueOnly :$layerdefault, TrueOnly :$front, TrueOnly :$back,
18 |             :ls(:@linestyle), :lt(:@linetype), :lw(:@linewidth), :&writer? = &!writer) {
19 |     my @args;
20 |     @args.push($xtics ?? "xtics" !! "noxtics") if $xtics.defined;
21 |     @args.push("mxtics") if $mxtics.defined;
22 |     @args.push($ytics ?? "ytics" !! "noytics") if $ytics.defined;
23 |     @args.push("mytics") if $mytics.defined;
24 |     @args.push($ztics ?? "ztics" !! "noztics") if $ztics.defined;
25 |     @args.push("mztics") if $mztics.defined;
26 | 
27 |     @args.push($x2tics ?? "x2tics" !! "nox2tics") if $x2tics.defined;
28 |     @args.push("mx2tics") if $mx2tics.defined;
29 |     @args.push($y2tics ?? "y2tics" !! "noy2tics") if $y2tics.defined;
30 |     @args.push("my2tics") if $my2tics.defined;
31 |     @args.push($cbtics ?? "cbtics" !! "nocbtics") if $cbtics.defined;
32 |     @args.push("mcbtics") if $mcbtics.defined;
33 | 
34 |     @args.push("polar " ~ $polar) if $polar.defined;
35 |     @args.push("layerdefault") if $layerdefault.defined;
36 |     @args.push("front") if $front.defined;
37 |     @args.push("back") if $back.defined;
38 | 
39 |     @args.push("linestyle " ~ @linestyle[0]) if @linestyle.elems >= 1;
40 |     @args.push("linetype " ~ @linetype[0]) if @linetype.elems >= 1;
41 |     @args.push("linewidth " ~ @linewidth[0]) if @linewidth.elems >= 1;
42 | 
43 |     @args.push(",") if @linestyle.elems|@linetype.elems|@linewidth.elems == 2;
44 |     @args.push("linestyle " ~ @linestyle[1]) if @linestyle.elems == 2;
45 |     @args.push("linetype " ~ @linetype[1]) if @linetype.elems == 2;
46 |     @args.push("linewidth " ~ @linewidth[1]) if @linewidth.elems == 2;
47 | 
48 |     &writer(sprintf("set grid %s", @args.grep(* ne "").join(" ")));
49 | }
50 | 
51 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Label.pm6:
--------------------------------------------------------------------------------
  1 | use v6;
  2 | unit class Chart::Gnuplot::Label:ver<0.0.21>;
  3 | 
  4 | use Chart::Gnuplot::Util;
  5 | use Chart::Gnuplot::Subset;
  6 | 
  7 | has &!writer;
  8 | 
  9 | submethod BUILD(:&!writer) { }
 10 | 
 11 | method writer(&writer) {
 12 |     &!writer = &writer;
 13 |     self
 14 | }
 15 | 
 16 | method label(:$tag, Str :$label-text, :$at, TrueOnly :$left, TrueOnly :$center, TrueOnly :$right,
 17 |              LabelRotate :$rotate, :$font-name, :$font-size, FalseOnly :$enhanced,
 18 |              TrueOnly :$front, TrueOnly :$back, :$textcolor, FalseOnly :$point, :$line-type, :$point-type, :$point-size, :$offset,
 19 |              TrueOnly :$boxed, TrueOnly :$hypertext, :&writer? = -> $msg { self.command: $msg }) {
 20 |     my @args;
 21 |     @args.push($tag) if $tag.defined;
 22 |     @args.push(sprintf("\"%s\"", $label-text)) if $label-text.defined;
 23 | 
 24 |     @args.push(tweak-coordinate(:name("at"), :coordinate($at)));
 25 |     @args.push("left") if $left.defined;
 26 |     @args.push("center") if $center.defined;
 27 |     @args.push("right") if $right.defined;
 28 | 
 29 |     if $rotate.defined {
 30 |         given $rotate {
 31 |             when $_ === False { @args.push("norotate") }
 32 |             when * ~~ Real { @args.push("rotate by $rotate") }
 33 |             default { die "Error: Something went wrong." }
 34 |         }
 35 |     }
 36 | 
 37 |     @args.push(tweak-fontargs(:$font-name, :$font-size));
 38 |     @args.push("noenhanced") if $enhanced.defined and $enhanced === False;
 39 |     @args.push("front") if $front.defined;
 40 |     @args.push("back") if $back.defined;
 41 |     @args.push("textcolor " ~ $textcolor) if $textcolor.defined;
 42 |     @args.push("nopoint") if $point.defined and $point === False;
 43 | 
 44 |     my @point-args;
 45 |     @point-args.push("lt " ~ $line-type) if $line-type.defined;
 46 |     @point-args.push("pt " ~ $point-type) if $point-type.defined;
 47 |     @point-args.push("ps " ~ $point-size) if $point-size.defined;
 48 | 
 49 |     @args.push("point " ~ @point-args.join(" ")) if @point-args.elems > 0;
 50 | 
 51 |     @args.push(tweak-coordinate(:name("offset"), :coordinate($offset)));
 52 |     @args.push("boxed") if $boxed.defined;
 53 |     @args.push("hypertext") if $hypertext.defined;
 54 | 
 55 |     &writer(sprintf("set label %s", @args.grep(* ne "").join(" ")));
 56 | }
 57 | 
 58 | method !anylabel(Str :$label, :$offset, :$font-name, :$font-size, :$textcolor, Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = -> $msg { self.command: $msg }) {
 59 |     my @args;
 60 |     @args.push(sprintf("\"%s\"", $label)) if $label.defined;
 61 |     @args.push(tweak-coordinate(:name("offset"), :coordinate($offset)));
 62 |     @args.push(tweak-fontargs(:$font-name, :$font-size));
 63 |     @args.push("textcolor " ~ $textcolor) if $textcolor.defined;
 64 |     @args.push($enhanced ?? "enhanced" !! "noenhanced") if $enhanced.defined;
 65 |     
 66 |     if $rotate.defined {
 67 |         given $rotate {
 68 |             when $_ === False { @args.push("norotate") }
 69 |             when * ~~ Real { @args.push("rotate by $rotate") }
 70 |             when * eq "parallel" { @args.push("rotate parallel") }
 71 |             default { die "Error: Something went wrong." }
 72 |         }
 73 |     }
 74 |     @args.grep(* ne "").join(" ");
 75 | }
 76 | 
 77 | method xlabel(Str :$label, :$offset, :$font-name, :$font-size, :$textcolor, Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = &!writer) {
 78 |     &writer(sprintf("set xlabel %s", self!anylabel(:$label, :$offset, :$font-name, :$font-size, :$textcolor, :$enhanced, :$rotate)));
 79 | }
 80 | 
 81 | method ylabel(Str :$label, :$offset, :$font-name, :$font-size, :$textcolor, Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = &!writer) {
 82 |     &writer(sprintf("set ylabel %s", self!anylabel(:$label, :$offset, :$font-name, :$font-size, :$textcolor, :$enhanced, :$rotate)));
 83 | }
 84 | 
 85 | method zlabel(Str :$label, :$offset, :$font-name, :$font-size, :$textcolor, Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = &!writer) {
 86 |     &writer(sprintf("set zlabel %s", self!anylabel(:$label, :$offset, :$font-name, :$font-size, :$textcolor, :$enhanced, :$rotate)));
 87 | }
 88 | 
 89 | method x2label(Str :$label, :$offset, :$font-name, :$font-size, :$textcolor, Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = &!writer) {
 90 |     &writer(sprintf("set x2label %s", self!anylabel(:$label, :$offset, :$font-name, :$font-size, :$textcolor, :$enhanced, :$rotate)));
 91 | }
 92 | 
 93 | method y2label(Str :$label, :$offset, :$font-name, :$font-size, :$textcolor, Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = &!writer) {
 94 |     &writer(sprintf("set y2label %s", self!anylabel(:$label, :$offset, :$font-name, :$font-size, :$textcolor, :$enhanced, :$rotate)));
 95 | }
 96 | 
 97 | method cblabel(Str :$label, :$offset, :$font-name, :$font-size, :$textcolor, Bool :$enhanced, AnyLabelRotate :$rotate, :&writer? = &!writer) {
 98 |     &writer(sprintf("set cblabel %s", self!anylabel(:$label, :$offset, :$font-name, :$font-size, :$textcolor, :$enhanced, :$rotate)));
 99 | }
100 | 
101 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Legend.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Legend:ver<0.0.21>;
 3 | 
 4 | use Chart::Gnuplot::Util;
 5 | use Chart::Gnuplot::Subset;
 6 | 
 7 | has &!writer;
 8 | 
 9 | submethod BUILD(:&!writer) { }
10 | 
11 | method writer(&writer) {
12 |     &!writer = &writer;
13 |     self
14 | }
15 | 
16 | method legend(TrueOnly :$on, TrueOnly :$off, TrueOnly :$default, TrueOnly :$inside, TrueOnly :$outside, TrueOnly :$lmargin, TrueOnly :$rmargin, TrueOnly :$tmargin, TrueOnly :$bmargin,
17 |               :$at,
18 |               TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$top, TrueOnly :$bottom,
19 |               TrueOnly :$vertical, TrueOnly :$horizontal, TrueOnly :$Left, TrueOnly :$Right,
20 |               Bool :$opaque, Bool :$reverse, Bool :$invert,
21 |               :$samplen, :$spacing, :$width, :$height,
22 |               TrueOnly :$autotitle, TrueOnly :$columnheader, :$title, :$font-name, :$font-size, :$textcolor,
23 |               Bool :$box, :$linestyle, :$linetype, :$linewidth,
24 |               LegendMax :$maxcols, LegendMax :$maxrows, :&writer? = &!writer) {
25 |     my @args;
26 |     @args.push("on") if $on.defined;
27 |     @args.push("off") if $off.defined;
28 |     @args.push("default") if $default.defined;
29 |     @args.push("inside") if $inside.defined;
30 |     @args.push("outside") if $outside.defined;
31 |     @args.push("lmargin") if $lmargin.defined;
32 |     @args.push("rmargin") if $rmargin.defined;
33 |     @args.push("tmargin") if $tmargin.defined;
34 |     @args.push("bmargin") if $bmargin.defined;
35 |     @args.push(tweak-coordinate(:name("at"), :coordinate($at)));
36 |     @args.push("left") if $left.defined;
37 |     @args.push("right") if $right.defined;
38 |     @args.push("top") if $top.defined;
39 |     @args.push("bottom") if $bottom.defined;
40 |     @args.push("center") if $center.defined;
41 |     @args.push("vertical") if $vertical.defined;
42 |     @args.push("horizontal") if $horizontal.defined;
43 |     @args.push("Left") if $Left.defined;
44 |     @args.push("Right") if $Right.defined;
45 |     @args.push($opaque ?? "opaque" !! "noopaque") if $opaque.defined;
46 |     @args.push($reverse ?? "reverse" !! "noreverse") if $reverse.defined;
47 |     @args.push($invert ?? "invert" !! "noinvert") if $invert.defined;
48 |     @args.push("samplen " ~ $samplen) if $samplen.defined;
49 |     @args.push("spacing " ~ $spacing) if $spacing.defined;
50 |     @args.push("width " ~ $width) if $width.defined;
51 |     @args.push("height " ~ $height) if $height.defined;
52 |     @args.push("autotitle") if $autotitle.defined;
53 |     @args.push("columnheader") if $autotitle.defined and $columnheader.defined;
54 |     @args.push(sprintf("title \"%s\"", $title)) if $title.defined;
55 |     
56 |     @args.push(tweak-fontargs(:$font-name, :$font-size));
57 |     @args.push("textcolor " ~ $textcolor) if $textcolor.defined;
58 |     @args.push($box ?? "box" !! "nobox") if $box.defined;
59 |     @args.push("linestyle " ~ $linestyle) if $box.defined and $linestyle.defined;
60 |     @args.push("linetype " ~ $linetype) if $box.defined and $linetype.defined;
61 |     @args.push("linewidth " ~ $linewidth) if $box.defined and $linewidth.defined;
62 |     if $maxcols.defined {
63 |         @args.push("maxcols " ~ $maxcols) if $maxcols ~~ Real;
64 |         @args.push("maxcols auto") if $maxcols eq "auto";
65 |     }
66 | 
67 |     if $maxrows.defined {
68 |         @args.push("maxrows " ~ $maxrows) if $maxrows ~~ Real;
69 |         @args.push("maxrows auto") if $maxrows eq "auto";
70 |     }
71 | 
72 |     &writer(sprintf("set key %s", @args.grep(* ne "").join(" ")));
73 | }
74 | 
75 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Object.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Object:ver<0.0.21>;
 3 | 
 4 | use Chart::Gnuplot::Util;
 5 | use Chart::Gnuplot::Subset;
 6 | 
 7 | has &!writer;
 8 | 
 9 | submethod BUILD(:&!writer) { }
10 | 
11 | method writer(&writer) {
12 |     &!writer = &writer;
13 |     self
14 | }
15 | 
16 | method !anyobject(TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
17 |                   TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = &!writer) {
18 | 
19 |     my @args;
20 |     @args.push("front") if $front.defined;
21 |     @args.push("back") if $back.defined;
22 |     @args.push("behind") if $behind.defined;
23 |     @args.push($clip ?? "clip" !! "noclip") if $clip.defined;
24 |     @args.push("fillcolor " ~ $fillcolor) if $fillcolor.defined;
25 |     @args.push("fillstyle " ~ $fillstyle) if $fillstyle.defined;
26 |     @args.push("default") if $default.defined;
27 |     @args.push("linewidth " ~ $linewidth) if $linewidth.defined;
28 |     @args.push("dashtype " ~ $dashtype) if $dashtype.defined;
29 |     @args.grep(* ne "").join(" ");
30 | }
31 | 
32 | multi method rectangle(:$index!, :$from, :$to,
33 |                        TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
34 |                        TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = &!writer) {
35 | 
36 |     my @args;
37 |     @args.push(tweak-coordinate(:name("from"), :coordinate($from)));
38 |     @args.push(tweak-coordinate(:name("to"), :coordinate($to)));
39 |     @args.push(self!anyobject(:$front, :$back, :$behind, :$clip, :$fillcolor, :$fillstyle,
40 |                               :$default, :$linewidth, :$dashtype));
41 |     &writer(sprintf("set object %d rectangle %s", $index, @args.grep(* ne "").join(" ")))
42 | }
43 | 
44 | multi method rectangle(:$index, :$from, :$rto,
45 |                        TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
46 |                        TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = &!writer) {
47 | 
48 |     my @args;
49 |     @args.push(tweak-coordinate(:name("from"), :coordinate($from)));
50 |     @args.push(tweak-coordinate(:name("rto"), :coordinate($rto)));
51 |     @args.push(self!anyobject(:$front, :$back, :$behind, :$clip, :$fillcolor, :$fillstyle,
52 |                               :$default, :$linewidth, :$dashtype));
53 |     &writer(sprintf("set object %d rectangle %s", $index, @args.grep(* ne "").join(" ")));
54 | }
55 | 
56 | method ellipse(:$index, :center(:$at), :$w!, :$h!,
57 |                TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
58 |                TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = &!writer) {
59 |     my @args;
60 |     @args.push(tweak-coordinate(:name("at"), :coordinate($at)));
61 |     @args.push(sprintf("size %s,%s", $w, $h));
62 |     @args.push(self!anyobject(:$front, :$back, :$behind, :$clip, :$fillcolor, :$fillstyle,
63 |                               :$default, :$linewidth, :$dashtype));
64 |     &writer(sprintf("set object %d ellipse %s", $index, @args.grep(* ne "").join(" ")));
65 | }
66 | 
67 | method circle(:$index, :center(:$at), :$radius!,
68 |               TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
69 |               TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = &!writer) {
70 |     my @args;
71 |     @args.push(tweak-coordinate(:name("at"), :coordinate($at)));
72 |     @args.push(sprintf("size %s", $radius));
73 |     @args.push(self!anyobject(:$front, :$back, :$behind, :$clip, :$fillcolor, :$fillstyle,
74 |                               :$default, :$linewidth, :$dashtype));
75 |     
76 |     &writer(sprintf("set object %d circle %s", $index, @args.grep(* ne "").join(" ")));
77 | }
78 | 
79 | method polygon(:$index, :$from, :@to,
80 |                TrueOnly :$front, TrueOnly :$back, TrueOnly :$behind, Bool :$clip, :$fillcolor, :$fillstyle,
81 |                TrueOnly :$default, :$linewidth, :$dashtype, :&writer? = &!writer) {
82 |     my @args;
83 |     @args.push(tweak-coordinate(:name("from"), :coordinate($from)));
84 |     @args.push(@to.map(-> $c { tweak-coordinate(:coordinate($c), :name("to")) }).join(" "));
85 |     @args.push(self!anyobject(:$front, :$back, :$behind, :$clip, :$fillcolor, :$fillstyle,
86 |                               :$default, :$linewidth, :$dashtype));
87 |     &writer(sprintf("set object %d polygon %s", $index, @args.grep(* ne "").join(" ")));
88 | }
89 | 
90 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Output.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Output:ver<0.0.21>;
 3 | 
 4 | has Str $!filename;
 5 | has &!writer;
 6 | 
 7 | submethod BUILD(Str :$!filename, :&!writer) { }
 8 | 
 9 | method writer(&writer) {
10 |     &!writer = &writer;
11 |     self
12 | }
13 | 
14 | method filename($filename) {
15 |     $!filename = $filename;
16 |     self
17 | }
18 | 
19 | method set {
20 |     &!writer(sprintf("set output \"%s\"", $!filename));
21 | }
22 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Range.pm6:
--------------------------------------------------------------------------------
  1 | use v6;
  2 | unit class Chart::Gnuplot::Range:ver<0.0.21>;
  3 | 
  4 | use Chart::Gnuplot::Subset;
  5 | 
  6 | has &!writer;
  7 | 
  8 | submethod BUILD(:&!writer) { }
  9 | 
 10 | method writer(&writer) {
 11 |     &!writer = &writer;
 12 |     self
 13 | }
 14 | 
 15 | method !anyrange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend) {
 16 |     my @args;
 17 |     @args.push(sprintf("[%s:%s]", $min, $max));
 18 |     @args.push($reverse ?? "reverse" !! "noreverse") if $reverse.defined;
 19 |     @args.push($writeback ?? "writeback" !! "nowriteback") if $writeback.defined;
 20 |     @args.push($extend ?? "extend" !! "noextend") if $extend.defined;
 21 |     @args.grep(* ne "").join(" ");
 22 | }
 23 | 
 24 | multi method xrange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 25 |    &writer(sprintf("set xrange %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 26 | }
 27 | 
 28 | multi method xrange(TrueOnly :$restore, :&writer? = &!writer) {
 29 |     &writer("set xrange restore");
 30 | }
 31 | 
 32 | multi method yrange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 33 |    &writer(sprintf("set yrange %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 34 | }
 35 | 
 36 | multi method yrange(TrueOnly :$restore, :&writer? = &!writer) {
 37 |     &writer("set yrange restore");
 38 | }
 39 | 
 40 | multi method zrange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 41 |    &writer(sprintf("set zrange %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 42 | }
 43 | 
 44 | multi method zrange(TrueOnly :$restore, :&writer? = &!writer) {
 45 |     &writer("set zrange restore");
 46 | }
 47 | 
 48 | multi method x2range(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 49 |    &writer(sprintf("set x2range %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 50 | }
 51 | 
 52 | multi method x2range(TrueOnly :$restore, :&writer? = &!writer) {
 53 |     &writer("set x2range restore");
 54 | }
 55 | 
 56 | multi method y2range(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 57 |    &writer(sprintf("set y2range %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 58 | }
 59 | 
 60 | multi method y2range(TrueOnly :$restore, :&writer? = &!writer) {
 61 |     &writer("set y2range restore");
 62 | }
 63 | 
 64 | multi method cbrange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 65 |     &writer(sprintf("set cbrange %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 66 | }
 67 | 
 68 | multi method cbrange(TrueOnly :$restore, :&writer? = &!writer) {
 69 |     &writer("set cbrange restore");
 70 | }
 71 | 
 72 | multi method rrange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 73 |     &writer(sprintf("set rrange %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 74 | }
 75 | 
 76 | multi method rrange(TrueOnly :$restore, :&writer? = &!writer) {
 77 |     &writer("set rrange restore");
 78 | }
 79 | 
 80 | multi method trange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 81 |     &writer(sprintf("set trange %s", self!anyrange(:$min, :$max, :$reverse, :$writeback,  :$extend)));
 82 | }
 83 | 
 84 | multi method trange(TrueOnly :$restore, :&writer? = &!writer) {
 85 |     &writer("set trange restore");
 86 | }
 87 | 
 88 | multi method urange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 89 |     &writer(sprintf("set urange %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 90 | }
 91 | 
 92 | multi method urange(TrueOnly :$restore, :&writer? = &!writer) {
 93 |     &writer("set urange restore");
 94 | }
 95 | 
 96 | multi method vrange(:$min, :$max, Bool :$reverse, Bool :$writeback, Bool :$extend, :&writer? = &!writer) {
 97 |     &writer(sprintf("set vrange %s", self!anyrange(:$min, :$max, :$reverse, :$writeback, :$extend)));
 98 | }
 99 | 
100 | multi method vrange(TrueOnly :$restore, :&writer? = &!writer) {
101 |     &writer("set vrange restore");
102 | }
103 | 
104 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Subset.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit module Chart::Gnuplot::Subset:ver<0.0.21>;
 3 | 
 4 | subset FalseOnly of Bool is export where { $_ ~~ Bool:U or $_ === False };
 5 | subset TrueOnly of Bool is export where { $_ ~~ Bool:U or $_ === True};
 6 | subset LabelRotate of Cool is export where { $_ ~~ Cool:U or $_ ~~ Real or $_ === False };
 7 | subset AnyLabelRotate of Cool is export where { $_ ~~ Cool:U or $_ eq "parallel" or $_ ~~ Real or $_ === False };
 8 | subset LegendMax of Cool is export where { $_ ~~ Cool:U or $_ eq "auto" or $_ ~~ Real };
 9 | subset AnyTicsRotate of Cool is export where { $_ ~~ Cool:U or $_ ~~ Real or $_ === False };
10 | subset AnyTicsOffset of Mu is export where { $_ ~~ Mu:U or $_ ~~ FalseOnly or ($_ ~~ List and $_.all ~~ Pair|Real) };
11 | subset AnyTicsTic of Mu is export where { $_ ~~ Mu:U or $_ ~~ Hash and .<label>:exists and .<pos>:exists and .keys.grep(* eq "label"|"pos"|"level").elems == .keys.elems };
12 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Terminal.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Terminal:ver<0.0.21>;
 3 | 
 4 | has Str $!type;
 5 | has &!writer;
 6 | 
 7 | submethod BUILD(Str:D :$!type, :&!writer) { }
 8 | 
 9 | method writer(&writer) {
10 |     &!writer = &writer;
11 |     self
12 | }
13 | 
14 | method type($type) {
15 |     $!type = $type;
16 |     self
17 | }
18 | 
19 | method set {
20 |     &!writer(sprintf("set terminal %s", $!type));
21 | }
22 | 
23 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Tics.pm6:
--------------------------------------------------------------------------------
  1 | use v6;
  2 | unit class Chart::Gnuplot::Tics:ver<0.0.21>;
  3 | 
  4 | use Chart::Gnuplot::Util;
  5 | use Chart::Gnuplot::Subset;
  6 | 
  7 | has &!writer;
  8 | 
  9 | submethod BUILD(:&!writer) { }
 10 | 
 11 | method writer(&writer) {
 12 |     &!writer = &writer;
 13 |     self
 14 | }
 15 | 
 16 | method !anytics(TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
 17 |                 TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
 18 |                 TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
 19 |                 TrueOnly :$add,
 20 |                 TrueOnly :$autofreq,
 21 |                :$incr,
 22 |                :$start, :$end,
 23 |                :@tics where Array[AnyTicsTic] | Array[],
 24 |                :$format, :$font-name, :$font-size, Bool :$enhanced,
 25 |                TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
 26 |                TrueOnly :$rangelimited,
 27 |                :$textcolor
 28 |                ) {
 29 |     my @args;
 30 |     @args.push("axis") if $axis.defined;
 31 |     @args.push("border") if $border.defined;
 32 |     @args.push($mirror ?? "mirror" !! "nomirror") if $mirror.defined;
 33 |     @args.push("in") if $in.defined;
 34 |     @args.push("out") if $out.defined;
 35 |     
 36 |     @args.push("scale default") if $scale-default.defined;
 37 | 
 38 |     my @scale-args;
 39 |     @scale-args.push($scale-major) if $scale-major.defined;
 40 |     @scale-args.push($scale-minor) if $scale-major.defined and $scale-minor.defined;
 41 |     
 42 |     if @scale-args.elems > 0 {
 43 |         @args.push(sprintf("scale %s", @scale-args.join(",")));
 44 |     }
 45 |     
 46 |     if $rotate.defined {
 47 |         given $rotate {
 48 |             when $_ === False { @args.push("norotate") }
 49 |             when * ~~ Real { @args.push("rotate by $rotate") }
 50 |             default { die "Error: Something went wrong." }
 51 |         }
 52 |     }
 53 | 
 54 |     @args.push(tweak-coordinate(:name("offset"), :coordinate($offset), :enable-nooffset));
 55 |     @args.push("left") if $left.defined;
 56 |     @args.push("right") if $right.defined;
 57 |     @args.push("center") if $center.defined;
 58 |     @args.push("autojustify") if $autojustify.defined;
 59 |     @args.push("add") if $add.defined;
 60 |     @args.push("autofreq") if $autofreq.defined;
 61 | 
 62 |     if $incr.defined and (not $start.defined and not $end.defined) {
 63 |         @args.push($incr) if $incr.defined;
 64 |     } else {
 65 |         if $start.defined and $incr.defined and $end.defined {
 66 |             @args.push(sprintf("%s, %s, %s", $start, $incr, $end));
 67 |         } elsif $start.defined and $incr.defined {
 68 |             @args.push(sprintf("%s, %s", $start, $incr));
 69 |         }
 70 |     }
 71 | 
 72 |     if @tics.elems > 0 {
 73 |         my @tic-args;
 74 |         for @tics -> $t {
 75 |             my @tmp;
 76 |             if $t<label>:exists {
 77 |                 @tmp.push(sprintf("\"%s\"", $t<label>));
 78 |             }
 79 | 
 80 |             @tmp.push($t<pos>);
 81 |             if $t<level>:exists {
 82 |                 @tmp.push($t<level>);
 83 |             }
 84 |             @tic-args.push(@tmp.join(" "));
 85 |         }
 86 |         @args.push(sprintf("(%s)", @tic-args.join(",")));
 87 |     }
 88 | 
 89 |     @args.push(sprintf("format \"%s\"", $format)) if $format.defined;
 90 |     @args.push(tweak-fontargs(:$font-name, :$font-size));
 91 | 
 92 |     @args.push($enhanced ?? "enhanced" !! "noenhanced") if $enhanced.defined;
 93 |     @args.push("numeric") if $numeric.defined;
 94 |     @args.push("timedate") if $timedate.defined;
 95 |     @args.push("geographic") if $geographic.defined;
 96 |     @args.push("rangelimited") if $rangelimited.defined;
 97 |     @args.push("textcolor " ~ $textcolor) if $textcolor.defined;
 98 |     @args.grep(* ne "").join(" ")
 99 | }
100 | 
101 | method xtics(TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
102 |              TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
103 |              TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
104 |              TrueOnly :$add,
105 |              TrueOnly :$autofreq,
106 |              :$incr,
107 |              :$start, :$end,
108 |              :@tics where Array[AnyTicsTic] | Array[],
109 |              :$format, :$font-name, :$font-size, Bool :$enhanced,
110 |              TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
111 |              TrueOnly :$rangelimited,
112 |              :$textcolor, :&writer? = &!writer
113 |             ) {
114 |     &writer(sprintf("set xtics %s", self!anytics(:$axis, :$border, :$mirror,
115 |                                                            :$in, :$out, :$scale-default, :$scale-major, :$scale-minor, :$rotate, :$offset,
116 |                                                            :$left, :$right, :$center, :$autojustify,
117 |                                                            :$add,
118 |                                                            :$autofreq,
119 |                                                            :$incr,
120 |                                                            :$start, :$end,
121 |                                                            :@tics,
122 |                                                            :$format, :$font-name, :$font-size, :$enhanced,
123 |                                                            :$numeric, :$timedate, :$geographic,
124 |                                                            :$rangelimited,
125 |                                                            :$textcolor)));
126 | }
127 | 
128 | method ytics(TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
129 |              TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
130 |              TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
131 |              TrueOnly :$add,
132 |              TrueOnly :$autofreq,
133 |              :$incr,
134 |              :$start, :$end,
135 |              :@tics where Array[AnyTicsTic] | Array[],
136 |              :$format, :$font-name, :$font-size, Bool :$enhanced,
137 |              TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
138 |              TrueOnly :$rangelimited,
139 |              :$textcolor, :&writer? = &!writer
140 |             ) {
141 |     &writer(sprintf("set ytics %s", self!anytics(:$axis, :$border, :$mirror,
142 |                                                  :$in, :$out, :$scale-default, :$scale-major, :$scale-minor, :$rotate, :$offset,
143 |                                                  :$left, :$right, :$center, :$autojustify,
144 |                                                  :$add,
145 |                                                  :$autofreq,
146 |                                                  :$incr,
147 |                                                  :$start, :$end,
148 |                                                  :@tics,
149 |                                                  :$format, :$font-name, :$font-size, :$enhanced,
150 |                                                  :$numeric, :$timedate, :$geographic,
151 |                                                  :$rangelimited,
152 |                                                  :$textcolor)));
153 | }
154 | 
155 | method ztics(TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
156 |              TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
157 |              TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
158 |              TrueOnly :$add,
159 |              TrueOnly :$autofreq,
160 |              :$incr,
161 |              :$start, :$end,
162 |              :@tics where Array[AnyTicsTic] | Array[],
163 |              :$format, :$font-name, :$font-size, Bool :$enhanced,
164 |              TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
165 |              TrueOnly :$rangelimited,
166 |              :$textcolor, :&writer? = &!writer
167 |             ) {
168 |     &writer(sprintf("set ztics %s", self!anytics(:$axis, :$border, :$mirror,
169 |                                                  :$in, :$out, :$scale-default, :$scale-major, :$scale-minor, :$rotate, :$offset,
170 |                                                  :$left, :$right, :$center, :$autojustify,
171 |                                                  :$add,
172 |                                                  :$autofreq,
173 |                                                  :$incr,
174 |                                                  :$start, :$end,
175 |                                                  :@tics,
176 |                                                  :$format, :$font-name, :$font-size, :$enhanced,
177 |                                                  :$numeric, :$timedate, :$geographic,
178 |                                                  :$rangelimited,
179 |                                                  :$textcolor)));
180 | }
181 | 
182 | method x2tics(TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
183 |               TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
184 |               TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
185 |               TrueOnly :$add,
186 |               TrueOnly :$autofreq,
187 |               :$incr,
188 |               :$start, :$end,
189 |               :@tics where Array[AnyTicsTic] | Array[],
190 |               :$format, :$font-name, :$font-size, Bool :$enhanced,
191 |               TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
192 |               TrueOnly :$rangelimited,
193 |               :$textcolor, :&writer? = &!writer
194 |              ) {
195 |     &writer(sprintf("set x2tics %s", self!anytics(:$axis, :$border, :$mirror,
196 |                                                   :$in, :$out, :$scale-default, :$scale-major, :$scale-minor, :$rotate, :$offset,
197 |                                                   :$left, :$right, :$center, :$autojustify,
198 |                                                   :$add,
199 |                                                   :$autofreq,
200 |                                                   :$incr,
201 |                                                   :$start, :$end,
202 |                                                   :@tics,
203 |                                                   :$format, :$font-name, :$font-size, :$enhanced,
204 |                                                   :$numeric, :$timedate, :$geographic,
205 |                                                   :$rangelimited,
206 |                                                   :$textcolor)));
207 | }
208 | 
209 | method y2tics(TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
210 |               TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
211 |               TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
212 |               TrueOnly :$add,
213 |               TrueOnly :$autofreq,
214 |               :$incr,
215 |               :$start, :$end,
216 |               :@tics where Array[AnyTicsTic] | Array[],
217 |               :$format, :$font-name, :$font-size, Bool :$enhanced,
218 |               TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
219 |               TrueOnly :$rangelimited,
220 |               :$textcolor, :&writer? = &!writer
221 |              ) {
222 |     &writer(sprintf("set y2tics %s", self!anytics(:$axis, :$border, :$mirror,
223 |                                                   :$in, :$out, :$scale-default, :$scale-major, :$scale-minor, :$rotate, :$offset,
224 |                                                   :$left, :$right, :$center, :$autojustify,
225 |                                                   :$add,
226 |                                                   :$autofreq,
227 |                                                   :$incr,
228 |                                                   :$start, :$end,
229 |                                                   :@tics,
230 |                                                   :$format, :$font-name, :$font-size, :$enhanced,
231 |                                                   :$numeric, :$timedate, :$geographic,
232 |                                                   :$rangelimited,
233 |                                                   :$textcolor)));
234 | }
235 | 
236 | method cbtics(TrueOnly :$axis, TrueOnly :$border, Bool :$mirror,
237 |               TrueOnly :$in, TrueOnly :$out, TrueOnly :$scale-default, :$scale-major, :$scale-minor, AnyTicsRotate :$rotate, AnyTicsOffset :$offset,
238 |               TrueOnly :$left, TrueOnly :$right, TrueOnly :$center, TrueOnly :$autojustify,
239 |               TrueOnly :$add,
240 |               TrueOnly :$autofreq,
241 |               :$incr,
242 |               :$start, :$end,
243 |               :@tics where Array[AnyTicsTic] | Array[],
244 |               :$format, :$font-name, :$font-size, Bool :$enhanced,
245 |               TrueOnly :$numeric, TrueOnly :$timedate, TrueOnly :$geographic,
246 |               TrueOnly :$rangelimited,
247 |               :$textcolor, :&writer? = &!writer
248 |              ) {
249 |     &writer(sprintf("set cbtics %s", self!anytics(:$axis, :$border, :$mirror,
250 |                                                   :$in, :$out, :$scale-default, :$scale-major, :$scale-minor, :$rotate, :$offset,
251 |                                                   :$left, :$right, :$center, :$autojustify,
252 |                                                   :$add,
253 |                                                   :$autofreq,
254 |                                                   :$incr,
255 |                                                   :$start, :$end,
256 |                                                   :@tics,
257 |                                                   :$format, :$font-name, :$font-size, :$enhanced,
258 |                                                   :$numeric, :$timedate, :$geographic,
259 |                                                   :$rangelimited,
260 |                                                   :$textcolor)));
261 | }
262 | 
263 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Timestamp.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Timestamp:ver<0.0.21>;
 3 | 
 4 | use Chart::Gnuplot::Util;
 5 | use Chart::Gnuplot::Subset;
 6 | 
 7 | has &!writer;
 8 | 
 9 | submethod BUILD(:&!writer) { }
10 | 
11 | method writer(&writer) {
12 |     &!writer = &writer;
13 |     self
14 | }
15 | 
16 | method timestamp(Str :$format, TrueOnly :$top, TrueOnly :$bottom, Bool :$rotate,
17 |                  :$offset, :$font-name, :$font-size, :$textcolor, :&writer? = &!writer) {
18 |     my @args;
19 |     @args.push(sprintf("\"%s\"", $format)) if $format.defined;
20 |     @args.push("top") if $top.defined;
21 |     @args.push("bottom") if $bottom.defined;
22 |     @args.push($rotate ?? "rotate" !! "norotate") if $rotate.defined;
23 | 
24 |     @args.push(tweak-coordinate(:name("offset"), :coordinate($offset))) if $offset.defined;
25 |     @args.push(tweak-fontargs(:$font-name, :$font-size));
26 | 
27 |     @args.push("textcolor " ~ $textcolor) if $textcolor.defined;
28 | 
29 |     &writer(sprintf("set timestamp %s", @args.grep(* ne "").join(" ")));
30 | }
31 | 
32 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Title.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Title:ver<0.0.21>;
 3 | 
 4 | use Chart::Gnuplot::Util;
 5 | 
 6 | has &!writer;
 7 | 
 8 | submethod BUILD(:&!writer) { }
 9 | 
10 | method writer(&writer) {
11 |     &!writer = &writer;
12 |     self
13 | }
14 | 
15 | method title(Str :$text, :$offset, :$font-name, :$font-size, :tc(:$textcolor), :$colorspec, Bool :$enhanced, :&writer? = &!writer) {
16 |     my @args;
17 |     
18 |     @args.push(sprintf("\"%s\"", $text));
19 |     @args.push(tweak-coordinate(:name("offset"), :coordinate($offset)));
20 |     @args.push(tweak-fontargs(:$font-name, :$font-size));
21 |     @args.push("textcolor " ~ $textcolor) if $textcolor.defined;
22 |     @args.push("colorspec " ~ $colorspec) if $colorspec.defined;
23 |     @args.push($enhanced ?? "enhanced" !! "noenhanced") if $enhanced.defined;
24 | 
25 |     &writer(sprintf("set title %s", @args.grep(* ne "").join(" ")));
26 | }
27 | 


--------------------------------------------------------------------------------
/lib/Chart/Gnuplot/Util.pm6:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | unit class Chart::Gnuplot::Util:ver<0.0.21>;
 3 | 
 4 | use Chart::Gnuplot::Subset;
 5 | 
 6 | sub tweak-fontargs(:$font-name, :$font-size) is export {
 7 |     my @font;
 8 |     @font.push($font-name.defined ?? $font-name !! "");
 9 |     @font.push($font-size) if $font-size.defined;
10 |     
11 |     (not $font-name.defined and not $font-size.defined) ?? "" !! sprintf("font \"%s\"", @font.join(","));
12 | }
13 | 
14 | sub tweak-coordinate(Mu :$coordinate!, :$name!, :$enable-nooffset = False, Int :$upper-bound?) is export {
15 |     return "" unless $coordinate.defined;
16 |     
17 |     my Str $coordinate-str = "";
18 |     given $coordinate {
19 |         when * ~~ FalseOnly and $enable-nooffset { $coordinate-str = "nooffset" }
20 |         when * ~~ Pair {
21 |             $coordinate-str = ($name, sprintf("%s %s", $_.key, $_.value)).join(" ");
22 |         }
23 |         when * ~~ List {
24 |             if $upper-bound.defined and $coordinate.elems > $upper-bound {
25 |                 die "Error: Something went wrong."; # TODO: LTA
26 |             }
27 |             my @coordinate-args;
28 |             for @$coordinate -> $p {
29 |                 given $p {
30 |                     when * ~~ Pair {
31 |                         @coordinate-args.push(sprintf("%s %s", $p.key, $p.value));
32 |                     }
33 |                     when * ~~ Real {
34 |                         @coordinate-args.push(sprintf("%s", $p));
35 |                     }
36 |                     default { die "Error: Something went wrong." } # TODO: LTA
37 |                 }
38 |             }
39 |             $coordinate-str = "$name " ~ @coordinate-args.join(",") if @coordinate-args.elems > 0;
40 |         }
41 |         default { die "Error: Something went wrong." } # TODO: LTA
42 |     }
43 |     $coordinate-str;
44 | }
45 | 


--------------------------------------------------------------------------------
/notebooks/synopsis.ipynb:
--------------------------------------------------------------------------------
  1 | {
  2 |  "cells": [
  3 |   {
  4 |    "cell_type": "code",
  5 |    "execution_count": 16,
  6 |    "id": "d8346f01-5669-4be1-b62e-b7caeed4c366",
  7 |    "metadata": {},
  8 |    "outputs": [
  9 |     {
 10 |      "data": {
 11 |       "image/svg+xml": [
 12 |        "<svg \n",
 13 |        " width=\"600\" height=\"480\"\n",
 14 |        " viewBox=\"0 0 600 480\"\n",
 15 |        " xmlns=\"http://www.w3.org/2000/svg\"\n",
 16 |        " xmlns:xlink=\"http://www.w3.org/1999/xlink\"\n",
 17 |        ">\n",
 18 |        "\n",
 19 |        "<title>Gnuplot</title>\n",
 20 |        "<desc>Produced by GNUPLOT 5.2 patchlevel 6 </desc>\n",
 21 |        "\n",
 22 |        "<g id=\"gnuplot_canvas\">\n",
 23 |        "\n",
 24 |        "<rect x=\"0\" y=\"0\" width=\"600\" height=\"480\" fill=\"none\"/>\n",
 25 |        "<defs>\n",
 26 |        "\n",
 27 |        "\t<circle id='gpDot' r='0.5' stroke-width='0.5' stroke='currentColor'/>\n",
 28 |        "\t<path id='gpPt0' stroke-width='0.222' stroke='currentColor' d='M-1,0 h2 M0,-1 v2'/>\n",
 29 |        "\t<path id='gpPt1' stroke-width='0.222' stroke='currentColor' d='M-1,-1 L1,1 M1,-1 L-1,1'/>\n",
 30 |        "\t<path id='gpPt2' stroke-width='0.222' stroke='currentColor' d='M-1,0 L1,0 M0,-1 L0,1 M-1,-1 L1,1 M-1,1 L1,-1'/>\n",
 31 |        "\t<rect id='gpPt3' stroke-width='0.222' stroke='currentColor' x='-1' y='-1' width='2' height='2'/>\n",
 32 |        "\t<rect id='gpPt4' stroke-width='0.222' stroke='currentColor' fill='currentColor' x='-1' y='-1' width='2' height='2'/>\n",
 33 |        "\t<circle id='gpPt5' stroke-width='0.222' stroke='currentColor' cx='0' cy='0' r='1'/>\n",
 34 |        "\t<use xlink:href='#gpPt5' id='gpPt6' fill='currentColor' stroke='none'/>\n",
 35 |        "\t<path id='gpPt7' stroke-width='0.222' stroke='currentColor' d='M0,-1.33 L-1.33,0.67 L1.33,0.67 z'/>\n",
 36 |        "\t<use xlink:href='#gpPt7' id='gpPt8' fill='currentColor' stroke='none'/>\n",
 37 |        "\t<use xlink:href='#gpPt7' id='gpPt9' stroke='currentColor' transform='rotate(180)'/>\n",
 38 |        "\t<use xlink:href='#gpPt9' id='gpPt10' fill='currentColor' stroke='none'/>\n",
 39 |        "\t<use xlink:href='#gpPt3' id='gpPt11' stroke='currentColor' transform='rotate(45)'/>\n",
 40 |        "\t<use xlink:href='#gpPt11' id='gpPt12' fill='currentColor' stroke='none'/>\n",
 41 |        "\t<path id='gpPt13' stroke-width='0.222' stroke='currentColor' d='M0,1.330 L1.265,0.411 L0.782,-1.067 L-0.782,-1.076 L-1.265,0.411 z'/>\n",
 42 |        "\t<use xlink:href='#gpPt13' id='gpPt14' fill='currentColor' stroke='none'/>\n",
 43 |        "\t<filter id='textbox' filterUnits='objectBoundingBox' x='0' y='0' height='1' width='1'>\n",
 44 |        "\t  <feFlood flood-color='white' flood-opacity='1' result='bgnd'/>\n",
 45 |        "\t  <feComposite in='SourceGraphic' in2='bgnd' operator='atop'/>\n",
 46 |        "\t</filter>\n",
 47 |        "\t<filter id='greybox' filterUnits='objectBoundingBox' x='0' y='0' height='1' width='1'>\n",
 48 |        "\t  <feFlood flood-color='lightgrey' flood-opacity='1' result='grey'/>\n",
 49 |        "\t  <feComposite in='SourceGraphic' in2='grey' operator='atop'/>\n",
 50 |        "\t</filter>\n",
 51 |        "</defs>\n",
 52 |        "<g fill=\"none\" color=\"white\" stroke=\"black\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 53 |        "</g>\n",
 54 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 55 |        "\t<path stroke='black'  d='M53.9,422.4 L62.9,422.4 M575.0,422.4 L566.0,422.4  '/>\t<g transform=\"translate(45.6,426.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 56 |        "\t\t<text><tspan font-family=\"Arial\" > 50</tspan></text>\n",
 57 |        "\t</g>\n",
 58 |        "</g>\n",
 59 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 60 |        "\t<path stroke='black'  d='M53.9,371.9 L62.9,371.9 M575.0,371.9 L566.0,371.9  '/>\t<g transform=\"translate(45.6,375.8)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 61 |        "\t\t<text><tspan font-family=\"Arial\" > 100</tspan></text>\n",
 62 |        "\t</g>\n",
 63 |        "</g>\n",
 64 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 65 |        "\t<path stroke='black'  d='M53.9,321.3 L62.9,321.3 M575.0,321.3 L566.0,321.3  '/>\t<g transform=\"translate(45.6,325.2)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 66 |        "\t\t<text><tspan font-family=\"Arial\" > 150</tspan></text>\n",
 67 |        "\t</g>\n",
 68 |        "</g>\n",
 69 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 70 |        "\t<path stroke='black'  d='M53.9,270.8 L62.9,270.8 M575.0,270.8 L566.0,270.8  '/>\t<g transform=\"translate(45.6,274.7)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 71 |        "\t\t<text><tspan font-family=\"Arial\" > 200</tspan></text>\n",
 72 |        "\t</g>\n",
 73 |        "</g>\n",
 74 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 75 |        "\t<path stroke='black'  d='M53.9,220.2 L62.9,220.2 M575.0,220.2 L566.0,220.2  '/>\t<g transform=\"translate(45.6,224.1)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 76 |        "\t\t<text><tspan font-family=\"Arial\" > 250</tspan></text>\n",
 77 |        "\t</g>\n",
 78 |        "</g>\n",
 79 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 80 |        "\t<path stroke='black'  d='M53.9,169.7 L62.9,169.7 M575.0,169.7 L566.0,169.7  '/>\t<g transform=\"translate(45.6,173.6)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 81 |        "\t\t<text><tspan font-family=\"Arial\" > 300</tspan></text>\n",
 82 |        "\t</g>\n",
 83 |        "</g>\n",
 84 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 85 |        "\t<path stroke='black'  d='M53.9,119.2 L62.9,119.2 M575.0,119.2 L566.0,119.2  '/>\t<g transform=\"translate(45.6,123.1)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 86 |        "\t\t<text><tspan font-family=\"Arial\" > 350</tspan></text>\n",
 87 |        "\t</g>\n",
 88 |        "</g>\n",
 89 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 90 |        "\t<path stroke='black'  d='M53.9,68.6 L62.9,68.6 M575.0,68.6 L566.0,68.6  '/>\t<g transform=\"translate(45.6,72.5)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 91 |        "\t\t<text><tspan font-family=\"Arial\" > 400</tspan></text>\n",
 92 |        "\t</g>\n",
 93 |        "</g>\n",
 94 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
 95 |        "\t<path stroke='black'  d='M53.9,18.1 L62.9,18.1 M575.0,18.1 L566.0,18.1  '/>\t<g transform=\"translate(45.6,22.0)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
 96 |        "\t\t<text><tspan font-family=\"Arial\" > 450</tspan></text>\n",
 97 |        "\t</g>\n",
 98 |        "</g>\n",
 99 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
100 |        "\t<path stroke='black'  d='M111.8,422.4 L111.8,413.4 M111.8,18.1 L111.8,27.1  '/>\t<g transform=\"translate(111.8,444.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
101 |        "\t\t<text><tspan font-family=\"Arial\" >1950</tspan></text>\n",
102 |        "\t</g>\n",
103 |        "</g>\n",
104 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
105 |        "\t<path stroke='black'  d='M169.7,422.4 L169.7,413.4 M169.7,18.1 L169.7,27.1  '/>\t<g transform=\"translate(169.7,444.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
106 |        "\t\t<text><tspan font-family=\"Arial\" >1960</tspan></text>\n",
107 |        "\t</g>\n",
108 |        "</g>\n",
109 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
110 |        "\t<path stroke='black'  d='M227.6,422.4 L227.6,413.4 M227.6,18.1 L227.6,27.1  '/>\t<g transform=\"translate(227.6,444.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
111 |        "\t\t<text><tspan font-family=\"Arial\" >1970</tspan></text>\n",
112 |        "\t</g>\n",
113 |        "</g>\n",
114 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
115 |        "\t<path stroke='black'  d='M285.5,422.4 L285.5,413.4 M285.5,18.1 L285.5,27.1  '/>\t<g transform=\"translate(285.5,444.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
116 |        "\t\t<text><tspan font-family=\"Arial\" >1980</tspan></text>\n",
117 |        "\t</g>\n",
118 |        "</g>\n",
119 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
120 |        "\t<path stroke='black'  d='M343.4,422.4 L343.4,413.4 M343.4,18.1 L343.4,27.1  '/>\t<g transform=\"translate(343.4,444.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
121 |        "\t\t<text><tspan font-family=\"Arial\" >1990</tspan></text>\n",
122 |        "\t</g>\n",
123 |        "</g>\n",
124 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
125 |        "\t<path stroke='black'  d='M401.3,422.4 L401.3,413.4 M401.3,18.1 L401.3,27.1  '/>\t<g transform=\"translate(401.3,444.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
126 |        "\t\t<text><tspan font-family=\"Arial\" >2000</tspan></text>\n",
127 |        "\t</g>\n",
128 |        "</g>\n",
129 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
130 |        "\t<path stroke='black'  d='M459.2,422.4 L459.2,413.4 M459.2,18.1 L459.2,27.1  '/>\t<g transform=\"translate(459.2,444.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
131 |        "\t\t<text><tspan font-family=\"Arial\" >2010</tspan></text>\n",
132 |        "\t</g>\n",
133 |        "</g>\n",
134 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
135 |        "\t<path stroke='black'  d='M517.1,422.4 L517.1,413.4 M517.1,18.1 L517.1,27.1  '/>\t<g transform=\"translate(517.1,444.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
136 |        "\t\t<text><tspan font-family=\"Arial\" >2020</tspan></text>\n",
137 |        "\t</g>\n",
138 |        "</g>\n",
139 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
140 |        "</g>\n",
141 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
142 |        "\t<path stroke='black'  d='M53.9,18.1 L53.9,422.4 L575.0,422.4 L575.0,18.1 L53.9,18.1 Z  '/></g>\n",
143 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
144 |        "\t<g transform=\"translate(314.4,471.3)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"middle\">\n",
145 |        "\t\t<text><tspan font-family=\"Arial\" >Year</tspan></text>\n",
146 |        "\t</g>\n",
147 |        "</g>\n",
148 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
149 |        "</g>\n",
150 |        "\t<g id=\"gnuplot_plot_1\" ><title>Male</title>\n",
151 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
152 |        "\t<g transform=\"translate(112.0,40.0)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
153 |        "\t\t<text><tspan font-family=\"Arial\" >Male</tspan></text>\n",
154 |        "\t</g>\n",
155 |        "</g>\n",
156 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
157 |        "\t<g stroke='none' shape-rendering='crispEdges'>\n",
158 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '120.3,40.6 162.5,40.6 162.5,31.6 120.3,31.6 '/>\n",
159 |        "\t</g>\n",
160 |        "\t<path stroke='rgb(148,   0, 211)'  d='M120.3,40.6 L162.5,40.6 L162.5,31.6 L120.3,31.6 L120.3,40.6 Z  '/></g>\n",
161 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
162 |        "\t<g stroke='none' shape-rendering='crispEdges'>\n",
163 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '104.6,422.4 119.1,422.4 119.1,371.8 104.6,371.8 '/>\n",
164 |        "\t</g>\n",
165 |        "\t<path stroke='rgb(148,   0, 211)'  d='M104.6,422.4 L104.6,371.9 L119.0,371.9 L119.0,422.4 L104.6,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
166 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '162.5,422.4 177.0,422.4 177.0,371.8 162.5,371.8 '/>\n",
167 |        "\t</g>\n",
168 |        "\t<path stroke='rgb(148,   0, 211)'  d='M162.5,422.4 L162.5,371.9 L176.9,371.9 L176.9,422.4 L162.5,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
169 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '220.4,422.4 234.9,422.4 234.9,392.0 220.4,392.0 '/>\n",
170 |        "\t</g>\n",
171 |        "\t<path stroke='rgb(148,   0, 211)'  d='M220.4,422.4 L220.4,392.1 L234.8,392.1 L234.8,422.4 L220.4,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
172 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '278.3,422.4 292.8,422.4 292.8,341.4 278.3,341.4 '/>\n",
173 |        "\t</g>\n",
174 |        "\t<path stroke='rgb(148,   0, 211)'  d='M278.3,422.4 L278.3,341.5 L292.7,341.5 L292.7,422.4 L278.3,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
175 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '336.2,422.4 350.7,422.4 350.7,331.3 336.2,331.3 '/>\n",
176 |        "\t</g>\n",
177 |        "\t<path stroke='rgb(148,   0, 211)'  d='M336.2,422.4 L336.2,331.4 L350.6,331.4 L350.6,422.4 L336.2,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
178 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '394.1,422.4 408.6,422.4 408.6,270.7 394.1,270.7 '/>\n",
179 |        "\t</g>\n",
180 |        "\t<path stroke='rgb(148,   0, 211)'  d='M394.1,422.4 L394.1,270.8 L408.5,270.8 L408.5,422.4 L394.1,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
181 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '452.0,422.4 466.5,422.4 466.5,230.3 452.0,230.3 '/>\n",
182 |        "\t</g>\n",
183 |        "\t<path stroke='rgb(148,   0, 211)'  d='M452.0,422.4 L452.0,230.4 L466.4,230.4 L466.4,422.4 L452.0,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
184 |        "\t\t<polygon fill = 'rgb(148,   0, 211)' points = '509.9,422.4 524.4,422.4 524.4,68.5 509.9,68.5 '/>\n",
185 |        "\t</g>\n",
186 |        "\t<path stroke='rgb(148,   0, 211)'  d='M509.9,422.4 L509.9,68.6 L524.3,68.6 L524.3,422.4 L509.9,422.4 Z  '/></g>\n",
187 |        "\t</g>\n",
188 |        "\t<g id=\"gnuplot_plot_2\" ><title>Female</title>\n",
189 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
190 |        "\t<g transform=\"translate(112.0,58.0)\" stroke=\"none\" fill=\"black\" font-family=\"Arial\" font-size=\"12.00\"  text-anchor=\"end\">\n",
191 |        "\t\t<text><tspan font-family=\"Arial\" >Female</tspan></text>\n",
192 |        "\t</g>\n",
193 |        "</g>\n",
194 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
195 |        "\t<g stroke='none' shape-rendering='crispEdges'>\n",
196 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '120.3,58.6 162.5,58.6 162.5,49.6 120.3,49.6 '/>\n",
197 |        "\t</g>\n",
198 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M120.3,58.6 L162.5,58.6 L162.5,49.6 L120.3,49.6 L120.3,58.6 Z  '/></g>\n",
199 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
200 |        "\t<g stroke='none' shape-rendering='crispEdges'>\n",
201 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '119.0,422.4 133.6,422.4 133.6,381.9 119.0,381.9 '/>\n",
202 |        "\t</g>\n",
203 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M119.0,422.4 L119.0,382.0 L133.5,382.0 L133.5,422.4 L119.0,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
204 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '176.9,422.4 191.5,422.4 191.5,381.9 176.9,381.9 '/>\n",
205 |        "\t</g>\n",
206 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M176.9,422.4 L176.9,382.0 L191.4,382.0 L191.4,422.4 L176.9,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
207 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '234.8,422.4 249.4,422.4 249.4,402.1 234.8,402.1 '/>\n",
208 |        "\t</g>\n",
209 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M234.8,422.4 L234.8,402.2 L249.3,402.2 L249.3,422.4 L234.8,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
210 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '292.7,422.4 307.3,422.4 307.3,331.3 292.7,331.3 '/>\n",
211 |        "\t</g>\n",
212 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M292.7,422.4 L292.7,331.4 L307.2,331.4 L307.2,422.4 L292.7,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
213 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '350.6,422.4 365.2,422.4 365.2,351.5 350.6,351.5 '/>\n",
214 |        "\t</g>\n",
215 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M350.6,422.4 L350.6,351.6 L365.1,351.6 L365.1,422.4 L350.6,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
216 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '408.5,422.4 423.1,422.4 423.1,260.6 408.5,260.6 '/>\n",
217 |        "\t</g>\n",
218 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M408.5,422.4 L408.5,260.7 L423.0,260.7 L423.0,422.4 L408.5,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
219 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '466.4,422.4 481.0,422.4 481.0,240.4 466.4,240.4 '/>\n",
220 |        "\t</g>\n",
221 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M466.4,422.4 L466.4,240.5 L480.9,240.5 L480.9,422.4 L466.4,422.4 Z  '/>\t<g stroke='none' shape-rendering='crispEdges'>\n",
222 |        "\t\t<polygon fill = 'rgb(  0, 158, 115)' points = '524.3,422.4 538.9,422.4 538.9,48.3 524.3,48.3 '/>\n",
223 |        "\t</g>\n",
224 |        "\t<path stroke='rgb(  0, 158, 115)'  d='M524.3,422.4 L524.3,48.4 L538.8,48.4 L538.8,422.4 L524.3,422.4 Z  '/></g>\n",
225 |        "\t</g>\n",
226 |        "<g fill=\"none\" color=\"white\" stroke=\"rgb(  0, 158, 115)\" stroke-width=\"2.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
227 |        "</g>\n",
228 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"2.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
229 |        "</g>\n",
230 |        "<g fill=\"none\" color=\"black\" stroke=\"black\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
231 |        "</g>\n",
232 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
233 |        "\t<path stroke='black'  d='M53.9,18.1 L53.9,422.4 L575.0,422.4 L575.0,18.1 L53.9,18.1 Z  '/></g>\n",
234 |        "<g fill=\"none\" color=\"black\" stroke=\"currentColor\" stroke-width=\"1.00\" stroke-linecap=\"butt\" stroke-linejoin=\"miter\">\n",
235 |        "</g>\n",
236 |        "</g>\n",
237 |        "</svg>\n"
238 |       ]
239 |      },
240 |      "execution_count": 16,
241 |      "metadata": {},
242 |      "output_type": "execute_result"
243 |     }
244 |    ],
245 |    "source": [
246 |     "use Chart::Gnuplot;\n",
247 |     "use Chart::Gnuplot::Subset;\n",
248 |     "use File::Temp;\n",
249 |     "\n",
250 |     "my ($filename, $filehandle);\n",
251 |     "\n",
252 |     "# NOTE: Shouldn't remove both ENTER and LEAVE blocks. File::Temp's auto-unlink doesn't seem to work on jupyter.\n",
253 |     "ENTER {\n",
254 |     "  ($filename, $filehandle) = tempfile(:tempdir(\"/tmp\"), :suffix(\".svg\"));\n",
255 |     "}\n",
256 |     "\n",
257 |     "LEAVE {\n",
258 |     "  $filehandle.close;\n",
259 |     "  $filename.IO.unlink;\n",
260 |     "}\n",
261 |     "\n",
262 |     "my $gnu = Chart::Gnuplot.new(:terminal(\"svg\"), :filename($filename));\n",
263 |     "\n",
264 |     "my @data = (q:to/EOF/).split(\"\\n\", :skip-empty)>>.split(\" \", :skip-empty);\n",
265 |     "Year Male Female\n",
266 |     "1950 100 90\n",
267 |     "1960 100 90\n",
268 |     "1970 80 70\n",
269 |     "1980 130 140\n",
270 |     "1990 140 120\n",
271 |     "2000 200 210\n",
272 |     "2010 240 230\n",
273 |     "2020 400 420\n",
274 |     "EOF\n",
275 |     "\n",
276 |     "my ($header, *@body) = @data;\n",
277 |     "\n",
278 |     "$gnu.command(\"set style histogram clustered\");\n",
279 |     "$gnu.legend(:left);\n",
280 |     "my AnyTicsTic @tics = (@body>>.[0]).pairs.map(-> (:key($pos), :value($year)) { %(:label($year), :pos($pos)) });\n",
281 |     "$gnu.xtics(:tics(@tics));\n",
282 |     "$gnu.xlabel(:label($header[0]));\n",
283 |     "$gnu.plot(:vertices(@body), :using([2]), :style(\"histogram\"), :title($header[1]), :fill(\"solid 1.0\"));\n",
284 |     "$gnu.plot(:vertices(@body), :using([3]), :style(\"histogram\"), :title($header[2]), :fill(\"solid 1.0\"));\n",
285 |     "$gnu.dispose;\n",
286 |     "\n",
287 |     "$filehandle.lines[1..*].join(\"\\n\");"
288 |    ]
289 |   },
290 |   {
291 |    "cell_type": "code",
292 |    "execution_count": null,
293 |    "id": "85d1bd61-dde8-4f63-b10b-da6645333483",
294 |    "metadata": {},
295 |    "outputs": [],
296 |    "source": []
297 |   }
298 |  ],
299 |  "metadata": {
300 |   "kernelspec": {
301 |    "display_name": "Raku",
302 |    "language": "raku",
303 |    "name": "raku"
304 |   },
305 |   "language_info": {
306 |    "file_extension": ".raku",
307 |    "mimetype": "text/plain",
308 |    "name": "raku",
309 |    "version": "6.d"
310 |   }
311 |  },
312 |  "nbformat": 4,
313 |  "nbformat_minor": 5
314 | }
315 | 


--------------------------------------------------------------------------------
/recprec.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/titsuki/raku-Chart-Gnuplot/490a4b7a15975742a0438d66de3753879836b2d8/recprec.png


--------------------------------------------------------------------------------
/sinx.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/titsuki/raku-Chart-Gnuplot/490a4b7a15975742a0438d66de3753879836b2d8/sinx.png


--------------------------------------------------------------------------------
/surface.dem.00.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/titsuki/raku-Chart-Gnuplot/490a4b7a15975742a0438d66de3753879836b2d8/surface.dem.00.png


--------------------------------------------------------------------------------
/t/01-basic.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | {
 6 |     lives-ok {
 7 |         my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("sample.png"));
 8 |     }, "Chart::Gnuplot.new should create a new instance."
 9 | }
10 | 
11 | {
12 |     my $msg;
13 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("sample.svg"), :debug);
14 |     $gnu.command("set terminal svg", :stderr(class { method print(*@args){ $msg ~= @args.join; }; method flush{}}));
15 |     sleep .5;
16 |     ok $msg ~~ "set terminal svg\n", "Chart::Gnuplot.command should print given command to stderr with newline when debug option is enabled.";
17 | }
18 | 
19 | done-testing;
20 | 


--------------------------------------------------------------------------------
/t/02-terminal.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | {
 6 |     my $msg = "";
 7 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("sample.svg"), :debug, :stderr(class { method print(*@args){ $msg ~= @args.join; }; method flush {} }));
 8 |     $gnu.terminal("svg");
 9 |     nok $msg ~~ /unknown/, "Chart::Gnuplot.terminal should accept \"svg\" as an argument.";
10 | }
11 | 
12 | {
13 |     my $msg;
14 |     my $gnu = Chart::Gnuplot.new(:terminal("png"), :filename("sample.png"), :debug, :stderr(class { method print(*@args){ $msg ~= @args.join; }; method flush{}}));
15 |     $gnu.terminal("Perl6isFun");
16 |     sleep .5;
17 |     ok $msg ~~ /unknown/, "Chart::Gnuplot.terminal shouldn't accept \"Perl6isFun\" as an argument.";
18 | }
19 | 
20 | done-testing;
21 | 


--------------------------------------------------------------------------------
/t/03-plot.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual-sinx.svg"));
23 |     my @actual;
24 |     $gnu.plot(:function("sin(x)"), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set terminal svg', 'set output "actual-sinx.svg"', 'plot sin(x)';
27 |     is @actual, @expected, 'Given :function("sin(x)") as an argument, then Chart::Gnuplot.plot should plot a sin(x) graph.';
28 | }
29 | 
30 | {
31 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual-population.svg"));
32 |     my @actual;
33 |     my @vertices = [$[1970,10],$[1980,100],$[2010,5000]];
34 |     $gnu.plot(:vertices(@vertices), :writer(-> $msg { @actual.push($msg); }));
35 |     $gnu.dispose;
36 |     my @expected = rx:s/\$mydata<[\d]>+ \<\< EOD/, '1970 10', '1980 100', '2010 5000', 'EOD', 'set terminal svg', 'set output "actual-population.svg"', rx:s/plot \$mydata<[\d]>+/;
37 |     ok comp(@actual, @expected), 'Given :vertices([$[1970,10],$[1980,100],$[2010,5000]]) as an argument, then Chart::Gnuplot.plot should plot a population graph.';
38 | }
39 | 
40 | done-testing;
41 | 


--------------------------------------------------------------------------------
/t/04-splot.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual-xy.svg"));
23 |     my @actual;
24 |     $gnu.splot(:function("x*y"), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set terminal svg', 'set output "actual-xy.svg"', 'splot x*y';
27 |     is @actual, @expected, 'Given :function("x*y") as an argument, then Chart::Gnuplot.splot should plot a xy graph.';
28 | }
29 | 
30 | {
31 |     my @vertices = [$[1,1,1],$[2,2,2],$[3,3,3]];
32 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual-xyz.svg"));
33 |     my @actual;
34 |     $gnu.splot(:vertices(@vertices), :writer(-> $msg { @actual.push($msg); }));
35 |     $gnu.dispose;
36 |     my @expected = rx:s/\$mydata<[\d]>+ \<\< EOD/, '1 1 1', '2 2 2', '3 3 3', 'EOD', 'set terminal svg', 'set output "actual-xyz.svg"', rx:s/splot \$mydata<[\d]>+/;
37 |     ok comp(@actual, @expected), 'Given :verteices([$[1,1,1],$[2,2,2],$[3,3,3]]) as an argument, then Chart::Gnuplot.splot should plot a xyz graph.';
38 | }
39 | 
40 | done-testing;
41 | 


--------------------------------------------------------------------------------
/t/05-label.t:
--------------------------------------------------------------------------------
  1 | use v6;
  2 | use Test;
  3 | use Chart::Gnuplot;
  4 | 
  5 | sub comp(@lhs, @rhs) returns Bool {
  6 |     return False if @lhs.elems != @rhs.elems;
  7 |     for @lhs Z @rhs -> ($l, $r) {
  8 |         given $r {
  9 |             when * ~~ Regex {
 10 |                 return False unless $l ~~ $r;
 11 |             }
 12 |             when * ~~ Str {
 13 |                 return False unless $l eq $r;
 14 |             }
 15 |             default {}
 16 |         }
 17 |     }
 18 |     True
 19 | }
 20 | 
 21 | 
 22 | {
 23 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 24 |     my @actual;
 25 |     $gnu.label(:label-text("mylabel"), :writer(-> $msg { @actual.push($msg); }));
 26 |     $gnu.dispose;
 27 |     my @expected = 'set label "mylabel"';
 28 |     is @actual, @expected, 'Given :label-text as arguments, then Chart::Gnuplot.label should set these properties.';
 29 | }
 30 | 
 31 | {
 32 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 33 |     my @actual;
 34 |     $gnu.label(:tag("1"), :label-text("mylabel"), :writer(-> $msg { @actual.push($msg); }));
 35 |     $gnu.dispose;
 36 |     my @expected = 'set label 1 "mylabel"';
 37 |     is @actual, @expected, 'Given :tag and :label-text as arguments, then Chart::Gnuplot.label should set these properties.';
 38 | }
 39 | 
 40 | {
 41 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 42 |     my @actual;
 43 |     $gnu.label(:label-text("mylabel"), :at(["graph" => 1, "graph" => 2]), :writer(-> $msg { @actual.push($msg); }));
 44 |     $gnu.dispose;
 45 |     my @expected = 'set label "mylabel" at graph 1,graph 2';
 46 |     is @actual, @expected, 'Given :label-text, :at as arguments, then Chart::Gnuplot.label should set these properties.';
 47 | }
 48 | 
 49 | {
 50 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 51 |     my @actual;
 52 |     $gnu.label(:label-text("mylabel"), :left, :writer(-> $msg { @actual.push($msg); }));
 53 |     $gnu.dispose;
 54 |     my @expected = 'set label "mylabel" left';
 55 |     is @actual, @expected, 'Given :label-text, :left as arguments, then Chart::Gnuplot.label should set these properties.';
 56 | }
 57 | 
 58 | {
 59 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 60 |     my @actual;
 61 |     $gnu.label(:label-text("mylabel"), :center, :writer(-> $msg { @actual.push($msg); }));
 62 |     $gnu.dispose;
 63 |     my @expected = 'set label "mylabel" center';
 64 |     is @actual, @expected, 'Given :label-text, :center as arguments, then Chart::Gnuplot.label should set these properties.';
 65 | }
 66 | 
 67 | {
 68 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 69 |     my @actual;
 70 |     $gnu.label(:label-text("mylabel"), :right, :writer(-> $msg { @actual.push($msg); }));
 71 |     $gnu.dispose;
 72 |     my @expected = 'set label "mylabel" right';
 73 |     is @actual, @expected, 'Given :label-text, :right as arguments, then Chart::Gnuplot.label should set these properties.';
 74 | }
 75 | 
 76 | {
 77 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 78 |     my @actual;
 79 |     $gnu.label(:label-text("mylabel"), :rotate(1), :writer(-> $msg { @actual.push($msg); }));
 80 |     $gnu.dispose;
 81 |     my @expected = 'set label "mylabel" rotate by 1';
 82 |     is @actual, @expected, 'Given :label-text, :rotate(1) as arguments, then Chart::Gnuplot.label should set these properties.';
 83 | }
 84 | 
 85 | {
 86 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 87 |     my @actual;
 88 |     $gnu.label(:label-text("mylabel"), :rotate(0), :writer(-> $msg { @actual.push($msg); }));
 89 |     $gnu.dispose;
 90 |     my @expected = 'set label "mylabel" rotate by 0';
 91 |     is @actual, @expected, 'Given :label-text, :rotate(0) as arguments, then Chart::Gnuplot.label should set these properties.';
 92 | }
 93 | 
 94 | {
 95 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 96 |     my @actual;
 97 |     $gnu.label(:label-text("mylabel"), :rotate(90), :writer(-> $msg { @actual.push($msg); }));
 98 |     $gnu.dispose;
 99 |     my @expected = 'set label "mylabel" rotate by 90';
100 |     is @actual, @expected, 'Given :label-text, :rotate(90) as arguments, then Chart::Gnuplot.label should set these properties.';
101 | }
102 | 
103 | {
104 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
105 |     my @actual;
106 |     $gnu.label(:label-text("mylabel"), :rotate(False), :writer(-> $msg { @actual.push($msg); }));
107 |     $gnu.dispose;
108 |     my @expected = 'set label "mylabel" norotate';
109 |     is @actual, @expected, 'Given :label-text, :rotate(False) as arguments, then Chart::Gnuplot.label should set these properties.';
110 | }
111 | 
112 | {
113 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
114 |     my @actual;
115 |     $gnu.label(:label-text("mylabel"), :font-name("Helvetica"), :writer(-> $msg { @actual.push($msg); }));
116 |     $gnu.dispose;
117 |     my @expected = 'set label "mylabel" font "Helvetica"';
118 |     is @actual, @expected, 'Given :label-text, :font-name as arguments, then Chart::Gnuplot.label should set these properties.';
119 | }
120 | 
121 | {
122 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
123 |     my @actual;
124 |     $gnu.label(:label-text("mylabel"), :font-size(10), :writer(-> $msg { @actual.push($msg); }));
125 |     $gnu.dispose;
126 |     my @expected = 'set label "mylabel" font ",10"';
127 |     is @actual, @expected, 'Given :label-text, :font-size as arguments, then Chart::Gnuplot.label should set these properties.';
128 | }
129 | 
130 | {
131 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
132 |     my @actual;
133 |     $gnu.label(:label-text("mylabel"), :enhanced(False), :writer(-> $msg { @actual.push($msg); }));
134 |     $gnu.dispose;
135 |     my @expected = 'set label "mylabel" noenhanced';
136 |     is @actual, @expected, 'Given :label-text, :enhanced(False) as arguments, then Chart::Gnuplot.label should set these properties.';
137 | }
138 | 
139 | {
140 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
141 |     my @actual;
142 |     $gnu.label(:label-text("mylabel"), :front, :writer(-> $msg { @actual.push($msg); }));
143 |     $gnu.dispose;
144 |     my @expected = 'set label "mylabel" front';
145 |     is @actual, @expected, 'Given :label-text, :front as arguments, then Chart::Gnuplot.label should set these properties.';
146 | }
147 | 
148 | {
149 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
150 |     my @actual;
151 |     $gnu.label(:label-text("mylabel"), :back, :writer(-> $msg { @actual.push($msg); }));
152 |     $gnu.dispose;
153 |     my @expected = 'set label "mylabel" back';
154 |     is @actual, @expected, 'Given :label-text, :back as arguments, then Chart::Gnuplot.label should set these properties.';
155 | }
156 | 
157 | {
158 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
159 |     my @actual;
160 |     $gnu.label(:label-text("mylabel"), :textcolor('rgb "blue"'), :writer(-> $msg { @actual.push($msg); }));
161 |     $gnu.dispose;
162 |     my @expected = 'set label "mylabel" textcolor rgb "blue"';
163 |     is @actual, @expected, 'Given :label-text, :textcolor as arguments, then Chart::Gnuplot.label should set these properties.';
164 | }
165 | 
166 | {
167 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
168 |     my @actual;
169 |     $gnu.label(:label-text("mylabel"), :point(False), :writer(-> $msg { @actual.push($msg); }));
170 |     $gnu.dispose;
171 |     my @expected = 'set label "mylabel" nopoint';
172 |     is @actual, @expected, 'Given :label-text, :point(False) as arguments, then Chart::Gnuplot.label should set these properties.';
173 | }
174 | 
175 | {
176 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
177 |     my @actual;
178 |     $gnu.label(:label-text("mylabel"), :line-type(0), :writer(-> $msg { @actual.push($msg); }));
179 |     $gnu.dispose;
180 |     my @expected = 'set label "mylabel" point lt 0';
181 |     is @actual, @expected, 'Given :label-text, :line-type as arguments, then Chart::Gnuplot.label should set these properties.';
182 | }
183 | 
184 | {
185 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
186 |     my @actual;
187 |     $gnu.label(:label-text("mylabel"), :point-type(0), :writer(-> $msg { @actual.push($msg); }));
188 |     $gnu.dispose;
189 |     my @expected = 'set label "mylabel" point pt 0';
190 |     is @actual, @expected, 'Given :label-text, :point-type as arguments, then Chart::Gnuplot.label should set these properties.';
191 | }
192 | 
193 | {
194 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
195 |     my @actual;
196 |     $gnu.label(:label-text("mylabel"), :offset([1]), :writer(-> $msg { @actual.push($msg); }));
197 |     $gnu.dispose;
198 |     my @expected = 'set label "mylabel" offset 1';
199 |     is @actual, @expected, 'Given :label-text, :offset as arguments, then Chart::Gnuplot.label should set these properties.';
200 | }
201 | 
202 | {
203 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
204 |     my @actual;
205 |     $gnu.label(:label-text("mylabel"), :boxed, :writer(-> $msg { @actual.push($msg); }));
206 |     $gnu.dispose;
207 |     my @expected = 'set label "mylabel" boxed';
208 |     is @actual, @expected, 'Given :label-text, :boxed as arguments, then Chart::Gnuplot.label should set these properties.';
209 | }
210 | 
211 | {
212 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
213 |     my @actual;
214 |     $gnu.label(:label-text("mylabel"), :hypertext, :writer(-> $msg { @actual.push($msg); }));
215 |     $gnu.dispose;
216 |     my @expected = 'set label "mylabel" hypertext';
217 |     is @actual, @expected, 'Given :label-text, :hypertext as arguments, then Chart::Gnuplot.label should set these properties.';
218 | }
219 | 
220 | {
221 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
222 |     my @actual;
223 |     $gnu.xlabel(:label("mylabel"), :rotate(False), :writer(-> $msg { @actual.push($msg); }));
224 |     $gnu.dispose;
225 |     my @expected = 'set xlabel "mylabel" norotate';
226 |     is @actual, @expected, 'Given :label, :rotate(False) as arguments, then Chart::Gnuplot.xlabel should set these properties.';
227 | }
228 | 
229 | {
230 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
231 |     my @actual;
232 |     $gnu.xlabel(:label("mylabel"), :rotate(90), :writer(-> $msg { @actual.push($msg); }));
233 |     $gnu.dispose;
234 |     my @expected = 'set xlabel "mylabel" rotate by 90';
235 |     is @actual, @expected, 'Given :label, :rotate(90) as arguments, then Chart::Gnuplot.xlabel should set these properties.';
236 | }
237 | 
238 | {
239 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
240 |     my @actual;
241 |     $gnu.xlabel(:label("mylabel"), :offset(["graph" => 1, "graph" => 1]), :writer(-> $msg { @actual.push($msg); }));
242 |     $gnu.dispose;
243 |     my @expected = 'set xlabel "mylabel" offset graph 1,graph 1';
244 |     is @actual, @expected, 'Given :label, :offset as arguments, then Chart::Gnuplot.xlabel should set these properties.';
245 | }
246 | 
247 | {
248 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
249 |     my @actual;
250 |     $gnu.xlabel(:label("mylabel"), :font-name("Helvetica"), :writer(-> $msg { @actual.push($msg); }));
251 |     $gnu.dispose;
252 |     my @expected = 'set xlabel "mylabel" font "Helvetica"';
253 |     is @actual, @expected, 'Given :label, :font-name as arguments, then Chart::Gnuplot.xlabel should set these properties.';
254 | }
255 | 
256 | {
257 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
258 |     my @actual;
259 |     $gnu.xlabel(:label("mylabel"), :font-size(10), :writer(-> $msg { @actual.push($msg); }));
260 |     $gnu.dispose;
261 |     my @expected = 'set xlabel "mylabel" font ",10"';
262 |     is @actual, @expected, 'Given :label, :font-size as arguments, then Chart::Gnuplot.xlabel should set these properties.';
263 | }
264 | 
265 | {
266 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
267 |     my @actual;
268 |     $gnu.xlabel(:label("mylabel"), :textcolor('rgb "white"'), :writer(-> $msg { @actual.push($msg); }));
269 |     $gnu.dispose;
270 |     my @expected = 'set xlabel "mylabel" textcolor rgb "white"';
271 |     is @actual, @expected, 'Given :label, :textcolor as arguments, then Chart::Gnuplot.xlabel should set these properties.';
272 | }
273 | 
274 | {
275 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
276 |     my @actual;
277 |     $gnu.xlabel(:label("mylabel"), :enhanced, :writer(-> $msg { @actual.push($msg); }));
278 |     $gnu.dispose;
279 |     my @expected = 'set xlabel "mylabel" enhanced';
280 |     is @actual, @expected, 'Given :label, :enhanced as arguments, then Chart::Gnuplot.xlabel should set these properties.';
281 | }
282 | 
283 | {
284 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
285 |     my @actual;
286 |     $gnu.xlabel(:label("mylabel"), :rotate(90), :writer(-> $msg { @actual.push($msg); }));
287 |     $gnu.dispose;
288 |     my @expected = 'set xlabel "mylabel" rotate by 90';
289 |     is @actual, @expected, 'Given :label, :rotate as arguments, then Chart::Gnuplot.xlabel should set these properties.';
290 | }
291 | 
292 | done-testing;
293 | 


--------------------------------------------------------------------------------
/t/06-range.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.xrange(:min(0.1), :max(0.5), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set xrange [0.1:0.5]';
27 |     is @actual, @expected, 'Given :min, :max as arguments, then Chart::Gnuplot.xrange should set these properties.';
28 | }
29 | 
30 | {
31 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
32 |     my @actual;
33 |     $gnu.xrange(:min(0.1), :max(0.5), :reverse, :writer(-> $msg { @actual.push($msg); }));
34 |     $gnu.dispose;
35 |     my @expected = 'set xrange [0.1:0.5] reverse';
36 |     is @actual, @expected, 'Given :min, :max, :reverse as arguments, then Chart::Gnuplot.xrange should set these properties.';
37 | }
38 | 
39 | {
40 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
41 |     my @actual;
42 |     $gnu.xrange(:min(0.1), :max(0.5), :writeback, :writer(-> $msg { @actual.push($msg); }));
43 |     $gnu.dispose;
44 |     my @expected = 'set xrange [0.1:0.5] writeback';
45 |     is @actual, @expected, 'Given :min, :max, :writeback as arguments, then Chart::Gnuplot.xrange should set these properties.';
46 | }
47 | 
48 | {
49 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
50 |     my @actual;
51 |     $gnu.xrange(:min(0.1), :max(0.5), :extend, :writer(-> $msg { @actual.push($msg); }));
52 |     $gnu.dispose;
53 |     my @expected = 'set xrange [0.1:0.5] extend';
54 |     is @actual, @expected, 'Given :min, :max, :extend as arguments, then Chart::Gnuplot.xrange should set these properties.';
55 | }
56 | 
57 | done-testing;
58 | 


--------------------------------------------------------------------------------
/t/07-tics.t:
--------------------------------------------------------------------------------
  1 | use v6;
  2 | use Test;
  3 | use Chart::Gnuplot;
  4 | use Chart::Gnuplot::Subset;
  5 | 
  6 | sub comp(@lhs, @rhs) returns Bool {
  7 |     return False if @lhs.elems != @rhs.elems;
  8 |     for @lhs Z @rhs -> ($l, $r) {
  9 |         given $r {
 10 |             when * ~~ Regex {
 11 |                 return False unless $l ~~ $r;
 12 |             }
 13 |             when * ~~ Str {
 14 |                 return False unless $l eq $r;
 15 |             }
 16 |             default {}
 17 |         }
 18 |     }
 19 |     True
 20 | }
 21 | 
 22 | {
 23 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 24 |     my @actual;
 25 |     $gnu.xtics(:axis, :rotate(False), :writer(-> $msg { @actual.push($msg); }));
 26 |     $gnu.dispose;
 27 |     my @expected = 'set xtics axis norotate';
 28 |     is @actual, @expected, 'Given :axis, :rotate(False) as arguments, then Chart::Gnuplot.xtics should set these properties.';
 29 | }
 30 | 
 31 | {
 32 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 33 |     my @actual;
 34 |     $gnu.xtics(:axis, :rotate(0), :writer(-> $msg { @actual.push($msg); }));
 35 |     $gnu.dispose;
 36 |     my @expected = 'set xtics axis rotate by 0';
 37 |     is @actual, @expected, 'Given :axis, :rotate(0) as arguments, then Chart::Gnuplot.xtics should set these properties.';
 38 | }
 39 | 
 40 | {
 41 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 42 |     my @actual;
 43 |     $gnu.xtics(:axis, :rotate(1), :writer(-> $msg { @actual.push($msg); }));
 44 |     $gnu.dispose;
 45 |     my @expected = 'set xtics axis rotate by 1';
 46 |     is @actual, @expected, 'Given :axis, :rotate(1) as arguments, then Chart::Gnuplot.xtics should set these properties.';
 47 | }
 48 | 
 49 | {
 50 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 51 |     my @actual;
 52 |     $gnu.xtics(:axis, :rotate(90), :writer(-> $msg { @actual.push($msg); }));
 53 |     $gnu.dispose;
 54 |     my @expected = 'set xtics axis rotate by 90';
 55 |     is @actual, @expected, 'Given :axis, :rotate(90) as arguments, then Chart::Gnuplot.xtics should set these properties.';
 56 | }
 57 | 
 58 | {
 59 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 60 |     my @actual;
 61 |     $gnu.xtics(:axis, :incr(0.1), :start(0), :end(1), :writer(-> $msg { @actual.push($msg); }));
 62 |     $gnu.dispose;
 63 |     my @expected = 'set xtics axis 0, 0.1, 1';
 64 |     is @actual, @expected, 'Given :axis, :incr, :start, :end as arguments, then Chart::Gnuplot.xtics should set these properties.';
 65 | }
 66 | 
 67 | {
 68 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 69 |     my @actual;
 70 |     my AnyTicsTic @tics = (%(:label("I love"), :pos(0.1)), %(:label("Perl 6"), :pos(0.5)));
 71 |     $gnu.xtics(:axis, :tics(@tics), :writer(-> $msg { @actual.push($msg); }));
 72 |     $gnu.dispose;
 73 |     my @expected = 'set xtics axis ("I love" 0.1,"Perl 6" 0.5)';
 74 |     is @actual, @expected, 'Given :axis, :tics as arguments, then Chart::Gnuplot.xtics should set these properties.';
 75 | }
 76 | 
 77 | {
 78 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 79 |     my @actual;
 80 |     $gnu.xtics(:axis, :format('%.3f'), :writer(-> $msg { @actual.push($msg); }));
 81 |     $gnu.dispose;
 82 |     my @expected = 'set xtics axis format "%.3f"';
 83 |     is @actual, @expected, 'Given :axis, :format as arguments, then Chart::Gnuplot.xtics should set these properties.';
 84 | }
 85 | 
 86 | {
 87 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 88 |     my @actual;
 89 |     $gnu.xtics(:axis, :format('%.3f'), :writer(-> $msg { @actual.push($msg); }));
 90 |     $gnu.dispose;
 91 |     my @expected = 'set xtics axis format "%.3f"';
 92 |     is @actual, @expected, 'Given :axis, :format as arguments, then Chart::Gnuplot.xtics should set these properties.';
 93 | }
 94 | 
 95 | {
 96 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 97 |     my @actual;
 98 |     $gnu.xtics(:axis, :font-name("Helvetica"), :writer(-> $msg { @actual.push($msg); }));
 99 |     $gnu.dispose;
100 |     my @expected = 'set xtics axis font "Helvetica"';
101 |     is @actual, @expected, 'Given :axis, :font-name as arguments, then Chart::Gnuplot.xtics should set these properties.';
102 | }
103 | 
104 | {
105 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
106 |     my @actual;
107 |     $gnu.xtics(:axis, :font-size(10), :writer(-> $msg { @actual.push($msg); }));
108 |     $gnu.dispose;
109 |     my @expected = 'set xtics axis font ",10"';
110 |     is @actual, @expected, 'Given :axis, :font-size as arguments, then Chart::Gnuplot.xtics should set these properties.';
111 | }
112 | 
113 | {
114 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
115 |     my @actual;
116 |     $gnu.xtics(:axis, :enhanced, :writer(-> $msg { @actual.push($msg); }));
117 |     $gnu.dispose;
118 |     my @expected = 'set xtics axis enhanced';
119 |     is @actual, @expected, 'Given :axis, :enhanced as arguments, then Chart::Gnuplot.xtics should set these properties.';
120 | }
121 | 
122 | {
123 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
124 |     my @actual;
125 |     $gnu.xtics(:axis, :numeric, :writer(-> $msg { @actual.push($msg); }));
126 |     $gnu.dispose;
127 |     my @expected = 'set xtics axis numeric';
128 |     is @actual, @expected, 'Given :axis, :numeric as arguments, then Chart::Gnuplot.xtics should set these properties.';
129 | }
130 | 
131 | {
132 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
133 |     my @actual;
134 |     $gnu.xtics(:axis, :timedate, :writer(-> $msg { @actual.push($msg); }));
135 |     $gnu.dispose;
136 |     my @expected = 'set xtics axis timedate';
137 |     is @actual, @expected, 'Given :axis, :timedate as arguments, then Chart::Gnuplot.xtics should set these properties.';
138 | }
139 | 
140 | {
141 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
142 |     my @actual;
143 |     $gnu.xtics(:axis, :geographic, :writer(-> $msg { @actual.push($msg); }));
144 |     $gnu.dispose;
145 |     my @expected = 'set xtics axis geographic';
146 |     is @actual, @expected, 'Given :axis, :geographic as arguments, then Chart::Gnuplot.xtics should set these properties.';
147 | }
148 | 
149 | {
150 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
151 |     my @actual;
152 |     $gnu.xtics(:axis, :rangelimited, :writer(-> $msg { @actual.push($msg); }));
153 |     $gnu.dispose;
154 |     my @expected = 'set xtics axis rangelimited';
155 |     is @actual, @expected, 'Given :axis, :rangelimited as arguments, then Chart::Gnuplot.xtics should set these properties.';
156 | }
157 | 
158 | {
159 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
160 |     my @actual;
161 |     $gnu.xtics(:axis, :textcolor('rgb "red"'), :writer(-> $msg { @actual.push($msg); }));
162 |     $gnu.dispose;
163 |     my @expected = 'set xtics axis textcolor rgb "red"';
164 |     is @actual, @expected, 'Given :axis, :textcolor as arguments, then Chart::Gnuplot.xtics should set these properties.';
165 | }
166 | 
167 | done-testing;
168 | 


--------------------------------------------------------------------------------
/t/08-legend.t:
--------------------------------------------------------------------------------
  1 | use v6;
  2 | use Test;
  3 | use Chart::Gnuplot;
  4 | 
  5 | sub comp(@lhs, @rhs) returns Bool {
  6 |     return False if @lhs.elems != @rhs.elems;
  7 |     for @lhs Z @rhs -> ($l, $r) {
  8 |         given $r {
  9 |             when * ~~ Regex {
 10 |                 return False unless $l ~~ $r;
 11 |             }
 12 |             when * ~~ Str {
 13 |                 return False unless $l eq $r;
 14 |             }
 15 |             default {}
 16 |         }
 17 |     }
 18 |     True
 19 | }
 20 | 
 21 | {
 22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 23 |     my @actual;
 24 |     $gnu.legend(:on, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 25 |     $gnu.dispose;
 26 |     my @expected = 'set key on title "Perl6"';
 27 |     is @actual, @expected, 'Given :on, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
 28 | }
 29 | 
 30 | {
 31 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 32 |     my @actual;
 33 |     $gnu.legend(:off, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 34 |     $gnu.dispose;
 35 |     my @expected = 'set key off title "Perl6"';
 36 |     is @actual, @expected, 'Given :off, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
 37 | }
 38 | 
 39 | {
 40 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 41 |     my @actual;
 42 |     $gnu.legend(:default, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 43 |     $gnu.dispose;
 44 |     my @expected = 'set key default title "Perl6"';
 45 |     is @actual, @expected, 'Given :default, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
 46 | }
 47 | 
 48 | {
 49 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 50 |     my @actual;
 51 |     $gnu.legend(:inside, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 52 |     $gnu.dispose;
 53 |     my @expected = 'set key inside title "Perl6"';
 54 |     is @actual, @expected, 'Given :inside, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
 55 | }
 56 | 
 57 | {
 58 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 59 |     my @actual;
 60 |     $gnu.legend(:outside, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 61 |     $gnu.dispose;
 62 |     my @expected = 'set key outside title "Perl6"';
 63 |     is @actual, @expected, 'Given :outside, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
 64 | }
 65 | 
 66 | {
 67 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 68 |     my @actual;
 69 |     $gnu.legend(:lmargin, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 70 |     $gnu.dispose;
 71 |     my @expected = 'set key lmargin title "Perl6"';
 72 |     is @actual, @expected, 'Given :lmargin, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
 73 | }
 74 | 
 75 | {
 76 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 77 |     my @actual;
 78 |     $gnu.legend(:rmargin, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 79 |     $gnu.dispose;
 80 |     my @expected = 'set key rmargin title "Perl6"';
 81 |     is @actual, @expected, 'Given :rmargin, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
 82 | }
 83 | 
 84 | {
 85 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 86 |     my @actual;
 87 |     $gnu.legend(:tmargin, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 88 |     $gnu.dispose;
 89 |     my @expected = 'set key tmargin title "Perl6"';
 90 |     is @actual, @expected, 'Given :tmargin, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
 91 | }
 92 | 
 93 | {
 94 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 95 |     my @actual;
 96 |     $gnu.legend(:bmargin, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
 97 |     $gnu.dispose;
 98 |     my @expected = 'set key bmargin title "Perl6"';
 99 |     is @actual, @expected, 'Given :bmargin, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
100 | }
101 | 
102 | {
103 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
104 |     my @actual;
105 |     $gnu.legend(:at(["graph" => 0.5]), :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
106 |     $gnu.dispose;
107 |     my @expected = 'set key at graph 0.5 title "Perl6"';
108 |     is @actual, @expected, 'Given :at, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
109 | }
110 | 
111 | {
112 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
113 |     my @actual;
114 |     $gnu.legend(:left, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
115 |     $gnu.dispose;
116 |     my @expected = 'set key left title "Perl6"';
117 |     is @actual, @expected, 'Given :left, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
118 | }
119 | 
120 | {
121 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
122 |     my @actual;
123 |     $gnu.legend(:right, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
124 |     $gnu.dispose;
125 |     my @expected = 'set key right title "Perl6"';
126 |     is @actual, @expected, 'Given :right, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
127 | }
128 | 
129 | {
130 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
131 |     my @actual;
132 |     $gnu.legend(:top, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
133 |     $gnu.dispose;
134 |     my @expected = 'set key top title "Perl6"';
135 |     is @actual, @expected, 'Given :top, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
136 | }
137 | 
138 | {
139 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
140 |     my @actual;
141 |     $gnu.legend(:bottom, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
142 |     $gnu.dispose;
143 |     my @expected = 'set key bottom title "Perl6"';
144 |     is @actual, @expected, 'Given :bottom, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
145 | }
146 | 
147 | {
148 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
149 |     my @actual;
150 |     $gnu.legend(:center, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
151 |     $gnu.dispose;
152 |     my @expected = 'set key center title "Perl6"';
153 |     is @actual, @expected, 'Given :center, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
154 | }
155 | 
156 | {
157 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
158 |     my @actual;
159 |     $gnu.legend(:vertical, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
160 |     $gnu.dispose;
161 |     my @expected = 'set key vertical title "Perl6"';
162 |     is @actual, @expected, 'Given :vertical, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
163 | }
164 | 
165 | {
166 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
167 |     my @actual;
168 |     $gnu.legend(:horizontal, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
169 |     $gnu.dispose;
170 |     my @expected = 'set key horizontal title "Perl6"';
171 |     is @actual, @expected, 'Given :horizontal, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
172 | }
173 | 
174 | 
175 | 
176 | {
177 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
178 |     my @actual;
179 |     $gnu.legend(:Left, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
180 |     $gnu.dispose;
181 |     my @expected = 'set key Left title "Perl6"';
182 |     is @actual, @expected, 'Given :Left, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
183 | }
184 | 
185 | {
186 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
187 |     my @actual;
188 |     $gnu.legend(:Right, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
189 |     $gnu.dispose;
190 |     my @expected = 'set key Right title "Perl6"';
191 |     is @actual, @expected, 'Given :Right, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
192 | }
193 | 
194 | {
195 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
196 |     my @actual;
197 |     $gnu.legend(:opaque, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
198 |     $gnu.dispose;
199 |     my @expected = 'set key opaque title "Perl6"';
200 |     is @actual, @expected, 'Given :opaque, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
201 | }
202 | 
203 | {
204 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
205 |     my @actual;
206 |     $gnu.legend(:reverse, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
207 |     $gnu.dispose;
208 |     my @expected = 'set key reverse title "Perl6"';
209 |     is @actual, @expected, 'Given :reverse, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
210 | }
211 | 
212 | {
213 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
214 |     my @actual;
215 |     $gnu.legend(:invert, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
216 |     $gnu.dispose;
217 |     my @expected = 'set key invert title "Perl6"';
218 |     is @actual, @expected, 'Given :invert, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
219 | }
220 | 
221 | {
222 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
223 |     my @actual;
224 |     $gnu.legend(:invert, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
225 |     $gnu.dispose;
226 |     my @expected = 'set key invert title "Perl6"';
227 |     is @actual, @expected, 'Given :invert, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
228 | }
229 | 
230 | {
231 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
232 |     my @actual;
233 |     $gnu.legend(:samplen(10), :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
234 |     $gnu.dispose;
235 |     my @expected = 'set key samplen 10 title "Perl6"';
236 |     is @actual, @expected, 'Given :samplen, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
237 | }
238 | 
239 | {
240 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
241 |     my @actual;
242 |     $gnu.legend(:spacing(1.5), :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
243 |     $gnu.dispose;
244 |     my @expected = 'set key spacing 1.5 title "Perl6"';
245 |     is @actual, @expected, 'Given :spacing, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
246 | }
247 | 
248 | {
249 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
250 |     my @actual;
251 |     $gnu.legend(:width(10), :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
252 |     $gnu.dispose;
253 |     my @expected = 'set key width 10 title "Perl6"';
254 |     is @actual, @expected, 'Given :width, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
255 | }
256 | 
257 | {
258 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
259 |     my @actual;
260 |     $gnu.legend(:height(10), :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
261 |     $gnu.dispose;
262 |     my @expected = 'set key height 10 title "Perl6"';
263 |     is @actual, @expected, 'Given :height, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
264 | }
265 | 
266 | 
267 | {
268 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
269 |     my @actual;
270 |     $gnu.legend(:autotitle, :columnheader, :title("Perl6"), :writer(-> $msg { @actual.push($msg); }));
271 |     $gnu.dispose;
272 |     my @expected = 'set key autotitle columnheader title "Perl6"';
273 |     is @actual, @expected, 'Given :autotitle, :columnheader, :title as arguments, then Chart::Gnuplot.legend should set these properties.';
274 | }
275 | 
276 | {
277 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
278 |     my @actual;
279 |     $gnu.legend(:title("Perl6"), :box, :linestyle(1), :writer(-> $msg { @actual.push($msg); }));
280 |     $gnu.dispose;
281 |     my @expected = 'set key title "Perl6" box linestyle 1';
282 |     is @actual, @expected, 'Given :title, :box, :linestyle as arguments, then Chart::Gnuplot.legend should set these properties.';
283 | }
284 | 
285 | {
286 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
287 |     my @actual;
288 |     $gnu.legend(:title("Perl6"), :box, :linetype(1), :writer(-> $msg { @actual.push($msg); }));
289 |     $gnu.dispose;
290 |     my @expected = 'set key title "Perl6" box linetype 1';
291 |     is @actual, @expected, 'Given :title, :box, :linetype as arguments, then Chart::Gnuplot.legend should set these properties.';
292 | }
293 | 
294 | {
295 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
296 |     my @actual;
297 |     $gnu.legend(:title("Perl6"), :box, :linewidth(1), :writer(-> $msg { @actual.push($msg); }));
298 |     $gnu.dispose;
299 |     my @expected = 'set key title "Perl6" box linewidth 1';
300 |     is @actual, @expected, 'Given :title, :box, :linewidth as arguments, then Chart::Gnuplot.legend should set these properties.';
301 | }
302 | 
303 | {
304 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
305 |     my @actual;
306 |     $gnu.legend(:title("Perl6"), :maxcols(10), :writer(-> $msg { @actual.push($msg); }));
307 |     $gnu.dispose;
308 |     my @expected = 'set key title "Perl6" maxcols 10';
309 |     is @actual, @expected, 'Given :title, :maxcols as arguments, then Chart::Gnuplot.legend should set these properties.';
310 | }
311 | 
312 | {
313 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
314 |     my @actual;
315 |     $gnu.legend(:title("Perl6"), :maxrows(10), :writer(-> $msg { @actual.push($msg); }));
316 |     $gnu.dispose;
317 |     my @expected = 'set key title "Perl6" maxrows 10';
318 |     is @actual, @expected, 'Given :title, :maxrows as arguments, then Chart::Gnuplot.legend should set these properties.';
319 | }
320 | 
321 | done-testing;
322 | 


--------------------------------------------------------------------------------
/t/09-border.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.border(:integer(8), :front, :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set border 8 front';
27 |     is @actual, @expected, 'Given :integer, :front as arguments, then Chart::Gnuplot.border should set these properties.';
28 | }
29 | 
30 | 
31 | {
32 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
33 |     my @actual;
34 |     $gnu.border(:integer(8), :back, :writer(-> $msg { @actual.push($msg); }));
35 |     $gnu.dispose;
36 |     my @expected = 'set border 8 back';
37 |     is @actual, @expected, 'Given :integer, :back as arguments, then Chart::Gnuplot.border should set these properties.';
38 | }
39 | 
40 | {
41 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
42 |     my @actual;
43 |     $gnu.border(:integer(8), :behind, :writer(-> $msg { @actual.push($msg); }));
44 |     $gnu.dispose;
45 |     my @expected = 'set border 8 behind';
46 |     is @actual, @expected, 'Given :integer, :behind as arguments, then Chart::Gnuplot.border should set these properties.';
47 | }
48 | 
49 | {
50 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
51 |     my @actual;
52 |     $gnu.border(:integer(8), :linewidth(5), :writer(-> $msg { @actual.push($msg); }));
53 |     $gnu.dispose;
54 |     my @expected = 'set border 8 linewidth 5';
55 |     is @actual, @expected, 'Given :integer, :linewidth as arguments, then Chart::Gnuplot.border should set these properties.';
56 | }
57 | 
58 | {
59 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
60 |     my @actual;
61 |     $gnu.border(:integer(8), :linestyle(1), :writer(-> $msg { @actual.push($msg); }));
62 |     $gnu.dispose;
63 |     my @expected = 'set border 8 linestyle 1';
64 |     is @actual, @expected, 'Given :integer, :linestyle as arguments, then Chart::Gnuplot.border should set these properties.';
65 | }
66 | 
67 | {
68 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
69 |     my @actual;
70 |     $gnu.border(:integer(8), :linetype(1), :writer(-> $msg { @actual.push($msg); }));
71 |     $gnu.dispose;
72 |     my @expected = 'set border 8 linetype 1';
73 |     is @actual, @expected, 'Given :integer, :linetype as arguments, then Chart::Gnuplot.border should set these properties.';
74 | }
75 | 
76 | done-testing;
77 | 


--------------------------------------------------------------------------------
/t/10-grid.t:
--------------------------------------------------------------------------------
  1 | use v6;
  2 | use Test;
  3 | use Chart::Gnuplot;
  4 | 
  5 | sub comp(@lhs, @rhs) returns Bool {
  6 |     return False if @lhs.elems != @rhs.elems;
  7 |     for @lhs Z @rhs -> ($l, $r) {
  8 |         given $r {
  9 |             when * ~~ Regex {
 10 |                 return False unless $l ~~ $r;
 11 |             }
 12 |             when * ~~ Str {
 13 |                 return False unless $l eq $r;
 14 |             }
 15 |             default {}
 16 |         }
 17 |     }
 18 |     True
 19 | }
 20 | 
 21 | {
 22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 23 |     my @actual;
 24 |     $gnu.grid(:xtics, :writer(-> $msg { @actual.push($msg); }));
 25 |     $gnu.dispose;
 26 |     my @expected = 'set grid xtics';
 27 |     is @actual, @expected, 'Given :xtics as arguments, then Chart::Gnuplot.grid should set these properties.';
 28 | }
 29 | 
 30 | {
 31 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 32 |     my @actual;
 33 |     $gnu.grid(:ytics, :writer(-> $msg { @actual.push($msg); }));
 34 |     $gnu.dispose;
 35 |     my @expected = 'set grid ytics';
 36 |     is @actual, @expected, 'Given :ytics as arguments, then Chart::Gnuplot.grid should set these properties.';
 37 | }
 38 | 
 39 | {
 40 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 41 |     my @actual;
 42 |     $gnu.grid(:ztics, :writer(-> $msg { @actual.push($msg); }));
 43 |     $gnu.dispose;
 44 |     my @expected = 'set grid ztics';
 45 |     is @actual, @expected, 'Given :ztics as arguments, then Chart::Gnuplot.grid should set these properties.';
 46 | }
 47 | 
 48 | {
 49 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 50 |     my @actual;
 51 |     $gnu.grid(:x2tics, :writer(-> $msg { @actual.push($msg); }));
 52 |     $gnu.dispose;
 53 |     my @expected = 'set grid x2tics';
 54 |     is @actual, @expected, 'Given :x2tics as arguments, then Chart::Gnuplot.grid should set these properties.';
 55 | }
 56 | 
 57 | 
 58 | {
 59 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 60 |     my @actual;
 61 |     $gnu.grid(:cbtics, :writer(-> $msg { @actual.push($msg); }));
 62 |     $gnu.dispose;
 63 |     my @expected = 'set grid cbtics';
 64 |     is @actual, @expected, 'Given :cbtics as arguments, then Chart::Gnuplot.grid should set these properties.';
 65 | }
 66 | 
 67 | {
 68 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 69 |     my @actual;
 70 |     $gnu.grid(:polar(30), :writer(-> $msg { @actual.push($msg); }));
 71 |     $gnu.dispose;
 72 |     my @expected = 'set grid polar 30';
 73 |     is @actual, @expected, 'Given :polar as arguments, then Chart::Gnuplot.grid should set these properties.';
 74 | }
 75 | 
 76 | {
 77 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 78 |     my @actual;
 79 |     $gnu.grid(:layerdefault, :writer(-> $msg { @actual.push($msg); }));
 80 |     $gnu.dispose;
 81 |     my @expected = 'set grid layerdefault';
 82 |     is @actual, @expected, 'Given :layerdefault as arguments, then Chart::Gnuplot.grid should set these properties.';
 83 | }
 84 | 
 85 | {
 86 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 87 |     my @actual;
 88 |     $gnu.grid(:front, :writer(-> $msg { @actual.push($msg); }));
 89 |     $gnu.dispose;
 90 |     my @expected = 'set grid front';
 91 |     is @actual, @expected, 'Given :front as arguments, then Chart::Gnuplot.grid should set these properties.';
 92 | }
 93 | 
 94 | {
 95 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 96 |     my @actual;
 97 |     $gnu.grid(:back, :writer(-> $msg { @actual.push($msg); }));
 98 |     $gnu.dispose;
 99 |     my @expected = 'set grid back';
100 |     is @actual, @expected, 'Given :back as arguments, then Chart::Gnuplot.grid should set these properties.';
101 | }
102 | 
103 | {
104 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
105 |     my @actual;
106 |     $gnu.grid(:linewidth([1,1]), :writer(-> $msg { @actual.push($msg); }));
107 |     $gnu.dispose;
108 |     my @expected = 'set grid linewidth 1 , linewidth 1';
109 |     is @actual, @expected, 'Given :linewidth as arguments, then Chart::Gnuplot.grid should set these properties.';
110 | }
111 | 
112 | {
113 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
114 |     my @actual;
115 |     $gnu.grid(:linestyle([1,1]), :writer(-> $msg { @actual.push($msg); }));
116 |     $gnu.dispose;
117 |     my @expected = 'set grid linestyle 1 , linestyle 1';
118 |     is @actual, @expected, 'Given :linestyle as arguments, then Chart::Gnuplot.grid should set these properties.';
119 | }
120 | 
121 | {
122 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
123 |     my @actual;
124 |     $gnu.grid(:linetype([1,1]), :writer(-> $msg { @actual.push($msg); }));
125 |     $gnu.dispose;
126 |     my @expected = 'set grid linetype 1 , linetype 1';
127 |     is @actual, @expected, 'Given :linetype as arguments, then Chart::Gnuplot.grid should set these properties.';
128 | }
129 | 
130 | done-testing;
131 | 


--------------------------------------------------------------------------------
/t/11-timestamp.t:
--------------------------------------------------------------------------------
  1 | use v6;
  2 | use Test;
  3 | use Chart::Gnuplot;
  4 | 
  5 | sub comp(@lhs, @rhs) returns Bool {
  6 |     return False if @lhs.elems != @rhs.elems;
  7 |     for @lhs Z @rhs -> ($l, $r) {
  8 |         given $r {
  9 |             when * ~~ Regex {
 10 |                 return False unless $l ~~ $r;
 11 |             }
 12 |             when * ~~ Str {
 13 |                 return False unless $l eq $r;
 14 |             }
 15 |             default {}
 16 |         }
 17 |     }
 18 |     True
 19 | }
 20 | 
 21 | {
 22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 23 |     my @actual;
 24 |     $gnu.timestamp(:format('%d'), :top, :writer(-> $msg { @actual.push($msg); }));
 25 |     $gnu.dispose;
 26 |     my @expected = 'set timestamp "%d" top';
 27 |     is @actual, @expected, 'Given :format, :top as arguments, then Chart::Gnuplot.timestamp should set these properties.';
 28 | }
 29 | 
 30 | {
 31 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 32 |     my @actual;
 33 |     $gnu.timestamp(:format('%d'), :bottom, :writer(-> $msg { @actual.push($msg); }));
 34 |     $gnu.dispose;
 35 |     my @expected = 'set timestamp "%d" bottom';
 36 |     is @actual, @expected, 'Given :format, :bottom as arguments, then Chart::Gnuplot.timestamp should set these properties.';
 37 | }
 38 | 
 39 | {
 40 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 41 |     my @actual;
 42 |     $gnu.timestamp(:format('%d'), :bottom, :writer(-> $msg { @actual.push($msg); }));
 43 |     $gnu.dispose;
 44 |     my @expected = 'set timestamp "%d" bottom';
 45 |     is @actual, @expected, 'Given :format, :bottom as arguments, then Chart::Gnuplot.timestamp should set these properties.';
 46 | }
 47 | 
 48 | {
 49 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 50 |     my @actual;
 51 |     $gnu.timestamp(:format('%d'), :rotate, :writer(-> $msg { @actual.push($msg); }));
 52 |     $gnu.dispose;
 53 |     my @expected = 'set timestamp "%d" rotate';
 54 |     is @actual, @expected, 'Given :format, :rotate as arguments, then Chart::Gnuplot.timestamp should set these properties.';
 55 | }
 56 | 
 57 | {
 58 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 59 |     my @actual;
 60 |     $gnu.timestamp(:format('%d'), :offset("graph" => 1), :writer(-> $msg { @actual.push($msg); }));
 61 |     $gnu.dispose;
 62 |     my @expected = 'set timestamp "%d" offset graph 1';
 63 |     is @actual, @expected, 'Given :format, :offset(Pair) as arguments, then Chart::Gnuplot.timestamp should set these properties.';
 64 | }
 65 | 
 66 | {
 67 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 68 |     my @actual;
 69 |     $gnu.timestamp(:format('%d'), :offset(["graph" => 1, "graph" => 1]), :writer(-> $msg { @actual.push($msg); }));
 70 |     $gnu.dispose;
 71 |     my @expected = 'set timestamp "%d" offset graph 1,graph 1';
 72 |     is @actual, @expected, 'Given :format, :offset(List) as arguments, then Chart::Gnuplot.timestamp should set these properties.';
 73 | }
 74 | 
 75 | {
 76 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 77 |     my @actual;
 78 |     $gnu.timestamp(:format('%d'), :font-name("Helvetica"), :writer(-> $msg { @actual.push($msg); }));
 79 |     $gnu.dispose;
 80 |     my @expected = 'set timestamp "%d" font "Helvetica"';
 81 |     is @actual, @expected, 'Given :format, :font-name as arguments, then Chart::Gnuplot.timestamp should set these properties.';
 82 | }
 83 | 
 84 | {
 85 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 86 |     my @actual;
 87 |     $gnu.timestamp(:format('%d'), :font-size(10), :writer(-> $msg { @actual.push($msg); }));
 88 |     $gnu.dispose;
 89 |     my @expected = 'set timestamp "%d" font ",10"';
 90 |     is @actual, @expected, 'Given :format, :font-size as arguments, then Chart::Gnuplot.timestamp should set these properties.';
 91 | }
 92 | 
 93 | {
 94 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
 95 |     my @actual;
 96 |     $gnu.timestamp(:format('%d'), :textcolor('rgb "blue"'), :writer(-> $msg { @actual.push($msg); }));
 97 |     $gnu.dispose;
 98 |     my @expected = 'set timestamp "%d" textcolor rgb "blue"';
 99 |     is @actual, @expected, 'Given :format, :textcolor as arguments, then Chart::Gnuplot.timestamp should set these properties.';
100 | }
101 | 
102 | done-testing;
103 | 


--------------------------------------------------------------------------------
/t/12-rectangle.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.rectangle(:index(1), :from(["graph" => 0, "graph" => 0]), :to(["graph" => 1, "graph" => 1]), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set object 1 rectangle from graph 0,graph 0 to graph 1,graph 1';
27 |     is @actual, @expected, 'Given :integer, :front as arguments, then Chart::Gnuplot.rectangle should set these properties.';
28 | }
29 | 
30 | done-testing;
31 | 


--------------------------------------------------------------------------------
/t/13-ellipse.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.ellipse(:index(1), :center(["graph" => 1, "graph" => 1]), :w(1), :h(1), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set object 1 ellipse at graph 1,graph 1 size 1,1';
27 |     is @actual, @expected, 'Given :index, :center, :w, :h as arguments, then Chart::Gnuplot.ellipse should set these properties.';
28 | }
29 | 
30 | done-testing;
31 | 


--------------------------------------------------------------------------------
/t/14-circle.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.circle(:index(1), :center(["graph" => 1, "graph" => 1]), :radius(3), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set object 1 circle at graph 1,graph 1 size 3';
27 |     is @actual, @expected, 'Given :index, :center, :radius as arguments, then Chart::Gnuplot.circle should set these properties.';
28 | }
29 | 
30 | done-testing;
31 | 


--------------------------------------------------------------------------------
/t/15-polygon.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.polygon(:index(1), :from(["graph" => 0, "graph" => 0]), :to([$["graph" => 1, "graph" => 1]]), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set object 1 polygon from graph 0,graph 0 to graph 1,graph 1';
27 |     is @actual, @expected, 'Given :index, :from, :to as arguments, then Chart::Gnuplot.polygon should set these properties.';
28 | }
29 | 
30 | done-testing;
31 | 


--------------------------------------------------------------------------------
/t/16-title.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.title(:text("Perl6 is fun"), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set title "Perl6 is fun"';
27 |     is @actual, @expected, 'Given :text as arguments, then Chart::Gnuplot.title should set these properties.';
28 | }
29 | 
30 | done-testing;
31 | 


--------------------------------------------------------------------------------
/t/17-arrow.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.arrow(:index(1), :from(["graph" => 0, "graph" => 0]), :to(["graph" => 1, "graph" => 1]), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set arrow from graph 0,graph 0 to graph 1,graph 1';
27 |     is @actual, @expected, 'Given :from, :to as arguments, then Chart::Gnuplot.arrow should set these properties.';
28 | }
29 | 
30 | done-testing;
31 | 


--------------------------------------------------------------------------------
/t/18-multiplot.t:
--------------------------------------------------------------------------------
 1 | use v6;
 2 | use Test;
 3 | use Chart::Gnuplot;
 4 | 
 5 | sub comp(@lhs, @rhs) returns Bool {
 6 |     return False if @lhs.elems != @rhs.elems;
 7 |     for @lhs Z @rhs -> ($l, $r) {
 8 |         given $r {
 9 |             when * ~~ Regex {
10 |                 return False unless $l ~~ $r;
11 |             }
12 |             when * ~~ Str {
13 |                 return False unless $l eq $r;
14 |             }
15 |             default {}
16 |         }
17 |     }
18 |     True
19 | }
20 | 
21 | {
22 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
23 |     my @actual;
24 |     $gnu.multiplot(:title("Perl6 is fun"), :font-name("Helvetica"), :writer(-> $msg { @actual.push($msg); }));
25 |     $gnu.dispose;
26 |     my @expected = 'set multiplot title "Perl6 is fun" font "Helvetica"';
27 |     is @actual, @expected, 'Given :title, :font-name as arguments, then Chart::Gnuplot.multiplot should set these properties.';
28 | }
29 | 
30 | {
31 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
32 |     my @actual;
33 |     $gnu.multiplot(:title("Perl6 is fun"), :font-size(10), :writer(-> $msg { @actual.push($msg); }));
34 |     $gnu.dispose;
35 |     my @expected = 'set multiplot title "Perl6 is fun" font ",10"';
36 |     is @actual, @expected, 'Given :title, :font-size as arguments, then Chart::Gnuplot.multiplot should set these properties.';
37 | }
38 | 
39 | {
40 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
41 |     my @actual;
42 |     $gnu.multiplot(:title("Perl6 is fun"), :layout([2,2]), :writer(-> $msg { @actual.push($msg); }));
43 |     $gnu.dispose;
44 |     my @expected = 'set multiplot title "Perl6 is fun" layout 2,2';
45 |     is @actual, @expected, 'Given :title, :layout as arguments, then Chart::Gnuplot.multiplot should set these properties.';
46 | }
47 | 
48 | {
49 |     my $gnu = Chart::Gnuplot.new(:terminal("svg"), :filename("actual.svg"));
50 |     my @actual;
51 |     $gnu.multiplot(:title("Perl6 is fun"), :offset("graph" => 0), :writer(-> $msg { @actual.push($msg); }));
52 |     $gnu.dispose;
53 |     my @expected = 'set multiplot title "Perl6 is fun" offset graph 0';
54 |     is @actual, @expected, 'Given :title, :offset as arguments, then Chart::Gnuplot.multiplot should set these properties.';
55 | }
56 | 
57 | done-testing;
58 | 


--------------------------------------------------------------------------------