Improvement ideas

[szaydel]

I have been playing around with the library a bit and made some changes over time. These are just ideas I wanted to share and see if there's much interest. Most of them are half-baked, as such no PR yet, but if you have interest in these, I am sure I can bring them closer to being useful.

diff --git c/common.go w/common.go
index e57bee1..712b8c4 100644
--- c/common.go
+++ w/common.go
@@ -139,7 +139,7 @@ func (plot *Plot) SetLogscale(axis string, base int) error {
 //  plot.AddPointGroup("Sample 1", "lines", []float64{2, 3, 4, 1})
 //  plot.SetTitle("Test Results")
 //     plot.SetYrange(-2,2)
-func (plot *Plot) SetYrange(start int, end int) error {
+func (plot *Plot) SetYrange(start, end int) error {
    return plot.Cmd(fmt.Sprintf("set yrange [%d:%d]", start, end))
 }

@@ -174,7 +174,22 @@ func (plot *Plot) SavePlot(filename string) (err error) {
    if plot.nplots == 0 {
        return &gnuplotError{fmt.Sprintf("This plot has 0 curves and therefore its a redundant plot and it can't be printed.")}
    }
-   outputFormat := "set terminal " + plot.format
+   outputFormat := "set terminal " + plot.format.String()
+   fmt.Printf("outputFormat: %s\n", outputFormat)
+   plot.CheckedCmd(outputFormat)
+   outputFileCommand := "set output " + "'" + filename + "'"
+   fmt.Printf("outputFileCommand: %s\n", outputFileCommand)
+   plot.CheckedCmd(outputFileCommand)
+   plot.CheckedCmd("replot  ")
+   return nil
+}
+
+func (plot *Plot) SaveHistogram(filename string) (err error) {
+   if plot.nplots == 0 {
+       return &gnuplotError{fmt.Sprintf("This plot has 0 curves and therefore its a redundant plot and it can't be printed.")}
+   }
+   plot.style = Histogram
+   outputFormat := "set terminal " + plot.format.String()
    plot.CheckedCmd(outputFormat)
    outputFileCommand := "set output" + "'" + filename + "'"
    plot.CheckedCmd(outputFileCommand)
@@ -196,9 +211,9 @@ func (plot *Plot) SavePlot(filename string) (err error) {
 //     plot.SetFormat("pdf")
 //  plot.SavePlot("1.pdf")
 // NOTE: png is default format for saving files.
-func (plot *Plot) SetFormat(newformat string) error {
-   allowed := []string{
-       "png", "pdf"}
+func (plot *Plot) SetFormat(newformat PlotFormat) error {
+   allowed := []PlotFormat{
+       Png, Pdf}
    for _, s := range allowed {
        if newformat == s {
            plot.format = newformat
@@ -210,3 +225,32 @@ func (plot *Plot) SetFormat(newformat string) error {
    err := &gnuplotError{fmt.Sprintf("invalid format '%s'", newformat)}
    return err
 }
+
+// SetLineStyleBrewerQualitative1 sets color palette based on
+// ColorBrewer Qualitative Paired Scheme with 9 colors.
+func (plot *Plot) SetLineStyleBrewerQualitative1() {
+   pal := `
+   # line styles
+   set style line 1 lt 1 lc rgb '#a6cee3' # light blue
+   set style line 2 lt 1 lc rgb '#1f78b4' # dark blue
+   set style line 3 lt 1 lc rgb '#b2df8a' # light green
+   set style line 4 lt 1 lc rgb '#33a02c' # dark green
+   set style line 5 lt 1 lc rgb '#fb9a99' # light red
+   set style line 6 lt 1 lc rgb '#e31a1c' # dark red
+   set style line 7 lt 1 lc rgb '#fdbf6f' # light orange
+   set style line 8 lt 1 lc rgb '#ff7f00' # dark orange
+   set style line 9 lt 1 lc rgb '#cab2d6' # light purple
+
+   # palette
+   set palette defined ( 0 '#a6cee3',\
+                         1 '#1f78b4',\
+                         2 '#b2df8a',\
+                         3 '#33a02c',\
+                         4 '#fb9a99',\
+                         5 '#e31a1c',\
+                         6 '#fdbf6f',\
+                         7 '#ff7f00',\
+                         8 '#cab2d6')`
+   plot.Cmd(pal)
+   plot.Execute()
+}
\ No newline at end of file
diff --git c/common_test.go w/common_test.go
index 0c84fc7..d31f97f 100644
--- c/common_test.go
+++ w/common_test.go
@@ -2,24 +2,123 @@ package glot

 import "testing"

-func TestSetLabels(t *testing.T) {
+var Args = PlotArgs{
+   Debug:   true,
+   Persist: true,
+}
+
+func TestSetLabels3Dims(t *testing.T) {
    dimensions := 3
-   persist := false
-   debug := false
-   plot, _ := NewPlot(dimensions, persist, debug)
+   plot, _ := NewPlot(dimensions, Args)
+   err := plot.SetLabels()
+   if err == nil {
+       t.Error("SetLabels raises error when empty string is passed")
+   }
+}
+
+func TestSetLabels2Dims(t *testing.T) {
+   dimensions := 2
+   plot, _ := NewPlot(dimensions, Args)
    err := plot.SetLabels()
    if err == nil {
        t.Error("SetLabels raises error when empty string is passed")
    }
 }

-func TestSetFormat(t *testing.T) {
+func TestSetLabels1Dims(t *testing.T) {
+   dimensions := 1
+   plot, _ := NewPlot(dimensions, Args)
+   err := plot.SetLabels()
+   if err == nil {
+       t.Error("SetLabels raises error when empty string is passed")
+   }
+}
+
+func TestSetFormat3Dims(t *testing.T) {
    dimensions := 3
-   persist := false
-   debug := false
-   plot, _ := NewPlot(dimensions, persist, debug)
-   err := plot.SetFormat("tls")
+
+   // Test unsupported formats
+   plot, _ := NewPlot(dimensions, Args)
+   err := plot.SetFormat(0)
    if err == nil {
        t.Error("SetLabels raises error when non-supported format is passed as an argument.")
    }
+
+   // Test supported formats
+   plot, _ = NewPlot(dimensions, Args)
+   err = plot.SetFormat(Pdf)
+   if err != nil {
+       t.Error("SetLabels failed to set supported format (Pdf).")
+   }
+   err = plot.SetFormat(Png)
+   if err != nil {
+       t.Error("SetLabels failed to set supported format (Png).")
+   }
 }
+
+func TestSetFormat2Dims(t *testing.T) {
+   dimensions := 2
+
+   // Test unsupported formats
+   plot, _ := NewPlot(dimensions, Args)
+   err := plot.SetFormat(0)
+   if err == nil {
+       t.Error("SetLabels raises error when non-supported format is passed as an argument.")
+   }
+
+   // Test supported formats
+   plot, _ = NewPlot(dimensions, Args)
+   err = plot.SetFormat(Pdf)
+   if err != nil {
+       t.Error("SetLabels failed to set supported format (Pdf).")
+   }
+   err = plot.SetFormat(Png)
+   if err != nil {
+       t.Error("SetLabels failed to set supported format (Png).")
+   }
+}
+
+func TestSetFormat1Dims(t *testing.T) {
+   dimensions := 1
+
+   // Test unsupported formats
+   plot, _ := NewPlot(dimensions, Args)
+   err := plot.SetFormat(0)
+   if err == nil {
+       t.Error("SetLabels raises error when non-supported format is passed as an argument.")
+   }
+
+   // Test supported formats
+   plot, _ = NewPlot(dimensions, Args)
+   err = plot.SetFormat(Pdf)
+   if err != nil {
+       t.Error("SetLabels failed to set supported format (Pdf).")
+   }
+   err = plot.SetFormat(Png)
+   if err != nil {
+       t.Error("SetLabels failed to set supported format (Png).")
+   }
+}
+
+func TestLinesStyleBrewerQualitative1(t *testing.T) {
+   dimensions := 1
+
+   // Test unsupported formats
+   plot1, _ := NewPlot(dimensions, Args)
+   plot2, _ := NewPlot(dimensions, Args)
+   t1 := `
+   set multiplot layout 2,2 ;
+   plot sin(x) ls 1 ; plot sin(x/2) ls 2 ;
+   plot sin(x/4) ls 3 ; plot cos(x/2) ls 4
+   `
+   t2 := `
+   set multiplot layout 2,2 ;
+   plot sin(x) ls 5 ; plot sin(x/2) ls 6 ;
+   plot sin(x/4) ls 7 ; plot cos(x/2) ls 8
+   `
+   plot1.SetLineStyleBrewerQualitative1()
+   plot2.SetLineStyleBrewerQualitative1()
+   plot1.Cmd(t1)
+   plot2.Cmd(t2)
+
+}
\ No newline at end of file
diff --git c/core.go w/core.go
index 5146ff4..701774d 100644
--- c/core.go
+++ w/core.go
@@ -73,7 +73,9 @@ func (plot *Plot) Cmd(format string, a ...interface{}) error {
    if plot.debug {
        //buf := new(bytes.Buffer)
        //io.Copy(buf, plot.proc.handle.Stdout)
-       fmt.Printf("cmd> %v", cmd)
+       fmt.Printf("fmt> %v\n", format)
+       fmt.Printf("a>   %v\n", a)
+       fmt.Printf("cmd> %v\n", cmd)
        fmt.Printf("res> %v\n", n)
    }
    return err
diff --git c/core_test.go w/core_test.go
index 077ff59..8e8cc5f 100644
--- c/core_test.go
+++ w/core_test.go
@@ -1,6 +1,9 @@
 package glot

-import "testing"
+import (
+   "math"
+   "testing"
+)

 func TestMin(t *testing.T) {
    var v int
@@ -9,3 +12,31 @@ func TestMin(t *testing.T) {
        t.Error("Expected 1, got ", v)
    }
 }
+
+func TestCmd(t *testing.T) {
+   base2n := func(n float64) []float64 {
+       res := []float64{}
+       for i := 0.; i < n; i++ {
+           res = append(res, math.Pow(2, i))
+       }
+       return res
+   }
+   var testArgs = PlotArgs{
+       Debug:   true,
+       Format:  Pdf,
+       Persist: true,
+       Style:   Points,
+       Command: "plot ",
+   }
+   var pg = &PointGroup{
+       name:       "TestCmd",
+       dimensions: 1,
+       style:      Points,
+       castedData: base2n(9),
+   }
+   p, err := NewPlot(1, testArgs)
+   if err != nil {
+       t.Errorf("NewPlot failed creation with: %v", err)
+   }
+   p.plotX(pg)
+}
diff --git c/function.go w/function.go
index 29fee9b..ae371bd 100644
--- c/function.go
+++ w/function.go
@@ -30,7 +30,7 @@ type Func3d func(x float64, y float64) float64
 //  pointsX     :=> The x Value of the points to be plotted.  y = func(x) is plotted on the curve.
 //  style       :=> Style of the curve
 // NOTE: Currently only float64 type is supported for this function
-func (plot *Plot) AddFunc2d(name string, style string, x []float64, fct Func2d) error {
+func (plot *Plot) AddFunc2d(name string, style PointStyle, x []float64, fct Func2d) error {
    y := make([]float64, len(x))
    for index := range x {
        y[index] = fct(x[index])
@@ -67,7 +67,7 @@ func (plot *Plot) AddFunc2d(name string, style string, x []float64, fct Func2d)
 //  style       :=> Style of the curve
 //  pointsX     :=> The x Value of the points to be plotted.  y = func(x) is plotted on the curve.
 // NOTE: Currently only float64 type is supported for this function
-func (plot *Plot) AddFunc3d(name string, style string, x []float64, y []float64, fct Func3d) error {
+func (plot *Plot) AddFunc3d(name string, style PointStyle, x []float64, y []float64, fct Func3d) error {
    if len(x) != len(y) {
        return &gnuplotError{fmt.Sprintf("The length of the x-axis array and y-axis array are not same.")}
    }
diff --git c/function_test.go w/function_test.go
index c605395..c9b4871 100644
--- c/function_test.go
+++ w/function_test.go
@@ -5,16 +5,17 @@ import (
 )

 func TestAddFunc3d(t *testing.T) {
+   args := PlotArgs{
+       Debug:   false,
+       Persist: false,
+   }
    dimensions := 3
-   persist := false
-   debug := false
-   plot, _ := NewPlot(dimensions, persist, debug)
+   plot, _ := NewPlot(dimensions, args)
    fct := func(x, y float64) float64 { return x - y }
-   groupName := "Stright Line"
-   style := "lines"
+   groupName := "Straight Line"
    pointsY := []float64{1, 2, 3}
    pointsX := []float64{1, 2, 3, 4, 5}
-   err := plot.AddFunc3d(groupName, style, pointsX, pointsY, fct)
+   err := plot.AddFunc3d(groupName, Lines, pointsX, pointsY, fct)
    if err == nil {
        t.Error("TestAddFunc3d raises error when the size of X and Y arrays are not equal.")
    }
diff --git c/glot.go w/glot.go
index a21e367..0dbe541 100644
--- c/glot.go
+++ w/glot.go
@@ -25,16 +25,93 @@ import (
 type Plot struct {
    proc       *plotterProcess
    debug      bool
-   plotcmd    string
+   plotcmd    PlotCommand
    nplots     int                    // number of currently active plots
    tmpfiles   tmpfilesDb             // A temporary file used for saving data
    dimensions int                    // dimensions of the plot
    PointGroup map[string]*PointGroup // A map between Curve name and curve type. This maps a name to a given curve in a plot. Only one curve with a given name exists in a plot.
-   format     string                 // The saving format of the plot. This could be PDF, PNG, JPEG and so on.
-   style      string                 // style of the plot
+   format     PlotFormat             // The saving format of the plot. This could be PDF, PNG, JPEG and so on.
+   style      PointStyle             // style of the plot
    title      string                 // The title of the plot.
 }

+const (
+   // Points is default style
+   Points = iota
+   // Bar is a Barplot type
+   Bar
+   BoxErrorBars
+   Circle
+   Dots
+   ErrorBars
+   FillSolid
+   // Histogram, i.e. fancy barplot
+   Histogram
+   // Lines is a lineplot
+   Lines
+   // LinesPoints is a lineplot with points
+   LinesPoints
+   Steps
+   InvalidPointStyle
+
+   // Pdf is a pdf output format
+   Pdf = iota
+   // Png is a png output format
+   Png
+)
+
+// PlotStyle ...
+type PointStyle uint
+
+// String is an implementation of the Stringer Interface
+// for PointStyle type.
+func (p PointStyle) String() string {
+   var m = map[PointStyle]string{
+       Bar:          "bar",
+       BoxErrorBars: "boxerrorbars",
+       Circle:       "circle",
+       Dots:         "dots",
+       ErrorBars:    "errorbars",
+       FillSolid:    "fill solid",
+       Histogram:    "histogram",
+       Lines:        "lines",
+       LinesPoints:  "linespoints",
+       Points:       "points",
+   }
+   if _, ok := m[p]; !ok {
+       return m[Points]
+   }
+   return m[p]
+}
+
+// PlotFormat ...
+type PlotFormat uint
+
+// String is an implementation of the Stringer Interface
+// for PlotFormat type.
+func (pf PlotFormat) String() string {
+   switch pf {
+   case Pdf:
+       return "pdf"
+   case Png:
+       return "png"
+   default:
+       return "unsupported"
+   }
+}
+
+// PlotCommand ...
+type PlotCommand string
+
+// PlotArgs ...
+type PlotArgs struct {
+   Debug   bool
+   Format  PlotFormat
+   Persist bool
+   Command PlotCommand
+   Style   PointStyle
+}
+
 // NewPlot Function makes a new plot with the specified dimensions.
 //
 // Usage
@@ -46,12 +123,22 @@ type Plot struct {
 //  dimensions  :=> refers to the dimensions of the plot.
 //  debug       :=> can be used by developers to check the actual commands sent to gnu plot.
 //  persist     :=> used to make the gnu plot window stay open.
-func NewPlot(dimensions int, persist, debug bool) (*Plot, error) {
-   p := &Plot{proc: nil, debug: debug, plotcmd: "plot",
-       nplots: 0, dimensions: dimensions, style: "points", format: "png"}
+func NewPlot(dimensions int, args PlotArgs) (*Plot, error) {
+   p := &Plot{
+       proc:  nil,
+       debug: args.Debug,
+       plotcmd: func() PlotCommand {
+           if args.Command == "" {
+               return "plot"
+           } else {
+               return args.Command
+           }
+       }(),
+       nplots: 0, dimensions: dimensions,
+       style: args.Style, format: args.Format}
    p.PointGroup = make(map[string]*PointGroup) // Adding a mapping between a curve name and a curve
    p.tmpfiles = make(tmpfilesDb)
-   proc, err := newPlotterProc(persist)
+   proc, err := newPlotterProc(args.Persist)
    if err != nil {
        return nil, err
    }
@@ -63,69 +150,151 @@ func NewPlot(dimensions int, persist, debug bool) (*Plot, error) {
    return p, nil
 }

-func (plot *Plot) plotX(PointGroup *PointGroup) error {
+func (plot *Plot) pointGroupSliceLen() int {
+   pgs, err := plot.pointGroupSlice()
+   if err != nil {
+       return 0
+   }
+   return len(pgs)
+}
+func (plot *Plot) pointGroupSlice() ([]*PointGroup, error) {
+   pgsl := []*PointGroup{}
+   if len(plot.PointGroup) == 0 {
+       return []*PointGroup{},
+           &gnuplotError{fmt.Sprintf("no pointgroups were found")}
+   }
+   for _, pg := range plot.PointGroup {
+       pgsl = append(pgsl, pg)
+   }
+   return pgsl, nil
+}
+
+func (plot *Plot) plotHistogram(PointGroup *PointGroup) error {
+   x := PointGroup.castedData.([][]float64)[0]
+   // y := PointGroup.castedData.([][]float64)[1]
+   npoints := len(x)
+   // npoints := min(len(x), len(y))
+
    f, err := ioutil.TempFile(os.TempDir(), gGnuplotPrefix)
    if err != nil {
        return err
    }
    fname := f.Name()
    plot.tmpfiles[fname] = f
-   for _, d := range PointGroup.castedData.([]float64) {
-       f.WriteString(fmt.Sprintf("%v\n", d))
+
+   for i := 0; i < npoints; i++ {
+       f.WriteString(fmt.Sprintf("%v\n", x[i]))
    }
+
    f.Close()
    cmd := plot.plotcmd
    if plot.nplots > 0 {
        cmd = plotCommand
    }
-   if PointGroup.style == "" {
-       PointGroup.style = defaultStyle
+
+   PointGroup.style = Histogram
+
+   var line string
+   if PointGroup.name == "" {
+       line = fmt.Sprintf("%s \"%s\" with %s", cmd, fname, plot.style)
+   } else {
+       line = fmt.Sprintf("%s \"%s\" title \"%s\" with %s",
+           cmd, fname, PointGroup.name, PointGroup.style)
+   }
+   plot.nplots++
+   return plot.Cmd(line)
+}
+func (plot *Plot) plotX(PointGroup *PointGroup) error {
+   f, err := ioutil.TempFile(os.TempDir(), gGnuplotPrefix)
+   if err != nil {
+       return err
+   }
+   defer f.Close()
+
+   fname := f.Name()
+   plot.tmpfiles[fname] = f
+   for _, d := range PointGroup.castedData.([]float64) {
+       f.WriteString(fmt.Sprintf("%v\n", d))
+   }
+
+   var cmd PlotCommand
+   if plot.nplots > 0 {
+       cmd = ""
+   } else {
+       cmd = plot.plotcmd
+   }
+
+   if PointGroup.style < 0 || PointGroup.style >= InvalidPointStyle {
+       PointGroup.style = Points
    }
    var line string
    if PointGroup.name == "" {
+
        line = fmt.Sprintf("%s \"%s\" with %s", cmd, fname, PointGroup.style)
    } else {
        line = fmt.Sprintf("%s \"%s\" title \"%s\" with %s",
            cmd, fname, PointGroup.name, PointGroup.style)
    }
+   if plot.nplots > 0 {
+       plot.plotcmd = plot.plotcmd + ", " + PlotCommand(line)
+   } else {
+       plot.plotcmd = PlotCommand(line)
+   }
    plot.nplots++
-   return plot.Cmd(line)
+   // return plot.Cmd(line)
+   return nil
 }

 func (plot *Plot) plotXY(PointGroup *PointGroup) error {
    x := PointGroup.castedData.([][]float64)[0]
    y := PointGroup.castedData.([][]float64)[1]
    npoints := min(len(x), len(y))
-
+   pointString := ""
    f, err := ioutil.TempFile(os.TempDir(), gGnuplotPrefix)
    if err != nil {
        return err
    }
+   defer f.Close()
+
    fname := f.Name()
    plot.tmpfiles[fname] = f

    for i := 0; i < npoints; i++ {
-       f.WriteString(fmt.Sprintf("%v %v\n", x[i], y[i]))
+       pointString += fmt.Sprintf("%v %v\n", x[i], y[i])
+       // f.WriteString(fmt.Sprintf("%v %v\n", x[i], y[i]))
+       if i%10000 == 0 { // flush every 10,000 lines
+           f.WriteString(pointString)
+           pointString = ""
+       }
    }
+   f.WriteString(pointString)

-   f.Close()
-   cmd := plot.plotcmd
+   var cmd PlotCommand
    if plot.nplots > 0 {
-       cmd = plotCommand
+       cmd = ""
+   } else {
+       cmd = plot.plotcmd
    }

-   if PointGroup.style == "" {
-       PointGroup.style = "points"
-   }
+   // if plot.nplots > 0 {
+   //  cmd = plotCommand
+   // }
    var line string
    if PointGroup.name == "" {
-       line = fmt.Sprintf("%s \"%s\" with %s", cmd, fname, PointGroup.style)
+       line = fmt.Sprintf("%s \"%s\" with %s", cmd, fname, PointGroup.style.String())
    } else {
        line = fmt.Sprintf("%s \"%s\" title \"%s\" with %s",
            cmd, fname, PointGroup.name, PointGroup.style)
    }
+   if plot.nplots > 0 {
+       plot.plotcmd = plot.plotcmd + ", " + PlotCommand(line)
+   } else {
+       plot.plotcmd = PlotCommand(line)
+   }
    plot.nplots++
-   return plot.Cmd(line)
+
+   // return plot.Cmd(line)
+   return nil
 }

 func (plot *Plot) plotXYZ(points *PointGroup) error {
@@ -138,6 +307,7 @@ func (plot *Plot) plotXYZ(points *PointGroup) error {
    if err != nil {
        return err
    }
+   defer f.Close()
    fname := f.Name()
    plot.tmpfiles[fname] = f

@@ -161,3 +331,27 @@ func (plot *Plot) plotXYZ(points *PointGroup) error {
    plot.nplots++
    return plot.Cmd(line)
 }
+
+// Execute triggers generation of actual figure
+func (plot *Plot) Execute() error {
+   pgs, err := plot.pointGroupSlice()
+   if len(pgs) == 0 {
+       return err
+   }
+   for _, pg := range pgs {
+       switch pg.dimensions {
+       case 1:
+           plot.plotX(pg)
+       case 2:
+           fmt.Printf("%v\n", pg)
+           plot.plotXY(pg)
+       case 3:
+           plot.plotXYZ(pg)
+       default:
+           return &gnuplotError{
+               fmt.Sprintf("unexpected number of dimensions in pointgroup"),
+           }
+       }
+   }
+   return plot.Cmd(string(plot.plotcmd))
+}
diff --git c/glot_test.go w/glot_test.go
index a93e9be..a912ddc 100644
--- c/glot_test.go
+++ w/glot_test.go
@@ -3,9 +3,11 @@ package glot
 import "testing"

 func TestNewPlot(t *testing.T) {
-   persist := false
-   debug := true
-   _, err := NewPlot(0, persist, debug)
+   args := PlotArgs{
+       Debug:   false,
+       Persist: false,
+   }
+   _, err := NewPlot(0, args)
    if err == nil {
        t.Error("Expected error when making a 0 dimensional plot.")
    }
diff --git c/pointgroup.go w/pointgroup.go
index dce5d91..fa0fe96 100644
--- c/pointgroup.go
+++ w/pointgroup.go
@@ -1,19 +1,22 @@
 package glot

-import (
-   "fmt"
-)
+import "fmt"

-// A PointGroup refers to a set of points that need to plotted.
+// A PointGroup refers to a set of points that need to be plotted.
 // It could either be a set of points or a function of co-ordinates.
 // For Example z = Function(x,y)(3 Dimensional) or  y = Function(x) (2-Dimensional)
 type PointGroup struct {
    name       string      // Name of the curve
    dimensions int         // dimensions of the curve
-   style      string      // current plotting style
+   style      PointStyle  // current plotting style
    data       interface{} // Data inside the curve in any integer/float format
    castedData interface{} // The data inside the curve typecasted to float64
    set        bool        //
+   index      int         // Relative index of pointgroup in the plot
+}
+
+func (pg *PointGroup) setIndex(idx int) {
+   pg.index = idx
 }

 // AddPointGroup function adds a group of points to a plot.
@@ -26,39 +29,46 @@ type PointGroup struct {
 //  plot.AddPointGroup("Sample1", "points", []int32{51, 8, 4, 11})
 //  plot.AddPointGroup("Sample2", "points", []int32{1, 2, 4, 11})
 //  plot.SavePlot("1.png")
-func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (err error) {
+func (plot *Plot) AddPointGroup(name string, style PointStyle, data interface{}) (err error) {
    _, exists := plot.PointGroup[name]
    if exists {
        return &gnuplotError{fmt.Sprintf("A PointGroup with the name %s  already exists, please use another name of the curve or remove this curve before using another one with the same name.", name)}
    }

-   curve := &PointGroup{name: name, dimensions: plot.dimensions, data: data, set: true}
-   allowed := []string{
-       "lines", "points", "linepoints",
-       "impulses", "dots", "bar",
-       "steps", "fill solid", "histogram", "circle",
-       "errorbars", "boxerrorbars",
-       "boxes", "lp"}
-   curve.style = defaultStyle
+   curve := &PointGroup{name: name, dimensions: plot.dimensions, data: data, set: true, style: style}
+
+   // We want to make sure that pointGroups are added to figure in a
+   // consistent and repeatable manner. Because we are using maps, the
+   // order is inherently unpredictable and using an index for each group
+   // allows us to have reproducible plots.
+   curve.setIndex(plot.pointGroupSliceLen())
    discovered := 0
-   for _, s := range allowed {
-       if s == style {
-           curve.style = style
-           err = nil
+   // If the style value is an empty string and there's only a single
+   // dimension, assume histogram by default.
+
+   if style < 0 || style >= InvalidPointStyle {
+       switch plot.dimensions {
+       case 0:
+           return &gnuplotError{
+               fmt.Sprintf("Wrong number of dimensions in this plot."),
+           }
+       case 1:
+           curve.style = Histogram
+           discovered = 1
+       case 2, 3:
+           curve.style = Points
            discovered = 1
        }
+   } else {
+       discovered++
    }
+
    switch data.(type) {
    case [][]float64:
        if plot.dimensions != len(data.([][]float64)) {
            return &gnuplotError{fmt.Sprintf("The dimensions of this PointGroup are not compatible with the dimensions of the plot.\nIf you want to make a 2-d curve you must specify a 2-d plot.")}
        }
        curve.castedData = data.([][]float64)
-       if plot.dimensions == 2 {
-           plot.plotXY(curve)
-       } else {
-           plot.plotXYZ(curve)
-       }
        plot.PointGroup[name] = curve

    case [][]float32:
@@ -74,11 +84,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            }
        }
        curve.castedData = typeCasteSlice
-       if plot.dimensions == 2 {
-           plot.plotXY(curve)
-       } else {
-           plot.plotXYZ(curve)
-       }
        plot.PointGroup[name] = curve

    case [][]int:
@@ -97,11 +102,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            }
        }
        curve.castedData = typeCasteSlice
-       if plot.dimensions == 2 {
-           plot.plotXY(curve)
-       } else {
-           plot.plotXYZ(curve)
-       }
        plot.PointGroup[name] = curve

    case [][]int8:
@@ -120,12 +120,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            }
        }
        curve.castedData = typeCasteSlice
-
-       if plot.dimensions == 2 {
-           plot.plotXY(curve)
-       } else {
-           plot.plotXYZ(curve)
-       }
        plot.PointGroup[name] = curve

    case [][]int16:
@@ -144,12 +138,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            }
        }
        curve.castedData = typeCasteSlice
-
-       if plot.dimensions == 2 {
-           plot.plotXY(curve)
-       } else {
-           plot.plotXYZ(curve)
-       }
        plot.PointGroup[name] = curve

    case [][]int32:
@@ -168,12 +156,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            }
        }
        curve.castedData = typeCasteSlice
-
-       if plot.dimensions == 2 {
-           plot.plotXY(curve)
-       } else {
-           plot.plotXYZ(curve)
-       }
        plot.PointGroup[name] = curve

    case [][]int64:
@@ -192,17 +174,10 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            }
        }
        curve.castedData = typeCasteSlice
-
-       if plot.dimensions == 2 {
-           plot.plotXY(curve)
-       } else {
-           plot.plotXYZ(curve)
-       }
        plot.PointGroup[name] = curve

    case []float64:
        curve.castedData = data.([]float64)
-       plot.plotX(curve)
        plot.PointGroup[name] = curve
    case []float32:
        originalSlice := data.([]float32)
@@ -211,7 +186,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            typeCasteSlice[i] = float64(originalSlice[i])
        }
        curve.castedData = typeCasteSlice
-       plot.plotX(curve)
        plot.PointGroup[name] = curve
    case []int:
        originalSlice := data.([]int)
@@ -220,7 +194,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            typeCasteSlice[i] = float64(originalSlice[i])
        }
        curve.castedData = typeCasteSlice
-       plot.plotX(curve)
        plot.PointGroup[name] = curve
    case []int8:
        originalSlice := data.([]int8)
@@ -229,7 +202,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            typeCasteSlice[i] = float64(originalSlice[i])
        }
        curve.castedData = typeCasteSlice
-       plot.plotX(curve)
        plot.PointGroup[name] = curve
    case []int16:
        originalSlice := data.([]int16)
@@ -238,7 +210,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            typeCasteSlice[i] = float64(originalSlice[i])
        }
        curve.castedData = typeCasteSlice
-       plot.plotX(curve)
        plot.PointGroup[name] = curve
    case []int32:
        originalSlice := data.([]int32)
@@ -247,7 +218,6 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            typeCasteSlice[i] = float64(originalSlice[i])
        }
        curve.castedData = typeCasteSlice
-       plot.plotX(curve)
        plot.PointGroup[name] = curve
    case []int64:
        originalSlice := data.([]int64)
@@ -256,14 +226,12 @@ func (plot *Plot) AddPointGroup(name string, style string, data interface{}) (er
            typeCasteSlice[i] = float64(originalSlice[i])
        }
        curve.castedData = typeCasteSlice
-       plot.plotX(curve)
        plot.PointGroup[name] = curve
    default:
-       return &gnuplotError{fmt.Sprintf("invalid number of dims ")}
-
+       return &gnuplotError{fmt.Sprintf("invalid number of dimensions")}
    }
    if discovered == 0 {
-       fmt.Printf("** style '%v' not in allowed list %v\n", style, allowed)
+       fmt.Printf("** style '%s' not supported ", style.String())
        fmt.Printf("** default to 'points'\n")
        err = &gnuplotError{fmt.Sprintf("invalid style '%s'", style)}
    }
@@ -300,7 +268,7 @@ func (plot *Plot) RemovePointGroup(name string) {
 //  plot, _ := glot.NewPlot(dimensions, persist, debug)
 //  plot.AddPointGroup("Sample1", "points", []int32{51, 8, 4, 11})
 //  plot.ResetPointGroupStyle("Sample1", "points")
-func (plot *Plot) ResetPointGroupStyle(name string, style string) (err error) {
+func (plot *Plot) ResetPointGroupStyle(name string, style PointStyle) (err error) {
    pointGroup, exists := plot.PointGroup[name]
    if !exists {
        return &gnuplotError{fmt.Sprintf("A curve with name %s does not exist.", name)}
diff --git c/pointgroup_test.go w/pointgroup_test.go
index 63f8f4c..f5a934e 100644
--- c/pointgroup_test.go
+++ w/pointgroup_test.go
@@ -1,15 +1,228 @@
 package glot

-import "testing"
+import (
+   "fmt"
+   "testing"
+)
+
+func squareInt(n int) int {
+   return n * n
+}
+func cubeInt(n int) int {
+   return n * squareInt(n)
+}
+
+func squareInt16(n int16) int16 {
+   return n * n
+}
+func cubeInt16(n int16) int16 {
+   return n * squareInt16(n)
+}

 func TestResetPointGroupStyle(t *testing.T) {
+   args := PlotArgs{
+       Debug:   false,
+       Persist: false,
+   }
    dimensions := 2
-   persist := false
-   debug := false
-   plot, _ := NewPlot(dimensions, persist, debug)
-   plot.AddPointGroup("Sample1", "points", []int32{51, 8, 4, 11})
-   err := plot.ResetPointGroupStyle("Sam", "lines")
+   plot, _ := NewPlot(dimensions, args)
+   plot.AddPointGroup("Sample1", Points, []int32{51, 8, 4, 11})
+   err := plot.ResetPointGroupStyle("Sam", Lines)
    if err == nil {
        t.Error("The specified pointgroup to be reset does not exist")
    }
 }
+
+func TestTwoPointGroups(t *testing.T) {
+   args := PlotArgs{
+       Debug:   true,
+       Persist: true,
+       Format:  Pdf,
+       Style:   Points,
+   }
+
+   plot, _ := NewPlot(1, args)
+   plot.AddPointGroup("TestGroup_1", Points, []float64{
+       -0.512695,
+       0.591778,
+       -0.0939544,
+       -0.510766,
+       -0.859442,
+       0.0340482,
+       0.887461,
+       0.277168,
+       -0.998753,
+       0.356656,
+   })
+   plot.AddPointGroup("TestGroup_2", Points, []float64{
+       0.712863,
+       0.975935,
+       0.875864,
+       0.737082,
+       -0.185717,
+       -0.936551,
+       0.779397,
+       0.916793,
+       0.622004,
+       -0.0860084,
+   })
+   fmt.Printf("pg: %v\n", plot.PointGroup)
+   plot.Execute()
+}
+
+func TestThreePointGroupsFloat64(t *testing.T) {
+   args := PlotArgs{
+       Debug:   true,
+       Persist: true,
+       Format:  Pdf,
+       Style:   Points,
+   }
+
+   plot, _ := NewPlot(1, args)
+   plot.AddPointGroup("TestGroup_1", Points, []float64{
+       -0.512695,
+       0.591778,
+       -0.0939544,
+       -0.510766,
+       -0.859442,
+       0.0340482,
+       0.887461,
+       0.277168,
+       -0.998753,
+       0.356656,
+   })
+   plot.AddPointGroup("TestGroup_2", Points, []float64{
+       0.712863,
+       0.975935,
+       0.875864,
+       0.737082,
+       -0.185717,
+       -0.936551,
+       0.779397,
+       0.916793,
+       0.622004,
+       -0.0860084,
+   })
+   plot.AddPointGroup("TestGroup_3", LinesPoints, []float64{
+       0.28927,
+       -0.945002,
+       -0.904681,
+       0.924912,
+       0.990415,
+       0.326935,
+       -0.927919,
+       0.994446,
+       0.270194,
+       -0.0378568,
+   })
+   fmt.Printf("pg: %v\n", plot.PointGroup)
+   plot.Execute()
+}
+
+func TestThreePointGroupsFloatMixed(t *testing.T) {
+   args := PlotArgs{
+       Debug:   true,
+       Persist: true,
+       Format:  Pdf,
+       Style:   Points,
+   }
+
+   plot, _ := NewPlot(1, args)
+   plot.AddPointGroup("TestGroup^1", Points, []float32{
+       -0.512695,
+       0.591778,
+       -0.0939544,
+       -0.510766,
+       -0.859442,
+       0.0340482,
+       0.887461,
+       0.277168,
+       -0.998753,
+       0.356656,
+   })
+   plot.AddPointGroup("TestGroup^2", Points, []float64{
+       0.712863,
+       0.975935,
+       0.875864,
+       0.737082,
+       -0.185717,
+       -0.936551,
+       0.779397,
+       0.916793,
+       0.622004,
+       -0.0860084,
+   })
+   plot.AddPointGroup("TestGroup^3", LinesPoints, []float32{
+       0.28927,
+       -0.945002,
+       -0.904681,
+       0.924912,
+       0.990415,
+       0.326935,
+       -0.927919,
+       0.994446,
+       0.270194,
+       -0.0378568,
+   })
+   fmt.Printf("%v\n", plot.PointGroup["TestGroup^1"])
+   fmt.Printf("%v\n", plot.PointGroup["TestGroup^2"])
+   fmt.Printf("%v\n", plot.PointGroup["TestGroup^3"])
+   plot.Execute()
+}
+
+func TestOnePointGroupInt8(t *testing.T) {
+   args := PlotArgs{
+       Debug:   true,
+       Persist: true,
+       Format:  Pdf,
+       Style:   Points,
+   }
+
+   plot, _ := NewPlot(1, args)
+   plot.AddPointGroup("TestGroup_1", Points, []int8{
+       0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
+       -9, -8, -7, -6, -5, -4, -3, -2, -1, 0,
+   })
+   plot.Execute()
+}
+func TestOnePointGroupInt16(t *testing.T) {
+   args := PlotArgs{
+       Debug:   true,
+       Persist: true,
+       Format:  Pdf,
+       Style:   Points,
+   }
+
+   plot, _ := NewPlot(1, args)
+   plot.AddPointGroup("TestGroup_1", Points, []int16{
+       1, 2, 8, 16, 32, 64, 128, 256, 512, 1024,
+   })
+   plot.Execute()
+}
+
+func TestTwoPointGroupsInt16(t *testing.T) {
+   args := PlotArgs{
+       Debug:   true,
+       Persist: true,
+       Format:  Pdf,
+       Style:   Points,
+   }
+
+   plot, _ := NewPlot(1, args)
+   plot.AddPointGroup("PowerOfTwo^1", Points, []int16{
+       1, 2, 8, 16, 32, 64, 128, 256, 512, 1024,
+   })
+   plot.AddPointGroup("Cubed^2", Points, []int16{
+       0,
+       1,
+       cubeInt16(2),
+       cubeInt16(3),
+       cubeInt16(4),
+       cubeInt16(5),
+       cubeInt16(6),
+       cubeInt16(7),
+       cubeInt16(8),
+       cubeInt16(9),
+   })
+   plot.Execute()
+}

[arafatkatze]

@szaydel
This looks really amazing.
Please do send a PR and I will make some comments/suggestions and will eventually merge it.
Thanks a lot.

[szaydel]

@Arafatk, Let me clean-up a bit, add some tests, and implement a few things I wanted to implement and I will send a PR. Thanks for considering it!

Cheers.

[szaydel]

Just wanted to give an update. I am still working on a few improvements before I do a PR. I wanted to propose a model where there are distinct types representing plot styles, i.e. there's a type for histograms, a type for points, etc., and each such type encodes all necessary information, as well as allows for some degree of customization. The type is then tied to a PointGroup, and multiple PointGroups are tied to a plot area or canvas. I am thinking of this as a more modular way to structure things, and a bit more object oriented.

Basic goal is to define a Geom, a Geometric Object struct, like in this example we have a HistogramGeom which includes a style struct, and this struct satisfies a PlotStyler Interface, which generalizes configuration of the different Geoms. The goal is to have a common interface for configuring different plotting styles, which depending on the style may require using the set style command or not, etc.

// HistogramStyle describes stylistic elements that may be attributed to histogram
type HistogramStyle struct {
    Empty  bool
    Solid  bool
    Border bool
}

// HistogramGeom --
type HistogramGeom struct {
    style HistogramStyle
}

[arafatkatze]

@szaydel Really sorry for the late reply. This looks really good and modular and will certainly help a lot in the long term when we try to extend the library functionalities.
Please go ahead with the pull request or maybe keep it a work in progress, the very first pull request doesn't have to be directly merged but atleast I can take a look at it and make comments if needed.

[szaydel]

Thanks @Arafatk. I will get this stuff prepared in the next few days, or over weekend and do a PR. If you want to start a Dev branch of some sort, I can do a PR against it instead of Master.