/*
	STPlot v2.6
	C++ API for plotting with gnuplot.

	Created by Stilianos Louca on 2008.11.25
	Last modified on 2014.03.06
	
	Tested using GCC 4.2.1 and gnuplot 4.6.5 on Mac OS 10.6.8.
 
	Namespace ST
 */

#ifndef STPLOT 
#define STPLOT 

#define STPLOT_VERSION 2.6


#include <iostream>
#include <fstream>
#include <vector>
#include <set>
#include <cmath>
#include <string>
#include <string.h>
#include <limits>
#include <iomanip>
#include <stdio.h>
#include <sys/stat.h>
#include "STPipe.h"
#include "STColor.h"

#include "STPlotDefaults.h"

using namespace std;

namespace ST{

extern string STPLOT_GNUPLOT_PATH; // modify this to set the gnuplot program path globally, or leave empty for automatic detection




#pragma mark -
#pragma mark Typedefs
#pragma mark -

typedef enum _PlotType{
	PlotTypeNone,							//No plot ('NULL')
	
	PlotType1DPoints,						//1 data column:  x1
	PlotType1DColoredPoints,				//4 data columns: x1, r,g,b. Plots points and sets color by rgb-value \in [0,1]^3.
	PlotType1DVectors,						//2 data columns: x1, v1
	PlotType1DColoredVectors,				//5 data columns: x1, v1, r,g,b. Plots vectors and sets color by rgb-value \in [0,1]^3.
	
	PlotType2DPoints,						//2 data columns: x1,x2
	PlotType2DColoredPoints,				//5 data columns: x1,x2,r,g,b. Plots points and sets color by rgb-value \in [0,1]^3.
	PlotType2DVectors,						//4 data columns: x1,x2,v1,v2
	PlotType2DColoredVectors,				//7 data columns: x1,x2,v1,v2,r,g,b. Plots vectors and sets color by rgb-value \in [0,1]^3.
	PlotType2DVariableSizedSpheres,			//3 data columns: x1,x2,radius. Plots spheres with variable radius (given in x-axis coordinates).
	PlotType2DColoredVariableSizedSpheres,	//6 data columns: x1,x2,radius,r,g,b. Plots (r,g,b)-colored spheres with variable radius (in x-axis coordinates).
	
	PlotType2DCurve,						//2 data columns: x1,x2
	PlotType2DCurvePoints,					//2 data columns: x1,x2
	PlotType2DGraphLinear,					//2 data columns: x,f(x)
	PlotType2DGraphLinearPoints,			//2 data columns: x,f(x)
	PlotType2DGraphSplines,					//2 data columns: x,f(x). x-values need not be ordered.
	PlotType2DGraphSplinesPoints,			//2 data columns: x,f(x). x-values need not be ordered.
	PlotType2DFilledCurve,					//3 data columnns: x,y
	PlotType2DFilledCurves,					//3 data columnns: x,y1,y2.
	PlotType2DAnalytic,						//No data needed. Plots function f(x) given analytically
	
	PlotType3DPoints,						//3 data columns: x1,x2,x3
	PlotType3DColoredPoints,				//6 data columns: x1,x2,x3,r,g,b. Plots points and sets color by rgb-value \in [0,1]^3.
	PlotType3DVectors,						//6 data columns: x1,x2,x3,v1,v2,v3
	PlotType3DColoredVectors,				//9 data columns: x1,x2,x3,v1,v2,v3,r,g,b. Plots vectors and sets color by rgb-value \in [0,1]^3.
	
	PlotType3DCurve,						//3 data columns: x1,x2,x3
	PlotType3DCurvePoints,					//3 data columns: x1,x2,x3
	
	PlotType1DHistogram,					//2 data columns: interval-names, value
	PlotType1DEmpiricalDensity,				//2 data columns: interval start, value
	
	PlotType2DScatteredValueMap,			//3 data columns: x1,x2,value (scattered data). Value -> color map is determined using a color palette.
	PlotType2DGridValueMap,					//data matrix: matrix entry corresponds to value on grid node (not grid box!). Value -> color map is determined using a color palette.
	PlotType2DScannedValueMap,				//3 data columns: x1,x2,value. Data needs to be in form of equally-sized row "chuncs", separated by one empty line. Each such chunk corresponds to one "sampling-line" of the surface. Value -> color map is determined using a color palette.
	
	PlotType2DColorImage,					//data matrix: matrix entry corresponds to color of box. Color should be given as integer (colorNumber) within [0, 256^3 - 1]. See the color conversion functions RGB2ColorNumber() & colorNumber2RGB() for more details.
	PlotType2DValueImage, 					//data matrix: matrix entry corresponds to value of box. Value -> color map is determined using a color palette.
	
	PlotType3DScatteredSurface,				//3 data columns: x1,x2,f(x1,x2) (scattered data)
	PlotType3DGridSurface,					//data matrix: matrix entry corresponds to surface height at that position
	PlotType3DScannedSurface,				//3 data columns: x1,x2,f(x1,x2). Data needs to be in form of equally-sized row "chuncs", separated by one empty line. Each such chunk corresponds to one "sampling-line" of the surface.

	PlotType3DValuedScannedSurface			//4 data columns: x1,x2,f(x1,x2),value. Data needs to be in form of equally-sized row "chuncs", separated by one empty line. Each such chunk corresponds to one "sampling-line" of the surface. Value -> color map is determined using a color palette.

} PlotType;

typedef enum _PlotError{
	PlotErrorNone,
	PlotErrorInvalidSyntax,
	PlotErrorException,
	PlotErrorFileReadError,
	PlotErrorFileWriteError,
	PlotErrorFileNotFoundError,
	PlotErrorPermissionError,
	PlotErrorEOF,
	PlotErrorPlotterNotFound,
	PlotErrorUnknownError,
	PlotErrorNothingToBeDone,
	PlotErrorParameterError,
	PlotErrorIncompatiblePlots
} PlotError;


typedef enum _GridColoringType{
	GridColoringTypeMean,						//Box value(color or height) is mean of adjacent corners
	GridColoringTypeMax,						//Box value(color or height) is max of adjacent corners
	GridColoringTypeMin,						//Box value(color or height) is min of adjacent corners
	GridColoringTypeLL,							//Box value(color or height) is lower-left adjacent corner
	GridColoringTypeUR							//Box value(color or height) is upper-right adjacent corner
} GridColoringType;


typedef enum _GridSmoothingType{
	GridSmoothingTypeEuclidean,
	GridSmoothingTypeGauss,
	GridSmoothingTypeBox
} GridSmoothingType;


typedef enum _PlotOutputType{
	PlotOutputTypeTerminal,
	PlotOutputTypeFilePDF,
	PlotOutputTypeFileEPS,
	PlotOutputTypeFileSVG
} PlotOutputType;


typedef enum _VectorHeadStyle{
	VectorHeadStyleFilledTriangle,
	VectorHeadStyleFilledArrow,
	VectorHeadStyleEmptyTriangle,
	VectorHeadStyleEmptyArrow,
	VectorHeadStyleNone		// don't draw any arrow head. Can be used to draw line segments.
} VectorHeadStyle;


typedef enum _FilledCurveStyle{
	FilledCurveStyleAbove,
	FilledCurveStyleBelow,
	FilledCurveStyleAll
} FilledCurveStyle;


typedef enum _IntegrationMethod{
	IntegrationMethodForwardEuler,
	IntegrationMethodClassicalRungeKutta
} IntegrationMethod;


typedef enum _ContourPlacement{
	ContourPlacementBottom,
	ContourPlacementSurface,
	ContourPlacementBottomSurface
} ContourPlacement;


typedef enum _HClusterMetric{
	HClusterMetricEuclidean,
	HClusterMetricManhattan,
	HClusterMetricMaximum
} HClusterMetric;


typedef enum _HClusterOrdering{
	HClusterOrderingArbitrary,
	HClusterOrderingCentroid,
	HClusterOrderingAscending,
	HClusterOrderingByDistance
} HClusterOrdering;



typedef enum _HClusterLinkage{
	HClusterLinkageSingle,		//minimum linkage
	HClusterLinkageComplete,	//maximum linkage
	HClusterLinkageUPGMA		//average linkage
} HClusterLinkage;


typedef enum _HClusterWhat{
	HClusterNone,
	HClusterRows,
	HClusterColumns,
	HClusterRowsAndColumns,
	HClusterRowsAndLockColumns2Rows,
	HClusterColumnsAndLockRows2Columns
} HClusterWhat;



typedef enum _LabelAlignment{
	LabelAlignmentLeft,
	LabelAlignmentCenter,
	LabelAlignmentRight
} LabelAlignment;



typedef enum {
	SortNone,
	SortAscending,
	SortDescending
} SortHow;


typedef enum {
	PlotColorTypeAuto,
	PlotColorTypeAsColor,
	PlotColorTypeAsValue
} 
PlotColorType;
	





#pragma mark -
#pragma mark Preliminary class definitions
#pragma mark -



//Public classes
class Contours;
class Range;
class MultiRange;
class MultiLabel; 	// for axis labeling
class PlotSource;
class Plot;
class MultiPlot;
class Label;		// for custom labels within the plot


//Private Classes
class GnuplotPipe;



#pragma mark -
#pragma mark Class definitions
#pragma mark -


class GnuplotPipe : private STPipe{
private:
	string 	gnuplotPath;
	FILE 	*scriptStream;
	string 	scriptPath;
	bool	_foundGnuplot;
	bool	tryToFindGnuplot(const string &firstGuess="");
	
public:
	//constructor
	GnuplotPipe() : STPipe(), scriptStream(NULL) {};

