#region Copyright
/*
* Copyright (c) 2005,2006,2007, OpenMI Association
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of the OpenMI Association nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY "OpenMI Association" ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL "OpenMI Association" BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#endregion
using System;
using OpenMI.Standard;
namespace RTCTools.OpenMI.Sdk.Backbone
{
///
/// The ScalarSet class contains a list of scalar values.
/// This is a trivial implementation of OpenMI.Standard.IScalarSet, refer there for further details.
///
[Serializable]
public class ScalarSet : IScalarSet
{
double[] _values;
double _missingValueDefinition;
private double _compareDoublesEpsilon;
///
/// Constructor
///
public ScalarSet()
{
_values = new double[0];
_missingValueDefinition = -999.0;
_compareDoublesEpsilon = 0.000001;
}
///
/// Constructor
///
/// The list of values
public ScalarSet(double[] values)
{
_values = values;
_missingValueDefinition = -999.0; // TODO call empty constructor
_compareDoublesEpsilon = 0.000001;
}
///
/// Returns if a certain element is valid
///
/// Element index
/// True if element is valid
public virtual bool IsValid(int elementIndex)
{
return !isEqual(_values[elementIndex], _missingValueDefinition);
}
///
/// Copy constructor
///
/// The scalar set to copy
public ScalarSet(IScalarSet source)
{
if ( source == null )
{
throw new Exception("ScalarSet Constructor from \"Source\": source == null");
}
_values = new double[source.Count];
for (int i = 0; i < source.Count; i++)
{
_values[i] = source.GetScalar(i);
}
}
///
/// Gets a value from the list of values
///
/// The element index
/// The scalar value
public double GetScalar(int ElementIndex)
{
if ( _values == null )
{
throw new Exception("Values null");
}
else
{
if ( _values.Length < ElementIndex+1 || ElementIndex < 0 )
{
throw new Exception("Invalid ElementIndex");
}
}
return _values[ElementIndex];
}
///
/// Gives direct access to the data
///
public double[] data
{
get
{
return _values;
}
set
{
_values = value;
}
}
///
/// Returns the number of values
///
public int Count
{
get
{
return _values.Length;
}
}
///
/// Check if the current instance equals another instance of this class.
///
///The instance to compare the current instance with.
///true
if the instances are the same instance or have the same content.
public override bool Equals(Object obj)
{
if (obj is ScalarSet)
{
ScalarSet sourceSet = (ScalarSet)obj;
if (sourceSet.Count != Count)
return false;
for (int i = 0; i < Count; i++)
{
if (sourceSet.GetScalar(i) != GetScalar(i))
return false;
}
return true;
}
return base.Equals(obj);
}
///
/// Getter and Setter for the missing value definition.
///
public double MissingValueDefinition
{
get { return _missingValueDefinition; }
set { _missingValueDefinition = value; }
}
///
/// The epsilon (i.e. the small double value) that should be used when
/// checking
///
///
public double CompareDoublesEpsilon
{
get { return _compareDoublesEpsilon; }
set { _compareDoublesEpsilon = value; }
}
///
/// Will compare two doubles, using _doubleEpsilon.
///
/// First double
/// Second double
/// True if double1 and double2 are equal.
protected bool isEqual(double double1, double double2)
{
bool isEqual = false;
if (double1 >= double2 - _compareDoublesEpsilon &&
double1 <= double2 + _compareDoublesEpsilon)
{
isEqual = true;
}
return isEqual;
}
///
/// Get Hash Code.
///
///Hash Code for the current instance.
public override int GetHashCode()
{
int hashCode = base.GetHashCode();
if (_values != null) hashCode += _values.GetHashCode();
return hashCode;
}
}
}