interval.cpp

粗糙集应用软件

//-------------------------------------------------------------------
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Revisions.....:
//===================================================================

#include <stdafx.h> // Precompiled headers.
#include <copyright.h>

#include <kernel/basic/interval.h>
#include <kernel/basic/string.h>
#include <kernel/basic/undefined.h>
#include <kernel/basic/message.h>

#include <kernel/system/float.h>
#include <kernel/system/math.h>

//-------------------------------------------------------------------
// Methods for class Interval.
//===================================================================

//-------------------------------------------------------------------
// Constructors/destructor.
//===================================================================

//-------------------------------------------------------------------
// Method........: Constructor
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

Interval::Interval() {
	MakeInterval(FromInclude(), Undefined::Float(), Undefined::Float(), To());
}

//-------------------------------------------------------------------
// Method........: Constructor
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

Interval::Interval(const Interval &in) {
	MakeInterval(in.GetLowerDelimiter(), in.GetLowerValue(), in.GetUpperValue(), in.GetUpperDelimiter());
}

//-------------------------------------------------------------------
// Method........: Constructor
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

Interval::Interval(char ldelimiter, float lvalue, float uvalue, char udelimiter) {
	MakeInterval(ldelimiter, lvalue, uvalue, udelimiter);
}

//-------------------------------------------------------------------
// Method........: Constructor
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......: If the string does not define a valid interval,
//                 the interval defaults to an invalid range.
// Revisions.....:
//===================================================================

Interval::Interval(const String &interval) {

	String copy = interval;

	// Allow surrounding whitespace.
	copy.Trim(" \t\n");

	// Extract delimiters.
	char ldelimiter = copy.First();
	char udelimiter = copy.Last();

	// Initialize values to define an invalid range.
	float lvalue = 1.0;
	float uvalue = 0.0;

	int index = copy.Search(1, Separator());

	// Extract values, if possible.
	if (index != -1) {

		String lstring = copy.GetSubstring(1, index - 1);
		String ustring = copy.GetSubstring(index + 1, copy.GetLength() - index - 2);

		// Allow surrounding whitespace.
		lstring.Trim(" \t\n");
		ustring.Trim(" \t\n");

		if (lstring == Infinity())
			lvalue = -FLT_MAX;
		else if (lstring.IsFloat())
			lvalue = lstring.GetFloat();

		if (ustring == Infinity())
			uvalue = FLT_MAX;
		else if (ustring.IsFloat())
			uvalue = ustring.GetFloat();

	}

	MakeInterval(ldelimiter, lvalue, uvalue, udelimiter);

}

//-------------------------------------------------------------------
// Method........: Destructor
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

Interval::~Interval() {
}

//-------------------------------------------------------------------
// Mutators.
//===================================================================

//-------------------------------------------------------------------
// Method........: SetLowerDelimiter/SetUpperDelimiter
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......:
// Revisions.....:
//===================================================================

bool
Interval::SetLowerDelimiter(char delimiter) {
	ldelimiter_ = delimiter;
	return (delimiter == From() || delimiter == FromInclude());
}

bool
Interval::SetUpperDelimiter(char delimiter) {
	udelimiter_ = delimiter;
	return (delimiter == To() || delimiter == ToInclude());
}

//-------------------------------------------------------------------
// Method........: SetLowerValue/SetUpperValue
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......: Undefined::Float() is interpreted as +/- infinity.
// Revisions.....:
//===================================================================

bool
Interval::SetLowerValue(float value) {
	if (value == Undefined::Float())
		value = -FLT_MAX;
	lvalue_ = value;
	return true;
}

bool
Interval::SetUpperValue(float value) {
	if (value == Undefined::Float())
		value = FLT_MAX;
	uvalue_ = value;
	return true;
}

//-------------------------------------------------------------------
// Method........: Merge
// Author........: Aleksander 豩rn
// Date..........:
// Description...:
// Comments......: Interval validity assumed. Not thoroughly debugged.
// Revisions.....:
//===================================================================

bool
Interval::Merge(const Interval &interval) {

	// Determine new range.
	float lvalue = (GetLowerValue() < interval.GetLowerValue()) ? GetLowerValue() : interval.GetLowerValue();
	float uvalue = (GetUpperValue() > interval.GetUpperValue()) ? GetUpperValue() : interval.GetUpperValue();

	char ldelimiter = GetLowerDelimiter();
	char udelimiter = GetUpperDelimiter();

	// New delimiters?
	if (lvalue == interval.GetLowerValue() && interval.GetLowerDelimiter() == FromInclude())
		ldelimiter = FromInclude();

	if (uvalue == interval.GetUpperValue() && interval.GetUpperDelimiter() == ToInclude())
		udelimiter = ToInclude();

	return MakeInterval(ldelimiter, lvalue, uvalue, udelimiter);

}

//-------------------------------------------------------------------
// Property querying methods.
//===================================================================

//-------------------------------------------------------------------
// Method........: IsValid
// Author........: Aleksander 豩rn
// Date..........:
// Description...: Returns true if the interval defines a valid range.
// Comments......:
// Revisions.....:
//===================================================================

bool
Interval::IsValid() const {

	// Is the lvalue delimiter valid?
	if (GetLowerDelimiter() != From() && GetLowerDelimiter() != FromInclude())
		return false;

	// Is the uvalue delimiter valid?
	if (GetUpperDelimiter() != To() && GetUpperDelimiter() != ToInclude())
		return false;

	// Is the range clearly invalid?
	if (GetLowerValue() > GetUpperValue())
		return false;

	// The range may have degenerated into a point.
	if (GetLowerValue() == GetUpperValue()) {
		if (GetLowerDelimiter() != FromInclude() || GetUpperDelimiter() != ToInclude())
			return false;
	}

	return true;

}

//-------------------------------------------------------------------
// Method........: IsFinite/IsInfinite
// Author........: Aleksander 豩rn
// Date..........:
// Description...: Returns true if the interval is finite/infinite.
// Comments......: Interval validity assumed.
// Revisions.....:
//===================================================================

bool
Interval::IsFinite() const {
	return (GetLength() != FLT_MAX);
}

bool
Interval::IsInfinite() const {
	return !IsFinite();
}

//-------------------------------------------------------------------
// Method........: IsAbove
// Author........: Aleksander 豩rn
// Date..........:
// Description...: Returns true if this interval is "above" the input
//                 interval.
// Comments......: Interval validity assumed. Not thoroughly debugged.
// Revisions.....:
//===================================================================

bool
Interval::IsAbove(const Interval &interval) const {
	return ((GetLowerValue() > interval.GetUpperValue()) ||
		      (GetLowerValue() == interval.GetUpperValue() && !(GetLowerDelimiter() == FromInclude() && interval.GetUpperDelimiter() == ToInclude())));
}

//-------------------------------------------------------------------