	//copy constructor: this will actually initiate a new pipe to gnuplot but with similar settings
	GnuplotPipe(const GnuplotPipe &original);

	//assignment operator: this will actually initiate a new pipe to gnuplot but with similar settings
	GnuplotPipe &operator=(const GnuplotPipe &original);
		
	void open();
	void open(string gnuplotPath);
	using STPipe::pipeIsReady;
	using STPipe::setLogStream;
	virtual bool write(const char *format, ...);
	virtual bool write(const string &message);
	
	void transformToScript();
	void transformToPipe();
	bool executeScript();
	bool isInScriptMode() const;
	
	bool foundGnuplot() const{ return _foundGnuplot; }
	string currentGnuplotPath() const{ return gnuplotPath; }
	string currentGnuplotVersion() const;
};




//Class for defining a 1-dimensional plot-range
//Unsetting a bound (min or max) sets it to 'auto'
class Range{
friend class MultiRange;
friend class Plot;
private:
	bool 	rangeMinAuto, rangeMaxAuto;
	double 	rangeMin, rangeMax;
	
	string gnuplotExpression() const;
	void mergeWithRange(Range range);
	
public:
	//constructors
	Range();
	Range(double rangeMin, double rangeMax);
	
	void unsetRangeMin(){ rangeMinAuto = true; }
	void unsetRangeMax(){ rangeMaxAuto = true; }
	void setRangeMin(double value){ rangeMin = value; rangeMinAuto = false; }
	void setRangeMax(double value){ rangeMax = value; rangeMaxAuto = false; }
	
	// get suggestions for a 'nice' plot range depending on the data
	static Range getNicePlotRange(const vector<double> &values, long start, long end, bool zeroIsReference, bool logarithmic, double epsilon);
	static Range getNicePlotRange(double minValue, double maxValue, bool zeroIsReference, bool logarithmic, double epsilon);

	
	void scaleRangeByFactor(double factor);
	
};



//Class for defining a multidimensional (2D or 3D) plot-range.
//Dimension is determined via the constructor used.
class MultiRange{
friend class Plot;
private:
	unsigned int 	dim;
	
	void mergeWithRange(MultiRange range);
	string gnuplotExpression() const;
	string gnuplotCommand() const;
	
public:
	Range 		xRange, yRange, zRange;
	
	//constructors
	MultiRange(); //dim = 2, ranges set to auto
	MultiRange(unsigned int dim); //dim \in {2,3}, ranges set to auto
	MultiRange(Range xRange, Range yRange); //dim = 2
	MultiRange(Range xRange, Range yRange, Range zRange); //dim = 3
	MultiRange(double xRangeMin, double xRangeMax, double yRangeMin, double yRangeMax); //dim = 2
	MultiRange(double xRangeMin, double xRangeMax, double yRangeMin, double yRangeMax, double zRangeMin, double zRangeMax); //dim = 3

	void scaleRangeByFactor(double factor);
	
};





//Class for defining a multidimensional (2D or 3D) axis-label.
//Dimension is determined via the constructor used.
class MultiLabel{
friend class Plot;
private:
	string 			_xLabel, _yLabel, _zLabel;
	unsigned int 	_dim;
	
	string gnuplotCommand(bool interpretSymbols, bool escapeUnderscores) const;
	
public:
	//constructors
	MultiLabel(); //dim = 2. labels set to "x" and "y"
	MultiLabel(string xLabel, string yLabel); //dim = 2
	MultiLabel(string xLabel, string yLabel, string zLabel); //dim = 3
};




//Single class for defining contouring behaviour of plots
class Contours{
friend class	Plot;
private:
	bool drawContours;
	bool incremental;
	bool fixedCount;
	bool automatic;
	double start, step, end;
	unsigned int count;
	vector<double> levels;
	
	static string contourPlacement2string(ContourPlacement placement);
	string gnuplotCommand() const; 
	
public:
	//constructors
	Contours(bool enable = false);
	Contours(const vector<double> &levels);
	Contours(double singleLevel);
	Contours(unsigned int count);
	Contours(double start, double step, unsigned int count);
	Contours(double start, double step, double end);
	
