/// <summary>
/// Returns the minimum and maximum values in a DataView.
/// </summary>
/// <param name="data">The DataView to search.</param>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
/// <param name="columnName">The name of the column in the row collection to search over.</param>
/// <returns>true is min max set, false otherwise (a = null or zero length).</returns>
public static bool DataViewArrayMinMax(DataView data,
out double min, out double max, string columnName)
{
// double[] is a reference type and can be null, if it is then I reckon the best
// values for min and max are also null. double is a value type so can't be set
// to null. So min an max return object, and we understand that if it is not null
// it is a boxed double (same trick I use lots elsewhere in the lib). The
// wonderful comment I didn't write at the top should explain everything.
if (data == null || data.Count == 0)
{
min = 0.0;
max = 0.0;
return(false);
}
min = Utils.ToDouble((data[0])[columnName]);
max = Utils.ToDouble((data[0])[columnName]);
for (int i = 0; i < data.Count; ++i)
{
double e = Utils.ToDouble(data[i][columnName]);
if (e < min)
{
min = e;
}
if (e > max)
{
max = e;
}
}
return(true);
}
/// <summary>
/// Gets data at a given index, in the given series (column number).
/// </summary>
/// <param name="index">index in the series to get data for</param>
/// <param name="seriesIndex">series number (column number) to get data for.</param>
/// <returns>the required data point.</returns>
public double PointAt(int index, int seriesIndex)
{
if (seriesIndex < abscissaColumnNumber_)
{
return(Utils.ToDouble(rows_[index][seriesIndex]));
}
else
{
return(Utils.ToDouble(rows_[index][seriesIndex + 1]));
}
}
/// <summary>
/// Returns the minimum and maximum values in a DataRowCollection.
/// </summary>
/// <param name="rows">The row collection to search.</param>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
/// <param name="columnName">The name of the column in the row collection to search over.</param>
/// <returns>true is min max set, false otherwise (a = null or zero length).</returns>
public static bool RowArrayMinMax(DataRowCollection rows,
out double min, out double max, string columnName)
{
// double[] is a reference type and can be null, if it is then I reckon the best
// values for min and max are also null. double is a value type so can't be set
// to null. So min an max return object, and we understand that if it is not null
// it is a boxed double (same trick I use lots elsewhere in the lib). The
// wonderful comment I didn't write at the top should explain everything.
if (rows == null || rows.Count == 0)
{
min = 0.0;
max = 0.0;
return(false);
}
min = Utils.ToDouble((rows[0])[columnName]);
max = Utils.ToDouble((rows[0])[columnName]);
foreach (DataRow r in rows)
{
double e = Utils.ToDouble(r[columnName]);
if ((min.Equals(double.NaN)) && (!e.Equals(double.NaN)))
{
// if min/max are double.NaN and the current value not, then
// set them to the current value.
min = e;
max = e;
}
if (!double.IsNaN(e))
{
if (e < min)
{
min = e;
}
if (e > max)
{
max = e;
}
}
}
if (min.Equals(double.NaN))
{
// if min == double.NaN, then max is also double.NaN
min = 0.0;
max = 0.0;
return(false);
}
return(true);
}
/// <summary>
/// Returns the minimum and maximum values in an IList. The members of the list
/// can be of different types - any type for which the function Utils.ConvertToDouble
/// knows how to convert into a double.
/// </summary>
/// <param name="a">The IList to search.</param>
/// <param name="min">The minimum value.</param>
/// <param name="max">The maximum value.</param>
/// <returns>true if min max set, false otherwise (a == null or zero length).</returns>
public static bool ArrayMinMax(IList a, out double min, out double max)
{
if (a == null || a.Count == 0)
{
min = 0.0;
max = 0.0;
return(false);
}
min = Utils.ToDouble(a[0]);
max = Utils.ToDouble(a[0]);
foreach (object o in a)
{
double e = Utils.ToDouble(o);
if ((min.Equals(double.NaN)) && (!e.Equals(double.NaN)))
{
// if min/max are double.NaN and the current value not, then
// set them to the current value.
min = e;
max = e;
}
if (!double.IsNaN(e))
{
if (e < min)
{
min = e;
}
if (e > max)
{
max = e;
}
}
}
if (min.Equals(double.NaN))
{
// if min == double.NaN, then max is also double.NaN
min = 0.0;
max = 0.0;
return(false);
}
return(true);
}
/// <summary>
/// Gets the ith point in the candle adapter
/// </summary>
/// <param name="i">index of datapoint to get</param>
/// <returns>the datapoint.</returns>
public PointOLHC this[int i]
{
get
{
// try a fast track first
if (useDoublesArrays_)
{
return(new PointOLHC(
abscissaDataArray_[i],
openDataArray_[i],
lowDataArray_[i],
highDataArray_[i],
closeDataArray_[i]));
}
// is the data coming from a data source?
else if (rows_ != null)
{
double x = Utils.ToDouble(((DataRow)(rows_[i]))[(string)abscissaData_]);
double open = Utils.ToDouble(((DataRow)(rows_[i]))[(string)openData_]);
double low = Utils.ToDouble(((DataRow)(rows_[i]))[(string)lowData_]);
double high = Utils.ToDouble(((DataRow)(rows_[i]))[(string)highData_]);
double close = Utils.ToDouble(((DataRow)(rows_[i]))[(string)closeData_]);
return(new PointOLHC(x, open, low, high, close));
}
// the data is coming from individual arrays.
else if (abscissaData_ is Array && openData_ is Array && lowData_ is Array && highData_ is Array && closeData_ is Array)
{
double x = Utils.ToDouble(((Array)abscissaData_).GetValue(i));
double open = Utils.ToDouble(((Array)openData_).GetValue(i));
double low = Utils.ToDouble(((Array)lowData_).GetValue(i));
double high = Utils.ToDouble(((Array)highData_).GetValue(i));
double close = Utils.ToDouble(((Array)closeData_).GetValue(i));
return(new PointOLHC(x, open, low, high, close));
}
else
{
throw new NPlotException("not implemented yet");
}
}
}
/// <summary>
/// Gets the ith data value.
/// </summary>
/// <param name="i">sequence number of data to get.</param>
/// <returns>ith data value.</returns>
public double Get(int i)
{
return(Utils.ToDouble((rows_[i])[columnName_]));
}
/// <summary>
/// Gets the ith data value.
/// </summary>
/// <param name="i">sequence number of data to get.</param>
/// <returns>ith data value.</returns>
public double Get(int i)
{
return(Utils.ToDouble(data_[i]));
}
/// <summary>
/// Returns an x-axis that is suitable for drawing the data.
/// </summary>
/// <returns>A suitable x-axis.</returns>
public Axis SuggestXAxis()
{
double min;
double max;
double minStep = 0.0;
if (this.rows_ == null)
{
Utils.ArrayMinMax((System.Collections.IList) this.abscissaData_, out min, out max);
if (((System.Collections.IList)abscissaData_).Count > 1)
{
double first = Utils.ToDouble(((Array)abscissaData_).GetValue(0));
double second = Utils.ToDouble(((Array)abscissaData_).GetValue(1));
minStep = Math.Abs(second - first);
}
if (((System.Collections.IList)abscissaData_).Count > 2)
{
double first = Utils.ToDouble(((Array)abscissaData_).GetValue(1));
double second = Utils.ToDouble(((Array)abscissaData_).GetValue(2));
if (Math.Abs(second - first) < minStep)
{
minStep = Math.Abs(second - first);
}
}
if (((System.Collections.IList)abscissaData_)[0] is DateTime)
{
return(new DateTimeAxis(min - minStep / 2.0, max + minStep / 2.0));
}
else
{
return(new LinearAxis(min - minStep / 2.0, max + minStep / 2.0));
}
}
else
{
Utils.RowArrayMinMax(this.rows_, out min, out max, (string)this.abscissaData_);
if (rows_.Count > 1)
{
double first = Utils.ToDouble(rows_[0][(string)abscissaData_]);
double second = Utils.ToDouble(rows_[1][(string)abscissaData_]);
minStep = Math.Abs(second - first);
}
if (rows_.Count > 2)
{
double first = Utils.ToDouble(rows_[1][(string)abscissaData_]);
double second = Utils.ToDouble(rows_[2][(string)abscissaData_]);
if (Math.Abs(second - first) < minStep)
{
minStep = Math.Abs(second - first);
}
}
if ((rows_[0])[(string)abscissaData_] is DateTime)
{
return(new DateTimeAxis(min - minStep / 2.0, max + minStep / 2.0));
}
else
{
return(new LinearAxis(min - minStep / 2.0, max + minStep / 2.0));
}
}
}
