/// <summary>
/// Constructor to initialize the PointPairList from two arrays of
/// type double.
/// </summary>
public FilteredPointList(IReadOnlyList <double> x, IReadOnlyList <double> y)
{
var len = Math.Max(x.Count, y.Count);
var dt = new CompactPt[len];
if (x.Count < y.Count)
{
for (var i = 0; i < x.Count; ++i)
{
dt[i] = new CompactPt(x[i], y[i]);
}
for (var i = x.Count; i < y.Count; ++i)
{
dt[i] = new CompactPt(PointPairBase.Missing, y[i]);
}
}
else
{
for (var i = 0; i < y.Count; ++i)
{
dt[i] = new CompactPt(x[i], y[i]);
}
for (var i = y.Count; i < x.Count; ++i)
{
dt[i] = new CompactPt(x[i], PointPairBase.Missing);
}
}
_data = dt;
}
// /// <summary>
// /// Switch used to indicate if the next filtered point should be the high point or the
// /// low point within the current range.
// /// </summary>
// private bool _upDown = false;
// /// <summary>
// /// Determines if the high/low logic will be used.
// /// </summary>
// private bool _isApplyHighLowLogic = true;
#endregion
#region Properties
/// <summary>
/// Indexer to access the specified <see cref="PointPair"/> object by
/// its ordinal position in the list.
/// </summary>
/// <remarks>
/// Returns <see cref="PointPairBase.Missing" /> for any value of <see paramref="index" />
/// that is outside of its corresponding array bounds.
/// </remarks>
/// <param name="index">The ordinal position (zero-based) of the
/// <see cref="PointPair"/> object to be accessed.</param>
/// <value>A <see cref="PointPair"/> object reference.</value>
public IPointPair this[int index]
{
get
{
// See if the array should be bounded
if (_minBoundIndex >= 0 && _maxBoundIndex >= 0 && MaxPts >= 0)
{
// get number of points in bounded range
var nPts = _maxBoundIndex - _minBoundIndex + 1;
if (nPts > MaxPts)
{
// if we're skipping points, then calculate the new index
index = _minBoundIndex + (int)(index * (double)nPts / MaxPts);
}
else
{
// otherwise, index is just offset by the start of the bounded range
index += _minBoundIndex;
}
}
return(index >= 0 && index < _data.Length ? (IPointPair)_data[index] : PointPair.Empty);
}
set
{
// See if the array should be bounded
if (_minBoundIndex >= 0 && _maxBoundIndex >= 0 && MaxPts >= 0)
{
// get number of points in bounded range
int nPts = _maxBoundIndex - _minBoundIndex + 1;
if (nPts > MaxPts)
{
// if we're skipping points, then calculate the new index
index = _minBoundIndex + (int)(index * (double)nPts / MaxPts);
}
else
{
// otherwise, index is just offset by the start of the bounded range
index += _minBoundIndex;
}
}
if (index >= 0 && index < _data.Length)
{
_data[index] = new CompactPt(value);
}
}
}
/// <summary>
/// Indexer: get the DataPoint instance at the specified ordinal position in the list
/// </summary>
/// <remarks>
/// This method will throw an exception if the index is out of range. This can happen
/// if the index is less than the number of filtered values, or if data points are
/// removed from a filtered dataset with updating the filter (by calling
/// <see cref="FilterData" />).
/// </remarks>
/// <param name="index">The ordinal position in the list of points</param>
/// <returns>Returns a <see cref="PointPair" /> instance. The <see cref="PointPair.Z" />
/// and <see cref="PointPair.Tag" /> properties will be defaulted to
/// <see cref="PointPairBase.Missing" /> and null, respectively.
/// </returns>
public new IPointPair this[int index]
{
get
{
int j = index;
if (_isFiltered)
{
j = _visibleIndicies[index];
}
return(base[j]);
}
set
{
int j = index;
if (_isFiltered)
{
j = _visibleIndicies[index];
}
base[j] = new CompactPt(value);
}
}