	ContourPlacement placement;
	bool individualContours;
};




//Class for defining tics on a single axis
class Tics{
friend class	Plot;
private:
	vector<string> 	customTicLabels;
	vector<double> 	customTicValues;
	vector<bool>	customTicWithCustomLabel;
	bool			automatic;
	double			start, step, end;
	bool			startSet, stepSet, endSet;
	double 			rotation;
	
	void add(unsigned int ticCount, va_list values);
	string gnuplotCommand(string ticsName, bool interpretSymbols, bool escapeUnderscores) const;
	string gnuplotCommand(string ticsName, bool interpretSymbols, bool escapeUnderscores, double rescale) const;
	
public:
	Tics();								//sets tics to automatic with no custom tics.
	Tics(unsigned int ticCount,...); 	//following ticCount arguments should be of type double, corresponding to values of custom tics.

	void add(const string &label, double value);
	void add(double value);
	void add(unsigned int count, ...);
	void clearCustomTics();
	void enableAutomaticTics();
	void enableAutomaticTics(double step);
	void enableAutomaticTics(double start, double step);
	void enableAutomaticTics(double start, double step, double end);
	void disableAutomaticTics();
	void setToRegularIntegerValues(double rangeMin, double rangeMax); 	// will generate a regular tics grid on integer values within the given range. Guaranteed to include ceil(rangeMin).
	void setRotation(double angle);
};



class Label{
friend class Plot;
private:
	string gnuplotCommand(long tag, bool interpretSymbols, int dim, const string &font, bool escapeUnderscores) const;
public:
	string 			text;
	bool 			wrtCoordinates;
	double 			x,y,z;
	LabelAlignment 	alignment;
	double			fontSize;	// set to negative for default
	
	Label();
	Label(const string &text, bool wrtCoordinates, double x, double y, LabelAlignment alignment);
	Label(const string &text, bool wrtCoordinates, double x, double y, double z, LabelAlignment alignment);
};


//Class for defining a single plot source: file-path, data-index, title, dimension of data (number of columns), column-indices
//Used in subsequent plotting functions
class PlotSource{
	friend class Plot;
	friend class MultiPlot;
	
private:
	string 					filePath;
	unsigned long 			index;
	vector<unsigned long> 	columns; 	//columns to be considered from data. Note that the left-most column has index 1 (gnuplot convention)
	PlotType				plotType;
	
	PlotColorType	colorType;
	Color			color;
	double			colorValue;
	
	bool			lineWidthAuto;
	double			lineWidth;		//width in multiples of the default width.
	
	bool			lineTypeAuto;
	int				lineType;		//actual line form depends on terminal used. Typically type -1 is a solid line.
	
	bool			pointSizeAuto;
	double			pointSize;
	
	bool			pointTypeAuto;
	int				pointType;		//actual point form depends on terminal used
			
	static unsigned int columnCountForPlotType(PlotType type);
	string 			gnuplotLineWidthExpression() const;
	string 			gnuplotColorExpression() const;
//	string 			gnuplotColorColumnExpression() const;
	string 			gnuplotLineTypeExpression() const;
	string			gnuplotPointSizeExpression() const;
	string			gnuplotPointTypeExpression() const;
	string			gnuplotFilledCurveStyleExpression() const;

	bool isPlotWithEPSBlurProblems() const;
	bool isPlotWhichShowsColorbox() const;

public:
	string				title;
	
	//specialized parameters needed depending on plotType
	double				xStart, 		yStart;
	double				xStep, 			yStep;
	unsigned int		xCount, 		yCount;
	double				minX, maxX,		minY, maxY;
	string				xTransformationFunction; //function given as gnuplot math expression of variable '#'
	string				yTransformationFunction; //function given as gnuplot math expression of variable '#'
	string				zTransformationFunction; //function given as gnuplot math expression of variable '#'
	string				wTransformationFunction; //function given as gnuplot math expression of variable '#'
	VectorHeadStyle		vectorHeadStyle;
	double				vectorHeadSize;
	FilledCurveStyle	filledCurveStyle;
	double				fillReference; //reference y-value against which to fill a single curve	
	
	void				setColor(const Color &c);
	void				setColorAsValue(double value);
	void				setColorAuto();
	void				setLineWidth(double width);
	void				setLineWidthAuto();
	void				setLineType(int type);
	void				setLineTypeAuto();
	void				setPointSize(double size);
	void				setPointSizeAuto();
	void				setPointType(int type);
	void				setPointTypeAuto();
	void				setColorLineTypeLineWidth(const Color &c, int type, double width);
	
	//returns values 0, 1, 2 or 3 depending on plot type
	unsigned int 		plotDimension() const;
	
	
	//constructor
	//missing arguments should be unsigned ints, corresponding to data-columns used. Their number is determined by plotType.
	//filePath should be analytic function in x if plotType == PlotType2DAnalytic. In that case f(x) should have gnuplot function syntax.
	PlotSource(PlotType plotType, string title, string filePath, unsigned int index, ...);
	
	//empty source of PlotTypeNone
	PlotSource();
	
	//destructor
	~PlotSource(); 
	 
	//copy constructor
//	PlotSource(const PlotSource &original);
	
	//assignment operator
//	PlotSource &operator=(const PlotSource &original);
	
	bool usesSourceFile() const;
};
	
	


//Single class for defining a plot with one or multiple graphs/data sets
//Note: PlotTypes must be compatible with each other, otherwise only the first compatible sources will be considered
class Plot{
	friend class MultiPlot;
	friend PlotSource vectorField2PlotSource(	bool (*vectorField)(double, double, double&, double&),
									string filePath, 
									string title, 
									unsigned int resolutionX, 
									unsigned int resolutionY, 
									double minX, 
									double maxX, 
									double minY, 
									double maxY, 
									VectorColoring coloring,
									double meanVectorLength,
									PlotError &error);
	
	friend PlotSource vectorField2PlotSource(	bool (*vectorField)(double, double, double, double&, double&, double&),
									string filePath, 
									string title, 
									unsigned int resolutionX, 
									unsigned int resolutionY,
									unsigned int resolutionZ,
									double minX, 
									double maxX, 
									double minY, 
									double maxY, 
									double minZ,
									double maxZ,
									VectorColoring coloring,
									double meanVectorLength,
									PlotError &error);

private:
	
	//Takes a mathematical expression of parameter '$' and returns it with $ replaced by $column. Used for transforming plot data.
	//An empty trafo string is interpreted as the identity.
	static string 			evaluateFunctionForColumn(string trafo, unsigned long column);

	static unsigned int 	compatibilityGroup(PlotType type);
	static bool 			plotTypesCompatible(PlotType type1, PlotType type2);
	static string 			vectorHeadStyle2string(VectorHeadStyle style, double headSize);
	string					gnuplotDataSeparatorExpression() const;
	
	PlotError 				writeCommandToPipe(	GnuplotPipe &pipe, 
												double originX, 
												double originY, 
												double availableWidth, 
												double availableHeight, 
												double resizeNonPlotAreaWidthByFactor,
												double resizeNonPlotAreaHeightByFactor, 
												double resizeTicsByFactor,
												const string &windowFont,
												bool interpretSymbols,
												unsigned long startSource,
												const string &plotTag,
												bool escapeUnderscoresInTitle,
												bool escapeUnderscoresInTicsAndLabels,
												string commandJustAfterFirstPlot,
												long &nextAvailLabelTag) const;
	
	bool hasPlotWithEPSBlurProblems() const;
	bool hasPlotWhichShowsColorbox() const;
	
public:	
	bool 				showColorBox;
	bool				showColorMap; //if set to false, only contours are drawn (if enabled).
	ColorPalette		colorPalette;
	bool				showKeys;
	string 				title;
	MultiLabel 			axisLabels;
	string				CBLabel;
	MultiRange 			range;
	vector<PlotSource> 	sources;
	GridColoringType 	gridColoringType;
	GridSmoothingType 	gridSmoothingType;
	Contours			contours;
	double 				xDistanceScale;
	double				yDistanceScale;
	unsigned int		xGridSize;
	unsigned int		yGridSize;
	Range				CBRange;
	Tics				CBTics, xTics, yTics, zTics;
	bool				xLogarithmic, yLogarithmic, zLogarithmic;
	Color				backgroundColor;
	vector<Label>		labels;
	string				dataSeparator;
	
	//Constructors
	Plot();
	Plot(	const string &title);
	
	Plot(	const PlotSource 	&source,
			const MultiLabel 	&label, 
			const MultiRange 	&range, 
			const string 		&title);
				
	Plot(	const vector<PlotSource> 	&sources, 
			const MultiLabel 			&label, 
			const MultiRange 			&range, 
			const string 				&title);
			
	// mass-adjustment of all plot sources
	void	setLineWidthForAllCurrentSources(double width);
	void	setLineWidthAutoForAllCurrentSources();
	void	setLineTypeForAllCurrentSources(int type);
	void	setLineTypeAutoForAllCurrentSources();
	void	setPointSizeForAllCurrentSources(double size);
	void	setPointSizeAutoForAllCurrentSources();
	void	setPointTypeForAllCurrentSources(int type);
	void	setPointTypeAutoForAllCurrentSources();
	void	setNiceColorsForAllCurrentSources();
			
	//description of types
	static string 	plotErrorDescription(PlotError error);
	static string 	integrationMethod2string(IntegrationMethod method);
	
	//returns 0, 1, 2 or 3 depending on max. plot source dimension
	unsigned int 	highestPlotDimension() const;
};




class MultiPlot{
private:
	GnuplotPipe pipe;
	double		optimalRatio, minRatio, maxRatio;
	
	//factorizes value = r * c, so that |r - r0| + |c - c0| becomes minimal,
	//	whereas r0,c0 are such that value = r0 * c0 and c0/r0 = ratio.
	void getFactorization(unsigned int value, double optimalRatio, unsigned int &r, unsigned int &c);

	//returns getFactorization(newValue, optimalRatio, r, c) for minimal newValue >= value satisfying (c/r <= maxRatio) && (c/r >= minRatio)
	//Both (maxRatio - optimalRatio) and (optimalRatio - minRatio) should be positive numbers, the bigger the smaller r * c can be chosen
	void getFactorization(	unsigned int value, 
							double optimalRatio, 
							double minRatio, 
							double maxRatio, 
							unsigned int &r, 
							unsigned int &c);

	static unsigned int countNeedle(const string &haystack, const string &needle); 	//used for formatting reasons
	double				getLabelHeight(const string &label);						//in inches if output is EPS or PDF, otherwise in pixels
	string				generatePlotTag(long number) const; // returns infinite alphabet: a, b, ..., z, aa, ab, .... 
	void				setDefaults();
	
	void				renderFootnote(	string &openingCommand, 
										string &closingCommand, 
										double &footnoteScreenHeight,
										double plotHeightWithoutFootnote,
										double &plotHeightWithFootnote,
										long &nextAvailLabelTag); 
										
	bool hasPlotWithEPSBlurProblems() const;
	
	void getOutputCommands(	double 	suggestedWidth, 
							double 	suggestedHeight, 
							long 	sessionNumber, 
							string 	&outputCommand, 
							string 	&closingShellCommand, 
							string 	&terminalCommand, 
							string 	&terminalTitleCommand,
							double 	&resizeTicsByFactor) const;
							
	bool outputIsToFile() const;
	bool outputIsPS() const;
	static bool program_exists(const string &name);
	
	string			terminalName, filePath;
	PlotOutputType	outputType;
	string			terminalTitle;
	double			plotWidth, plotHeight; 		//dimensions of a single plot (in inches if output is EPS or PDF, otherwise in pixels)
	double			defaultPlotWidth, defaultPlotHeight; // dimensions of a single plot which STPlot is originally calibrated for (depends on output type)
	double			plotHSpacing, plotVSpacing; // spacing between adjacent plots in a multiplot. Relative to plotWidth and plotHeight

public:
	vector<Plot> 	plots;
	string			footnote;
	string			font; //leave blanck for default
	bool			interpretSymbols;
	bool			tagPlots; //put identifying letter symbols next to plot titles
	bool			escapeUnderscoresInTitle;
	bool			escapeUnderscoresInFootnote;
	bool			escapeUnderscoresInTicsAndLabels;
	bool			onlyResizePlotAreaInResizedPlots; // if plots are set to non-default size, only resize plotting area but not other objects (e.g. graph boundaries, color boxes..) accordingly
	
	
	//constructors
	MultiPlot();
	
	MultiPlot(	const string &gnuplotPath);
	
	MultiPlot(	const Plot &plot,
				const string &title);
				
	MultiPlot(	const Plot &plot,
				const string &title,
				const string &gnuplotPath);
	
				
	MultiPlot(	const vector<Plot> &plots, 
				string title);
				
	MultiPlot(	const vector<Plot> &plots, 
				string title,
				string gnuplotPath);
				
				
	//copies plots and parameters to MP.
	//Pipe and Log stream are not copied!
	//Ensures MP has a new pipe and will generate a new plot window.
	//void copyTo(MultiPlot &MP) const; // obsolete because GnuplotPipe has a copy constructor that takes care of that part
	
		
	//set output terminal and output files
	void	setOutputToTerminal(const string &terminal, double width, double height, const string &title); 	//terminal defaults to ST_DEFAULT_TERM. Dimensions (of a single plot) are in pixels.
	void	setOutputToPDF(const string &filePath, double width, double height); 		//requires postscript terminal and ps2pdf installed. Dimensions (of a single plot) are in inches.
	void	setOutputToEPS(const string &filePath, double width, double height);		//requires postscript terminal. Dimensions (of a single plot) are in inches.
	void	setOutputToSVG(const string &filePath, double width, double height);		//requires SVG terminal. Dimensions (of a single plot) are in pixels.
	
	void	setPlotSpacing(double Hspacing, double Vspacing);	// set spacing between plots (relative to plotWidth and plotHeight)
	
	
	//plot commands
	PlotError plot(long sessionNumber = 0);
	
	static PlotError plot(	const Plot 		&plot, 
							const string 	&title);	
							
	
	static PlotError plot(	const Plot 		&plot, 
							const string 	&title,
							const string	&gnuplotPath);	
					
					
	//logging
	void setLogStream(ostream *logStream);
	
	//get currently used gnuplot executable
	bool 	foundGnuplot() 		const{ return pipe.foundGnuplot(); }
	string 	gnuplotPath() 		const{ return pipe.currentGnuplotPath(); }
	string 	gnuplotVersion()	const{ return pipe.currentGnuplotVersion(); }
	
	//arrangement of sub-plots is calculated automatically according to the costraints below
	//aspect ratio is columns over rows.
	void setAspectRatio(double optimalRatio);
	void setAspectRatio(double optimalRatio, double minRatio, double maxRatio);
	
	// mass-adjustment of all plot sources across all plots
	void	setLineWidthForAllCurrentPlots(double width);
	void	setLineWidthAutoForAllCurrentPlots();
	void	setLineTypeForAllCurrentPlots(int type);
	void	setLineTypeAutoForAllCurrentPlots();
	void	setPointSizeForAllCurrentPlots(double size);
	void	setPointSizeAutoForAllCurrentPlots();
	void	setPointTypeForAllCurrentPlots(int type);
	void	setPointTypeAutoForAllCurrentPlots();
	void	setColorForAllCurrentPlots(const Color &color);
	
	
	//statistics and setup information
	
	//returns 0, 1, 2 or 3, depending on highest dimensionality among plot sources
	unsigned int 	highestPlotDimension() const;

	//returns paths to all source files required
	set<string>		sourceFiles() const;
};




#pragma mark -
#pragma mark Hierarchical clustering
#pragma mark -



// Reorder data matrix rows (columns if transpose==true) to improve clustering, in a way compatible with a pre-calculated binary H-cluster dendrogram (stored in merge1[] and merge2[])
// merge1[] & merge2[] can be of the type returned by HClusterAgglomerativeSingle(). 
// Each pair of siblings is ordered according to the proximity of their centroids to the centroid of their parent’s sibling
// The centroid of a leaf is the leaf value itself, the centroid of a parent node is the weighted (by mass) average of the centroids of its two children 
// Fills the order[] array, with the i-th entry being the matrix row (column if transpose==true) to be placed at position i.
// Time complexity is O(Nrows*Ncolumns).
void orderHClusterRowsCentroid(	const double	data[],		//(INPUT) data matrix in row-major format
								long			Nrows,
								long			Ncolumns,
								bool			transpose,	//(INPUT) if true, the transposed data matrix is considered instead
								HClusterMetric	metric,
								long 			merge1[], 	//(INPUT) (might be modified)
								long 			merge2[], 	//(INPUT) (might be modified)
								long			order[]); 	//(OUTPUT) improved row order (if transpose==false) or column order (if transpose==true)




// Choose order of H-cluster leafs based on distance between children and siblings
// Simlar to orderHClusterRowsCentroid() in its idea, but considers "average distances" as opposed to "centroid-to-centroid distances" between clusters.
// Advantage: Only requires distance matrix (make sure it's non negative!)
// Time complexity is O(N^2).
void orderHClusterByDistance(	const double	distances[],	//(INPUT) distance matrix in row-major format. Only strictly upper-triangular part is used.
								long			N, 
								long			merge1[], 		//(INPUT) (might be modified)
								long			merge2[], 		//(INPUT) (might be modified)
								long			order[]);		//(OUTPUT) improved object order: order[i] gives the ID of the leaf to be placed at position i.




// Calculate H-cluster leaf order in a way that minimizes change from original object order (prior to clustering), at each hierarchical level.
void orderHClusterAscending(long		N,
							const long	merge1[],	// (INPUT) merge table of Hcluster (1st column)
							const long	merge2[],	// (INPUT) merge table of Hcluster (2nd column)
							long		order[]);	// (OUTPUT) calculated leaf order. Must be pre-allocated at size >= N


//perform agglomerative hierarchical clustering of a list of objects
//distances are given in a pre-calculated distance matrix (as 1D array in row-major format). Its contents might get modified, so make a copy of it if you need it).
//the dendrogram is always a full binary tree
//Hence, the number of leafs L and the number of internal nodes (non-leaf clusters) I are related as: I = L-1
//the final object order is chosen so that dendrogram branches do not cross (but ordering is generally non-unique).
//this is similar to the hclust() function in R
//The dendrogram structure will be stored in the arrays merge1[] and merge2[]:
//	Let n1=merge1[p] and n2=merge2[p]
//	if (n1<=0) then the object (-n1) was merged into cluster p
//	if (n1>0) then the cluster (n1-1) was merged into cluster p. Merges are stored in merge1[] in the order in which they were created (bottom-up), so always (n1-1) < p.
//	Similarly for n2.
// Time complexity is O(N^3).
void HClusterAgglomerative(	long			N,				// (INPUT) sample size
							double 			distances[],	// (INPUT) distance matrix in row-major format (only strictly super-diagonal part needs to be filled). Needs to be non-negative! Might be modified upon function return so make a copy of it if you still need it.
							HClusterLinkage	linkage,
							long 			merge1[], 		// (OUTPUT) needs to be pre-allocated of size N-1, or NULL
							long			merge2[],		// (OUTPUT) needs to be pre-allocated of size N-1, or NULL
							long			order[]);		// (OUTPUT) order[i] is the ID of the object to be placed at position i. needs to be pre-allocated of size N, or NULL




#pragma mark -
#pragma mark High level plot creation
#pragma mark -

//Write vectorField as scattered data to file and return according PlotSource of type PlotType2DVectors or PlotType2DColoredVectors.
//vectorField(x,y,vx,vy) sets (vx,vy) to the field value at (x,y) and should return true if (x,y) is within its domain.
//ResolutionX & resolutionY defines the number of sampled points in x & y direction.
//(minX, minY) should be within the domain of vectorField.
PlotSource vectorField2PlotSource(	bool (*vectorField)(double, double, double&, double&),
									string filePath, 
									string title, 
									unsigned int resolutionX, 
									unsigned int resolutionY, 
									double minX, 
									double maxX, 
									double minY, 
									double maxY, 
									VectorColoring coloring,
									double meanVectorLength,
									PlotError &error);
					
//3D-version of vectorField2PlotSource(), see above
PlotSource vectorField2PlotSource(	bool (*vectorField)(double, double, double, double&, double&, double&),
									string filePath, 
									string title, 
									unsigned int resolutionX, 
									unsigned int resolutionY,
									unsigned int resolutionZ,
									double minX, 
									double maxX, 
									double minY, 
									double maxY, 
									double minZ,
									double maxZ,
									VectorColoring coloring,
									double meanVectorLength,
									PlotError &error);



//Integrate flow lines defined by the (static) vectorField and return a PlotSource of type PlotType2DCurve.
//Flow lines are written as curves to file.
//vectorField(x,y,vx,vy) sets (vx,vy) to the field value at (x,y) and should return true if (x,y) is within its domain.
//ResolutionX & resolutionY define the grid of start-points of flow-lines.
//Flow-lines are integrated up to flowTime, as long as:
//		- The vectorField is defined along their path
//		- Either followFlowsOutsideBounds == true, or they lie within [minX, maxX] x [minY, maxY].
//In case resolutionX == 1, all considered trajectories start with the x-coordinate at (minX + maxX)/2  (similarly for resolutionY).
//Thus, you may set resolutionX = resolutionY = 1 and minX = maxX, minY = maxY to follow just one trajectory starting at (minX, minY). 
PlotSource vectorFieldFlowLines2PlotSource( bool (*vectorField)(double, double, double&, double&),
											string filePath, 
											string title, 
											unsigned int resolutionX, 
											unsigned int resolutionY,
											double timeStep,
											double flowTime,
											IntegrationMethod integrationMethod,
											bool followFlowsOutsideBounds,
											double minX, 
											double maxX, 
											double minY, 
											double maxY,
											PlotError &error);
	

//3D-version of vectorFieldFlowLines2PlotSource(), see above
PlotSource vectorFieldFlowLines2PlotSource( bool (*vectorField)(double, double, double, double&, double&, double&),
											string filePath, 
											string title, 
											unsigned int resolutionX, 
											unsigned int resolutionY,
											unsigned int resolutionZ,
											double timeStep,
											double flowTime,
											IntegrationMethod integrationMethod,
											bool followFlowsOutsideBounds,
											double minX, 
											double maxX, 
											double minY, 
											double maxY, 
											double minZ,
											double maxZ,
											PlotError &error);


//Represents C -> C mapping as color-map on a 2D plane by mapping complex numbers to colors using the HSV-cylinder model.
//Mapping(xr,xi,yr,yi) should set the complex number (yr + i * yi) as function of the complex (xr + i * xi).
//Returned PlotSource is of type PlotType2DColorImage.
//valueRadius defines a y-radius within which colors should be saturated. Values far away from the so defined domain will be represented 'less colorfull'. 
PlotSource complexMapping2PlotSource(	void (*mapping)(double, double, double&, double&), 
										string filePath,
										string title,
										unsigned int resolutionR,
										unsigned int resolutionI,
										double minR, 
										double maxR, 
										double minI, 
										double maxI,
										double zeroRadius,
										double inftyRadius,
										PlotError &error);
										
			
//Create a Heat Map plot for the data given, possibly after clustering (row & column reordering)
//row-clustering is of time complexity O(Nrows^3+Nrows^2*Ncolumns) and space complexity P(Nrows^2)
//data[] is matrix given as 1D array in row-major format.
//Assuming no re-ordering:
//	data[0] corresponds to top-left pixel in plot
//	data[Nrows*Ncolumns-1] corresponds to bottom-right pixel in plot
//You can further customize the returned plot object
Plot HeatMapHClustered2Plot(	const vector<double>	&data,		// (INPUT) data matrix in row-major format
								long					Nrows,
								long					Ncolumns,
								const string			&Rlegend,
								const string			&Clegend,
								const string			&ValueLegend,
								const vector<string>	&Rnames,	// (INPUT) row category names to be displayed next to vertical axis. Leave empty for no names
								const vector<string>	&Cnames,	// (INPUT) column category names, similar to Rnames
								const string			&filePath,	// (INPUT) path to data file
								ofstream				&fout,		// (INPUT/OUTPUT) file stream to write to. If the stream is closed, it is opened by appending and closed at the end
								long					&currentDataIndex,	// (INPUT/OUTPUT) 
								const string			&title,
								const string			&fileComment,
								double					columnNamesRotation, // (INPUT) rotation angle for column names (in degrees). 0 means horizontal. Counted counter-clokwise.
								HClusterWhat			clusterWhat,
								HClusterOrdering		Rordering,		// (INPUT) only relevant if clusterRows == true
								HClusterOrdering		Cordering,		// (INPUT) only relevant if clusterRows == true
								HClusterMetric			metric,			// (INPUT) dissimilarity metric used to compare rows and/or columns for clustering
								HClusterLinkage			linkage,		// (INPUT) linkage criterium used for composite clusters during clustering
								bool					uniformize,	// (INPUT) redistribute data (while preserving order) to achieve a uniform distribution on the color scale. This will generate an additional data index
								double					&recommendedPlotWidthCorrection, 	// (OUTPUT) recommended width for this plot (compared to ST_GNUPLOT default width)
								double					&recommendedPlotHeighCorrectiont, 	// (OUTPUT) recommended height for this plot (compared to ST_GNUPLOT default height)
								double					&recommendedRelativePlotHSpacing, 	// (OUTPUT) recommended relative horizontal spacing for this plot (in inches, only applies to PDF plots)
								double					&recommendedRelativePlotVSpacing, 	// (OUTPUT) recommended relative vertical spacing for this plot (in inches, only applies to PDF plots)
								PlotError 				&error);


Plot Histogram2Plot(	const vector<string> 	&names,
						const vector<double> 	&values,
						const string			&nameLegend,
						const string			&valueLegend,
						const string			&filePath,		// (INPUT) path to data file to be created
						long					&dataIndex,		// (INPUT/OUTPUT) if this is negative, the data file is overwritten. Otherwise data is appended, but the caller guarantees that the resulting data index is correct
						const string			&title,
						const string			&fileComment,
						const string			&separator,		// (INPUT) separator to be used for data file (must not occur in bar names). Set to empty for white-space (assumes names contain no spaces)
						double					namesRotation, 	// (INPUT) rotation angle for bar names (in degrees). 0 means horizontal. Counted counter-clokwise
						SortHow					sortHow, 			// (INPUT) how to sort categories w.r.t. bar height
						bool					escapeUnderscoresInNames,
						double					&recommendedPlotWidthCorrection, 	// (OUTPUT) recommended width for this plot (compared to ST_GNUPLOT default width)
						double					&recommendedPlotHeighCorrectiont, 	// (OUTPUT) recommended height for this plot (compared to ST_GNUPLOT default height)
						double					&recommendedRelativePlotHSpacing, 	// (OUTPUT) recommended relative horizontal spacing for this plot (in inches, only applies to PDF plots)
						double					&recommendedRelativePlotVSpacing, 	// (OUTPUT) recommended relative vertical spacing for this plot (in inches, only applies to PDF plots)
						long					&histogramIndex,					// (OUTPUT) index of actual histogram in plot sources
						PlotError 				&error);




Plot StackedFilledCurves2Plot(	const double			data[],	// (INPUT) Data matrix in row-major format. 1st column are x values, the rest of the columns are y values for different curves (ycount in total) evaluated at the same x.
								unsigned long			xcount,
								unsigned long			ycount,
								const vector<Color>		&colors,
								const vector<string>	&names,
								const string			&filePath,
								long					dataIndex,	// (INPUT) if this is negative, the data file is overwritten. Otherwise data is appended, but the caller guarantees that the resulting data index is correct
								const string			&title,
								const string			&fileComment,
								const string			&xlabel,
								const string			&ylabel,
								bool					relative, // (INPUT) if true, data is rescaled to sum=1, i.e. such that relative y-values are shown for each x
								ColorBlindness			assumedColorBlindness, // If not ColorBlindnessNone, all palette colors are transformed to color-blind readable
								PlotError				&error); // (OUTPUT) 


Plot TimeSeriesDistribution2Plot(	const vector<double> 			&times,				// (INPUT) common times for all sample time series, strictly increasing
									const vector<double>			&centiles,			// (INPUT) centiles (e.g. 0.5, 0.95) at which to show contours and change coloring
									const vector<vector<double> > 	&centileMinValues, 	// (INPUT) values[t][c] is min value of c-th centile at time times[t] 
									const vector<vector<double> > 	&centileMaxValues, 	// (INPUT) values[t][c] is max value of c-th centile at time times[t] . That is, at time t, time series will be within [centileMinValues[t][c], centileMaxValues[t][c]] with probablity centiles[c]
									const vector<double>			&highlightValues,	// (INPUT) highlightValues[t] is value of a highlighted time series at time times[t]. Can also be empty (omit).
									const string					&highlightName,		// (INPUT) name of the highlighted curve. Only relevant if highlightValues[] is not empty.
									const vector<double>			&meanValues,		// (INPUT) meanValues[t] is value of the time series mean at time times[t]. Can also be empty (omit).
									double							lineWidth,			// (INPUT)
									ofstream						&fout,
									const string					&filePath,
									long							&currentDataIndex,
									const string					&title,
									const string					&fileComment,
									const string					&xlabel,
									const string					&ylabel,
									const string					&dataName,
									double							epsilon,
									ColorPalette					colorPalette,
									bool 							useKeysInsteadOfColorBar, // if true, centile color scale is shown as plot keys instead of a color bar
									PlotError						&error);


// writes the data for and returns a heatmap plot of a 2D rectangular grid value grid
// bottom-left plot corner will be 1st row and 1st column
// the special feature is that grid steps can be irregular (but grid must still be rectangular)
// and that plotted boxes are centered at the grid points (and not between grid points)
// this is a convenient wrapper because underneath data has to be written and transformed in a complicated way
Plot irregular2DGridValueMap2Plot(	const vector<double>	&gridValues, 	// (INPUT) data grid values as matrix in row-major format
									long					NR,				// (INPUT) number of grid rows
									long					NC,				// (INPUT) number of grid columns
									const vector<double>	&rowValues,		// (INPUT) coordinates at row centres, in ascenting order. Of size at least NR
									const vector<double>	&columnValues,	// (INPUT) coordinates at column centres, in ascending order. Of size at least NC
									ofstream				&fout,
									const string			&filePath,
									long					&currentDataIndex,
									const string			&title,
									const string			&fileComment,
									const string			&xlabel,
									const string			&ylabel,
									const string			&dataName,
									bool					alsoSaveOriginalData,
									PlotError				&error); 		// (OUTPUT) if an error occurred, this will be different than PlotErrorNone


template<class FUNCTOR>
PlotError plotFunction(	const FUNCTOR 		&f, 
						double 				minX, 
						double 				maxX, 
						const MultiLabel 	&label, 
						const string 		&title, 
						unsigned int 		resolution){
	ofstream fout;
	string fileName(tmpnam(NULL));
  	fout.open(fileName.c_str());
  	double dx = (maxX - minX)/resolution;
  	for(double x = minX; x <= maxX; x += dx){
  		fout << x << " " << f(x) << "\n";
  	}
  	fout.close();
  	
  	PlotError error = MultiPlot::plot(	Plot(	PlotSource(PlotType2DGraphLinear, "", fileName, 0, 1, 2), 
												label, 
												MultiRange(Range(minX, maxX), Range()), 
												title),
												title);
  	remove(fileName.c_str());
  	return error;
}









template<class TYPE>
PlotError plotTimeSeries(	const vector<TYPE> 	&t,
							const vector<TYPE> 	&x, 
							unsigned long 		start,
							unsigned long 		end,
							const MultiLabel 	&label, 
							const string 		&title, 
							bool				showLines,
							bool				showPoints,
							bool				xLogarithmic,
							bool				yLogarithmic){
	ofstream fout;
	string fileName(tmpnam(NULL));
  	fout.open(fileName.c_str());
  	for(unsigned long i=start; i<=end; ++i){
  		fout << t[i] << " " << x[i] << "\n";
  	}
  	fout.close();
  	
  	Plot plot(	PlotSource((showLines && showPoints ? PlotType2DGraphLinearPoints : (showLines ? PlotType2DGraphLinear : PlotType2DPoints)), "", fileName, 0, 1, 2), 
				label, 
				MultiRange(Range(), Range()), 
				title);
	plot.xLogarithmic = xLogarithmic;
	plot.yLogarithmic = yLogarithmic;
  	PlotError error = MultiPlot::plot(plot,title);
  	remove(fileName.c_str());
  	return error;
}


Plot circularNetwork2Plot(	const double 			adjacencies[],		// (INPUT) adjacency matrix in row-major format (lower-triangular and diagonal part are not used). Adjacencies can be negative or positive (but undirected).
							long					N,
							const vector<double>	&sizeParam,			// (INPUT) object size parameter (only relative values matter). Should either contain N entries or be empty.
							const vector<double>	&colorParam,		// (INPUT) object color parameter (only relative values matter). Should either contain N entries or be empty.
							const string			&filePath,			// (INPUT) path to output data file
							const string			&title,				// (INPUT) plot title
							const string			&fileComment,		// (INPUT) Comment to add to output file header
							ColorPalette			nodeColorPalette,	// (INPUT) color palette from which to choose node colors. Only applies if colorParam[] is non-empty.
							const Color				&colorNeg,
							const Color				&colorPos,
							double					thresholdNeg,		// (INPUT) negative correlation threshold (negative correlations greater than this are omitted)
							double					thresholdPos,		// (INPUT) positive correlation threshold (positive correlations smaller than this are omitted)
							bool					cluster,			// (INPUT) if true, nodes are re-ordered so that highly correlated nodes end up closer to each other (hierarchical clustering). Time complexity O(N^3).
							PlotError 				&error);




#pragma mark - 
#pragma mark Plot handlers
#pragma mark


//plot a MultiPlot in a PDF and/or the terminal and generate a plot log (gnuplot script)
//If requested, appends the shell command 'gnuplot <plot script>' to a given shell script file (provided that logFile is valid).
bool plotWithLog(	MultiPlot 		&MP,
					const string 	&logFile,		//Plot script file path. Set to empty for no log (script) file
					const string 	&plotPDFFile,	//PDF plot path. Set to empty for no PDF plotting
					const string 	&plotSVGFile,	//SVG plot path. Set to empty for no SVG plotting
					const string 	&plotName,		//descriptive name for this plot (only relevant if streamOut!=NULL or shellScript!="")
					ostream* 		streamOut, 		//feedback stream. Set to NULL for no feedback 
					bool 			plotTerm,		//if true, plot is also in default plot terminal
					const string	&shellScript,	//file onto which to append a shell command for executing the gnuplot script later on. Set to empty for no shell script.
					string			&errorMessage);


// same as plotWithLog(..) above, but the option to specify dimensions per plot
bool plotWithLog(	MultiPlot 		&MP,
					const string 	&logFile,	
					const string 	&plotPDFFile,
					const string 	&plotSVGFile,
					const string 	&plotName,	
					ostream* 		streamOut, 	
					bool 			plotTerm,	
					const string	&shellScript,
					double			plotWidthTerm,	// only relevant if plotTerm
					double			plotHeightTerm,	// only relevant if plotTerm
					double			plotWidthPDF,	// only relevant if plotPDFFile!=""
					double			plotHeightPDF,	// only relevant if plotPDFFile!=""
					double			plotWidthSVG,	// only relevant if plotSVGFile!=""
					double			plotHeightSVG,	// only relevant if plotSVGFile!=""
					double			plotHSpacing,	// horizontal space between plots (relative to plotWidth)
					double			plotVpacing,	// vertical space between plots (relative to plotHeight)
					string			&errorMessage);



#pragma mark - 
#pragma mark Auxiliary
#pragma mark






// transforms data monotonically (i.e. while preserving order) onto values covering the interval [0,1]
// adjusts the passed tics scale so that tics are placed on regular grid at transformed values but labeled with original values
void STPlot_transformDataToUniformDistribution(const vector<double> 	&original, 
										long 					start,
										long 					end,
										vector<double> 			&transformed,
										Tics 					&adjustedTics);




void STPlot_getRegularIntegerGrid(long minValue, long maxValue, vector<long> &grid);




inline double STPlot_aux_SQ(double x){ return x*x; }


inline long STPlot_aux_array_rowColumn2Index(long row, long column, long columns){
	return row*columns + column;
}

//same as STPlot_aux_array_rowColumn2Index() but for upper triangular matrices
//swaps row<-->column if (row, column) is sub-diagonal
inline long STPlot_aux_arrayUT_rowColumn2Index(long row, long column, long columns){
	return (row<=column ? row*columns + column : column*columns + row);
}


inline void STPlot_aux_array_index2RowColumn(long index, long columns, long &row, long &column){
	 column = index % columns;
	 row 	= index/columns;
}


inline long STPlot_aux_array_rowColumn2Index(	long Ncolumns,
												bool transpose,
												long row,
												long column){
	return (transpose ? (column*Ncolumns+row) : (row*Ncolumns + column));					
}



double STPlot_aux_distanceBetweenDataRows(	const double 	data[],	// (INPUT) data matrix in row-major format
											long			row1,
											long			row2,
											long			Ncolumns,
											HClusterMetric	metric);




double STPlot_aux_distanceBetweenDataColumns(	const double 	data[],	// (INPUT) data matrix in row-major format
												long			column1,
												long			column2,
												long			Nrows,
												long			Ncolumns,
												HClusterMetric	metric);



double STPlot_aux_distanceBetweenDataRecords(	const double 	data1[],		// (INPUT) data matrix 1 in row-major format
												long			Ncolumns1,
												long			recordID1,
												bool			asRow1,
												const double	data2[],		// (INPUT) data matrix 2 in row-major format
												long			Ncolumns2,
												long			recordID2,
												bool			asRow2,
												long			recordDim,		// (INPUT)
												HClusterMetric	metric);



bool STPlot_aux_file_missing_or_empty(string file);

	
template<class TYPE> 
static string STPlot_makeString(const TYPE &data){ ostringstream stream; stream << data; return stream.str(); }


template<class TYPE>
string STPlot_makeString(TYPE data, unsigned int precision){
	ostringstream stream;
	stream << setprecision(precision) << data;
	return stream.str();
}



int STPlot_aux_replaceAll(string& haystack, const char *needle, const char *replacement);

string STPlot_aux_get_replaceAll(const string& haystack, const char *needle, const char *replacement);

double STPlot_aux_modulo(double numerator, double denominator);

inline double STPlot_aux_moduloInterval(double value, double intervalMin, double intervalMax){
	return STPlot_aux_modulo(value - intervalMin, intervalMax - intervalMin) + intervalMin;
}

inline long STPlot_aux_getMaxStringLength(const vector<string> &sv){
	long L=0;
	for(long i=0; i<sv.size(); ++i){ L = max(L, (long) sv[i].length()); }
	return L;
}


bool STPlot_aux_fileExists(const string &path);

// changes file extension, but only if a given extension was present initially
void STPlot_aux_correctFileExtensionFromTo(string &path, const string &from, const string &to);

inline string STPlot_aux_lowercase(const string &s){
	string ls = s;
	for(long n=0; n<ls.length(); ++n){ ls[n] = tolower(ls[n]); }
	return ls;
}

void STPlot_qsortIndices(const vector<double> &values, vector<long> &sortedIndices, bool ascending);

long STPlot_aux_qsortIndices_partition(const vector<double> &values, vector<long> &indices, long start, long end, bool ascending);

void STPlot_aux_qsortIndices(const vector<double> &values, vector<long> &indices, long start, long end, bool ascending);


string STPlot_aux_getUniqueTempFilePath();

long STPlot_aux_getPrecisionToDistinguishValues(const vector<double> &values);





}//END OF NAMESPACE ST

#endif