Eaagles::Basic Namespace Reference

Classes
class	LcBroadcastHandler
class	LcBoolean
class	LcCie
class	LcMonitorMetrics
class	LcCmy
class	LcColor
class	LcColorRotary
class	LcColorRotaryB
class	LcComponent
class	LcDecibel
class	LcFileReader
class	LcFloat
class	LcHls
class	LcHsv
class	LcHsva
class	LcIdent
class	LcInt
class	LcLatLon
class	LcLexical
class	Locus
class	LcLogger
class	LcMulticastHandler
class	LcNav
class	LcNetHandler
class	LcNumber
class	LcObject
class	LcAdd
class	LcSubtract
class	LcMultiply
class	LcDivide
class	LcPair
class	LcPairStream
class	RngStream
class	LcRand
class	UniformRand
class	NormalRand
class	ExponentialRand
class	LcRgb
class	LcRgba
class	LcSlotTable
class	LcStack
class	LcStatistic
class	LcStMach
class	LcString
class	LcTable
class	LcTable1
class	LcTable2
class	LcTable3
class	LcTable4
class	LcTable5
class	LcTcpHandler
class	Terrain
class	LcTimer
class	LcUpTimer
class	LcDownTimer
class	LcTransform
class	LcTranslation
class	LcRotation
class	LcScale
class	LcUdpHandler
class	LcYiq
Typedefs
typedef LcObject *(*)	ParserFormFunc (const char *formname)
typedef void(*)	StMachProc (LcObject *userValue)
Functions
bool	operator! (const LcBoolean &b)
bool	operator== (const LcBoolean &b1, const LcBoolean &b2)
bool	operator== (const bool b1, const LcBoolean &b2)
bool	operator== (const LcBoolean &b1, const bool b2)
bool	operator!= (const LcBoolean &b1, const LcBoolean &b2)
bool	operator!= (const bool b1, const LcBoolean &b2)
bool	operator!= (const LcBoolean &b1, const bool b2)
bool	operator && (const LcBoolean &b1, const LcBoolean &b2)
bool	operator && (const bool b1, const LcBoolean &b2)
bool	operator && (const LcBoolean &b1, const bool b2)
bool	operator|| (const LcBoolean &b1, const LcBoolean &b2)
bool	operator|| (const bool b1, const LcBoolean &b2)
bool	operator|| (const LcBoolean &b1, const bool b2)
std::istream &	operator>> (std::istream &sin, LcBoolean &n)
std::ostream &	operator<< (std::ostream &sout, const LcBoolean &n)
bool	operator== (const LcColor &c1, const LcColor &c2)
bool	operator!= (const LcColor &c1, const LcColor &c2)
	if (_event<=MAX_KEY_EVENT &&container()!=0)
LCreal	operator+ (const LcDecibel &n1, const LcDecibel &n2)
LCreal	operator+ (const LCreal n1, const LcDecibel &n2)
LCreal	operator+ (const LcDecibel &n1, const LCreal n2)
LCreal	operator- (const LcDecibel &n1, const LcDecibel &n2)
LCreal	operator- (const LCreal n1, const LcDecibel &n2)
LCreal	operator- (const LcDecibel &n1, const LCreal n2)
bool	operator== (const LcDecibel &n1, const LcDecibel &n2)
bool	operator== (const LCreal n1, const LcDecibel &n2)
bool	operator== (const LcDecibel &n1, const LCreal n2)
bool	operator!= (const LcDecibel &n1, const LcDecibel &n2)
bool	operator!= (const LCreal n1, const LcDecibel &n2)
bool	operator!= (const LcDecibel &n1, const LCreal n2)
bool	operator< (const LcDecibel &n1, const LcDecibel &n2)
bool	operator< (const LCreal n1, const LcDecibel &n2)
bool	operator< (const LcDecibel &n1, const LCreal n2)
bool	operator<= (const LcDecibel &n1, const LcDecibel &n2)
bool	operator<= (const LCreal n1, const LcDecibel &n2)
bool	operator<= (const LcDecibel &n1, const LCreal n2)
bool	operator> (const LcDecibel &n1, const LcDecibel &n2)
bool	operator> (const LCreal n1, const LcDecibel &n2)
bool	operator> (const LcDecibel &n1, const LCreal n2)
bool	operator>= (const LcDecibel &n1, const LcDecibel &n2)
bool	operator>= (const LCreal n1, const LcDecibel &n2)
bool	operator>= (const LcDecibel &n1, const LCreal n2)
std::istream &	operator>> (std::istream &sin, LcDecibel &n)
std::ostream &	operator<< (std::ostream &sout, const LcDecibel &n)
LCreal	operator+ (const LcFloat &n1, const LcFloat &n2)
LCreal	operator+ (const LCreal n1, const LcFloat &n2)
LCreal	operator+ (const LcFloat &n1, const LCreal n2)
LCreal	operator- (const LcFloat &n1, const LcFloat &n2)
LCreal	operator- (const LCreal n1, const LcFloat &n2)
LCreal	operator- (const LcFloat &n1, const LCreal n2)
LCreal	operator * (const LcFloat &n1, const LcFloat &n2)
LCreal	operator * (const LCreal n1, const LcFloat &n2)
LCreal	operator * (const LcFloat &n1, const LCreal n2)
LCreal	operator/ (const LcFloat &n1, const LcFloat &n2)
LCreal	operator/ (const LCreal n1, const LcFloat &n2)
LCreal	operator/ (const LcFloat &n1, const LCreal n2)
bool	operator== (const LcFloat &n1, const LcFloat &n2)
bool	operator== (const LCreal n1, const LcFloat &n2)
bool	operator== (const LcFloat &n1, const LCreal n2)
bool	operator!= (const LcFloat &n1, const LcFloat &n2)
bool	operator!= (const LCreal n1, const LcFloat &n2)
bool	operator!= (const LcFloat &n1, const LCreal n2)
bool	operator< (const LcFloat &n1, const LcFloat &n2)
bool	operator< (const LCreal n1, const LcFloat &n2)
bool	operator< (const LcFloat &n1, const LCreal n2)
bool	operator<= (const LcFloat &n1, const LcFloat &n2)
bool	operator<= (const LCreal n1, const LcFloat &n2)
bool	operator<= (const LcFloat &n1, const LCreal n2)
bool	operator> (const LcFloat &n1, const LcFloat &n2)
bool	operator> (const LCreal n1, const LcFloat &n2)
bool	operator> (const LcFloat &n1, const LCreal n2)
bool	operator>= (const LcFloat &n1, const LcFloat &n2)
bool	operator>= (const LCreal n1, const LcFloat &n2)
bool	operator>= (const LcFloat &n1, const LCreal n2)
std::istream &	operator>> (std::istream &sin, LcFloat &n)
std::ostream &	operator<< (std::ostream &sout, const LcFloat &n)
DLLEXP LcObject *	formFunc (const char *formname)
std::ostream &	operator<< (std::ostream &sout, const LcIdent &ident)
int	operator+ (const LcInt &n1, const LcInt &n2)
int	operator+ (const int n1, const LcInt &n2)
int	operator+ (const LcInt &n1, const int n2)
int	operator- (const LcInt &n1, const LcInt &n2)
int	operator- (const int n1, const LcInt &n2)
int	operator- (const LcInt &n1, const int n2)
int	operator * (const LcInt &n1, const LcInt &n2)
int	operator * (const int n1, const LcInt &n2)
int	operator * (const LcInt &n1, const int n2)
int	operator/ (const LcInt &n1, const LcInt &n2)
int	operator/ (const int n1, const LcInt &n2)
int	operator/ (const LcInt &n1, const int n2)
int	operator% (const LcInt &n1, const LcInt &n2)
int	operator% (const int n1, const LcInt &n2)
int	operator% (const LcInt &n1, const int n2)
bool	operator== (const LcInt &n1, const LcInt &n2)
bool	operator== (const int n1, const LcInt &n2)
bool	operator== (const LcInt &n1, const int n2)
bool	operator!= (const LcInt &n1, const LcInt &n2)
bool	operator!= (const int n1, const LcInt &n2)
bool	operator!= (const LcInt &n1, const int n2)
bool	operator< (const LcInt &n1, const LcInt &n2)
bool	operator< (const int n1, const LcInt &n2)
bool	operator< (const LcInt &n1, const int n2)
bool	operator<= (const LcInt &n1, const LcInt &n2)
bool	operator<= (const int n1, const LcInt &n2)
bool	operator<= (const LcInt &n1, const int n2)
bool	operator> (const LcInt &n1, const LcInt &n2)
bool	operator> (const int n1, const LcInt &n2)
bool	operator> (const LcInt &n1, const int n2)
bool	operator>= (const LcInt &n1, const LcInt &n2)
bool	operator>= (const int n1, const LcInt &n2)
bool	operator>= (const LcInt &n1, const int n2)
std::istream &	operator>> (std::istream &sin, LcInt &n)
std::ostream &	operator<< (std::ostream &sout, const LcInt &n)
	if (_msg!=0)
LcObject *	lcParser (const char *filename, ParserFormFunc func, int *numErrors=0)
double	MultModM (double a, double s, double c, double m)
void	MatVecModM (const double A[3][3], const double s[3], double v[3], double m)
void	MatMatModM (const double A[3][3], const double B[3][3], double C[3][3], double m)
void	MatTwoPowModM (const double A[3][3], double B[3][3], double m, long e)
void	MatPowModM (const double A[3][3], double B[3][3], double m, long n)
int	CheckSeed (const unsigned long seed[6])
LcString	operator+ (const LcString &s1, const LcString &s2)
LcString	operator+ (const char *s1, const LcString &s2)
LcString	operator+ (const LcString &s1, const char *s2)
bool	operator== (const LcString &s1, const LcString &s2)
bool	operator== (const char *s1, const LcString &s2)
bool	operator== (const LcString &s1, const char *s2)
bool	operator!= (const LcString &s1, const LcString &s2)
bool	operator!= (const char *s1, const LcString &s2)
bool	operator!= (const LcString &s1, const char *s2)
bool	operator< (const LcString &s1, const LcString &s2)
bool	operator< (const char *s1, const LcString &s2)
bool	operator< (const LcString &s1, const char *s2)
bool	operator<= (const LcString &s1, const LcString &s2)
bool	operator<= (const char *s1, const LcString &s2)
bool	operator<= (const LcString &s1, const char *s2)
bool	operator> (const LcString &s1, const LcString &s2)
bool	operator> (const char *s1, const LcString &s2)
bool	operator> (const LcString &s1, const char *s2)
bool	operator>= (const LcString &s1, const LcString &s2)
bool	operator>= (const char *s1, const LcString &s2)
bool	operator>= (const LcString &s1, const char *s2)
std::ostream &	operator<< (std::ostream &sout, const LcString &s)
std::istream &	operator>> (std::istream &sin, LcString &s)
Variables
	networkAddr
	networkMask
	luminance
	x
	y
	monitor
	red
	green
	blue
	phosphors
	whiteRGB
	whiteCIE
	cyan
	magenta
	yellow
	breakcolors
	breakpoints
	firstColor
	secondColor
	components
	select
	logger
	enableTimingStats
	printTimingStats
	freeze
return	_used
	pathname
	filename
	recordLength
DLLEXP	LcObject
	hue
	lightness
	saturation
	hue
	saturation
	value
	alpha
	direction
	degrees
	minutes
	seconds
	file
	path
	multicastGroup
	ttl
const double	ellipseA = 6378137
const double	ellipseAsq = ellipseA * ellipseA
const double	ellipseF = 1/298.257223563
const double	ellipseB = ellipseA * (1.0 - ellipseF)
const double	ellipseBsq = ellipseB * ellipseB
const double	ellipseAsqOverB = ellipseAsq / ellipseB
const double	ellipseE = ellipseF * (2.0 - ellipseF)
const double	ellipseC1 = (1.0 - ellipseF) * (1.0 - ellipseF)
	port
	sourcePort
	shared
	sendBuffSizeKb
	recvBuffSizeKb
	value
	n2
	n3
	n4
	n5
	n6
	n7
	n8
	n9
	n10
LcNumber *	_msg = dynamic_cast<LcNumber*>(obj)
DLLEXP	LcObject
	Seed
	Antithetic
	Min
	Mean
const double	m1 = 4294967087.0
const double	m2 = 4294944443.0
const double	norm = 1.0 / (m1 + 1.0)
const double	a12 = 1403580.0
const double	a13n = 810728.0
const double	a21 = 527612.0
const double	a23n = 1370589.0
const double	two17 = 131072.0
const double	two53 = 9007199254740992.0
const double	fact = 5.9604644775390625e-8
const double	InvA1 [3][3]
const double	InvA2 [3][3]
const double	A1p0 [3][3]
const double	A2p0 [3][3]
const double	A1p76 [3][3]
const double	A2p76 [3][3]
const double	A1p127 [3][3]
const double	A2p127 [3][3]
	red
	green
	blue
	alpha
	data
	extrapolate
	x
	y
	z
	w
	v
	ipAddress
	file
	path
	timerValue
	active
	x
	y
	z
	ipAddress
	y
	i
	q
DLLEXP	LcObject
DLLEXP	LcObject
DLLEXP	LcObject
DLLEXP	LcObject
DLLEXP	LcObject
DLLEXP	LcObject
DLLEXP	LcObject
DLLEXP	LcObject
DLLEXP	LcObject

---

Typedef Documentation

typedef LcObject*(*) Eaagles::Basic::ParserFormFunc(const char *formname)

typedef void(*) Eaagles::Basic::StMachProc(LcObject *userValue)

---

Function Documentation

int Eaagles::Basic::@69::CheckSeed

(

const unsigned long

seed[6]

)

[static]

DLLEXP LcObject * Eaagles::Basic::formFunc

(

const char *

formname

)

parser form function

Eaagles::Basic::if

(

_msg!

= 0

)

Eaagles::Basic::if

(

_event<=MAX_KEY_EVENT &&container()!

= 0

)

DLLEXP LcObject * Eaagles::Basic::lcParser	(	const char *	filename,
		ParserFormFunc	func,
		int *	numErrors = 0
	)

The LcParser class parses an input file and returns an LcObject that was constructed.

void Eaagles::Basic::@69::MatMatModM	(	const double	A[3][3],
		const double	B[3][3],
		double	C[3][3],
		double	m
	)			[static]

void Eaagles::Basic::@69::MatPowModM	(	const double	A[3][3],
		double	B[3][3],
		double	m,
		long	n
	)			[static]

void Eaagles::Basic::@69::MatTwoPowModM	(	const double	A[3][3],
		double	B[3][3],
		double	m,
		long	e
	)			[static]

void Eaagles::Basic::@69::MatVecModM	(	const double	A[3][3],
		const double	s[3],
		double	v[3],
		double	m
	)			[static]

double Eaagles::Basic::@69::MultModM	(	double	a,
		double	s,
		double	c,
		double	m
	)			[static]

bool Eaagles::Basic::operator &&	(	const LcBoolean &	b1,
		const bool	b2
	)			[inline]

And the value b2 to val of LcBoolean instance b1.

bool Eaagles::Basic::operator &&	(	const bool	b1,
		const LcBoolean &	b2
	)			[inline]

And the value b1 to val of LcBoolean instance b2.

bool Eaagles::Basic::operator &&	(	const LcBoolean &	b1,
		const LcBoolean &	b2
	)			[inline]

int Eaagles::Basic::operator *	(	const LcInt &	n1,
		const int	n2
	)			[inline]

int Eaagles::Basic::operator *	(	const int	n1,
		const LcInt &	n2
	)			[inline]

int Eaagles::Basic::operator *	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

LCreal Eaagles::Basic::operator *	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

Multiply value n2 to val of LcFloat n1 and return the sum.

LCreal Eaagles::Basic::operator *	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

Multiply value n1 to val of LcFloat n2 and return the sum.

LCreal Eaagles::Basic::operator *	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

Multiply the vals of LcFloat instances n1 & n2 and return the sum.

bool Eaagles::Basic::operator!

(

const LcBoolean &

b

)

[inline]

NOT operator: ! Returns the opposite value of the value passed in.

bool Eaagles::Basic::operator!=	(	const LcString &	s1,
		const char *	s2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const char *	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LcString &	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LcInt &	n1,
		const int	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const int	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LcDecibel &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LCreal	n1,
		const LcDecibel &	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LcDecibel &	n1,
		const LcDecibel &	n2
	)			[inline]

bool Eaagles::Basic::operator!=	(	const LcColor &	c1,
		const LcColor &	c2
	)

bool Eaagles::Basic::operator!=	(	const LcBoolean &	b1,
		const bool	b2
	)			[inline]

Return a true if the value b2 is not equal to val of LcBoolean instance b1.

bool Eaagles::Basic::operator!=	(	const bool	b1,
		const LcBoolean &	b2
	)			[inline]

Return a true if the value b1 is not equal to val of LcBoolean instance b2.

bool Eaagles::Basic::operator!=	(	const LcBoolean &	b1,
		const LcBoolean &	b2
	)			[inline]

Return a true if the val's of the two LcBoolean instances are not equal.

int Eaagles::Basic::operator%	(	const LcInt &	n1,
		const int	n2
	)			[inline]

int Eaagles::Basic::operator%	(	const int	n1,
		const LcInt &	n2
	)			[inline]

int Eaagles::Basic::operator%	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

LcString Eaagles::Basic::operator+	(	const LcString &	s1,
		const char *	s2
	)			[inline]

LcString Eaagles::Basic::operator+	(	const char *	s1,
		const LcString &	s2
	)			[inline]

LcString Eaagles::Basic::operator+	(	const LcString &	s1,
		const LcString &	s2
	)			[inline]

int Eaagles::Basic::operator+	(	const LcInt &	n1,
		const int	n2
	)			[inline]

int Eaagles::Basic::operator+	(	const int	n1,
		const LcInt &	n2
	)			[inline]

int Eaagles::Basic::operator+	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

LCreal Eaagles::Basic::operator+	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

Add value n2 to val of LcFloat n1 and return the sum.

LCreal Eaagles::Basic::operator+	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

Add value n1 to val of LcFloat n2 and return the sum.

LCreal Eaagles::Basic::operator+	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

Add vals of LcFloat instances n1 & n2 and return the sum.

LCreal Eaagles::Basic::operator+	(	const LcDecibel &	n1,
		const LCreal	n2
	)			[inline]

Add value n2 to val of LcDecibel n1 and return the sum.

LCreal Eaagles::Basic::operator+	(	const LCreal	n1,
		const LcDecibel &	n2
	)			[inline]

Add value n1 to val of LcDecibel n2 and return the sum.

LCreal Eaagles::Basic::operator+	(	const LcDecibel &	n1,
		const LcDecibel &	n2
	)			[inline]

Add vals of LcDecibel instances n1 & n2 and return the sum.

int Eaagles::Basic::operator-	(	const LcInt &	n1,
		const int	n2
	)			[inline]

int Eaagles::Basic::operator-	(	const int	n1,
		const LcInt &	n2
	)			[inline]

int Eaagles::Basic::operator-	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

LCreal Eaagles::Basic::operator-	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

Subtract value n2 from val of LcFloat n1 and return the difference.

LCreal Eaagles::Basic::operator-	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

Subtract value n1 from val of LcFloat n2 and return the difference.

LCreal Eaagles::Basic::operator-	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

Subtract the vals of LcFloat instances n1 & n2 and return the difference.

LCreal Eaagles::Basic::operator-	(	const LcDecibel &	n1,
		const LCreal	n2
	)			[inline]

Subtract value n2 from val of LcDecibel n1 and return the difference.

LCreal Eaagles::Basic::operator-	(	const LCreal	n1,
		const LcDecibel &	n2
	)			[inline]

Subtract value n1 from val of LcDecibel n2 and return the difference.

LCreal Eaagles::Basic::operator-	(	const LcDecibel &	n1,
		const LcDecibel &	n2
	)			[inline]

Subtract the vals of LcDecibel instances n1 & n2 and return the difference.

int Eaagles::Basic::operator/	(	const LcInt &	n1,
		const int	n2
	)			[inline]

int Eaagles::Basic::operator/	(	const int	n1,
		const LcInt &	n2
	)			[inline]

int Eaagles::Basic::operator/	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

LCreal Eaagles::Basic::operator/	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

Divide val of LcFloat instance n1 by val n2 and return the quotient, unless val n2 is equal to zero, then return a zero and send an error message

LCreal Eaagles::Basic::operator/	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

Divide val n1 by LcFloat instance n2 and return the quotient, unless LcFloat instance n2 is equal to zero, then return a zero and send an error message

LCreal Eaagles::Basic::operator/	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

Divide the val of LcFloat instance n1 by LcFloat instance n2 and return the quotient, unless LcFloat instance n2 is equal to zero, then return a zero and send an error message

bool Eaagles::Basic::operator<	(	const LcString &	s1,
		const char *	s2
	)			[inline]

bool Eaagles::Basic::operator<	(	const char *	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LcString &	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LcInt &	n1,
		const int	n2
	)			[inline]

bool Eaagles::Basic::operator<	(	const int	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LcDecibel &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LCreal	n1,
		const LcDecibel &	n2
	)			[inline]

bool Eaagles::Basic::operator<	(	const LcDecibel &	n1,
		const LcDecibel &	n2
	)			[inline]

std::ostream& Eaagles::Basic::operator<<	(	std::ostream &	sout,
		const LcString &	s
	)			[inline]

output stream operator <<

std::ostream& Eaagles::Basic::operator<<	(	std::ostream &	sout,
		const LcInt &	n
	)			[inline]

output stream operator: <<

std::ostream& Eaagles::Basic::operator<<	(	std::ostream &	sout,
		const LcIdent &	ident
	)

std::ostream& Eaagles::Basic::operator<<	(	std::ostream &	sout,
		const LcFloat &	n
	)			[inline]

output stream operator: << Is C++ equivalent

std::ostream& Eaagles::Basic::operator<<	(	std::ostream &	sout,
		const LcDecibel &	n
	)			[inline]

output stream operator: <<

std::ostream& Eaagles::Basic::operator<<	(	std::ostream &	sout,
		const LcBoolean &	n
	)			[inline]

output stream operator: <<

bool Eaagles::Basic::operator<=	(	const LcString &	s1,
		const char *	s2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const char *	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LcString &	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LcInt &	n1,
		const int	n2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const int	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LcDecibel &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LCreal	n1,
		const LcDecibel &	n2
	)			[inline]

bool Eaagles::Basic::operator<=	(	const LcDecibel &	n1,
		const LcDecibel &	n2
	)			[inline]

bool Eaagles::Basic::operator==	(	const LcString &	s1,
		const char *	s2
	)			[inline]

bool Eaagles::Basic::operator==	(	const char *	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator==	(	const LcString &	s1,
		const LcString &	s2
	)			[inline]

Comparison operators: ==, !=, <, <=, >, and >=.

bool Eaagles::Basic::operator==	(	const LcInt &	n1,
		const int	n2
	)			[inline]

bool Eaagles::Basic::operator==	(	const int	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator==	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

Comparison operators: ==, !=, <, <=, >, and >=.

bool Eaagles::Basic::operator==	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator==	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

Return a true or a false after comparing value n1 and LcFloat n2.val.

bool Eaagles::Basic::operator==	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

Comparison operators: ==, !=, <, <=, >, and >= Return a true or a false after comparing LcFloat n1.val & n2.val

bool Eaagles::Basic::operator==	(	const LcDecibel &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator==	(	const LCreal	n1,
		const LcDecibel &	n2
	)			[inline]

Return a true or a false after comparing value n1 and LcDecibel n2.val.

bool Eaagles::Basic::operator==	(	const LcDecibel &	n1,
		const LcDecibel &	n2
	)			[inline]

Comparison operators: ==, !=, <, <=, >, and >= Return a true or a false after comparing LcDecibel n1.val & n2.val

bool Eaagles::Basic::operator==	(	const LcColor &	c1,
		const LcColor &	c2
	)

bool Eaagles::Basic::operator==	(	const LcBoolean &	b1,
		const bool	b2
	)			[inline]

Return a true if the value b2 is equal to val of LcBoolean instance b1.

bool Eaagles::Basic::operator==	(	const bool	b1,
		const LcBoolean &	b2
	)			[inline]

Return a true if the value b1 is equal to val of LcBoolean instance b2.

bool Eaagles::Basic::operator==	(	const LcBoolean &	b1,
		const LcBoolean &	b2
	)			[inline]

Equal/not-equal operators: == and != Return a true if the val's of the two LcBoolean instances are equal.

bool Eaagles::Basic::operator>	(	const LcString &	s1,
		const char *	s2
	)			[inline]

bool Eaagles::Basic::operator>	(	const char *	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LcString &	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LcInt &	n1,
		const int	n2
	)			[inline]

bool Eaagles::Basic::operator>	(	const int	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LcDecibel &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LCreal	n1,
		const LcDecibel &	n2
	)			[inline]

bool Eaagles::Basic::operator>	(	const LcDecibel &	n1,
		const LcDecibel &	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LcString &	s1,
		const char *	s2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const char *	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LcString &	s1,
		const LcString &	s2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LcInt &	n1,
		const int	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const int	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LcInt &	n1,
		const LcInt &	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LcFloat &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LCreal	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LcFloat &	n1,
		const LcFloat &	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LcDecibel &	n1,
		const LCreal	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LCreal	n1,
		const LcDecibel &	n2
	)			[inline]

bool Eaagles::Basic::operator>=	(	const LcDecibel &	n1,
		const LcDecibel &	n2
	)			[inline]

std::istream& Eaagles::Basic::operator>>	(	std::istream &	sin,
		LcString &	s
	)			[inline]

input stream operator >>

std::istream& Eaagles::Basic::operator>>	(	std::istream &	sin,
		LcInt &	n
	)			[inline]

input stream operator: >>

std::istream& Eaagles::Basic::operator>>	(	std::istream &	sin,
		LcFloat &	n
	)			[inline]

input stream operator: >> Is C++ equivalent

std::istream& Eaagles::Basic::operator>>	(	std::istream &	sin,
		LcDecibel &	n
	)			[inline]

input stream operator: >>

std::istream& Eaagles::Basic::operator>>	(	std::istream &	sin,
		LcBoolean &	n
	)			[inline]

input stream operator: >>

bool Eaagles::Basic::operator||	(	const LcBoolean &	b1,
		const bool	b2
	)			[inline]

Or the value b2 to val of LcBoolean instance b1.

bool Eaagles::Basic::operator||	(	const bool	b1,
		const LcBoolean &	b2
	)			[inline]

Or the value b1 to val of LcBoolean instance b2.

bool Eaagles::Basic::operator||	(	const LcBoolean &	b1,
		const LcBoolean &	b2
	)			[inline]

Or the val's of the two LcBoolean instances.

---

Variable Documentation

LcNumber* Eaagles::Basic::_msg = dynamic_cast<LcNumber*>(obj)

return Eaagles::Basic::_used

const double Eaagles::Basic::a12 = 1403580.0 [static]

const double Eaagles::Basic::a13n = 810728.0 [static]

const double Eaagles::Basic::A1p0[3][3] [static]

Initial value:

 {
       {       0.0,        1.0,       0.0 },
       {       0.0,        0.0,       1.0 },
       { -810728.0,  1403580.0,       0.0 }
       }

const double Eaagles::Basic::A1p127[3][3] [static]

Initial value:

 {
       {    2427906178.0, 3580155704.0,  949770784.0 },
       {     226153695.0, 1230515664.0, 3580155704.0 },
       {    1988835001.0,  986791581.0, 1230515664.0 }
       }

const double Eaagles::Basic::A1p76[3][3] [static]

Initial value:

 {
       {      82758667.0, 1871391091.0, 4127413238.0 },
       {    3672831523.0,   69195019.0, 1871391091.0 },
       {    3672091415.0, 3528743235.0,   69195019.0 }
       }

const double Eaagles::Basic::a21 = 527612.0 [static]

const double Eaagles::Basic::a23n = 1370589.0 [static]

const double Eaagles::Basic::A2p0[3][3] [static]

Initial value:

 {
       {        0.0,        1.0,       0.0 },
       {        0.0,        0.0,       1.0 },
       { -1370589.0,        0.0,  527612.0 }
       }

const double Eaagles::Basic::A2p127[3][3] [static]

Initial value:

 {
       {    1464411153.0,  277697599.0, 1610723613.0 },
       {      32183930.0, 1464411153.0, 1022607788.0 },
       {    2824425944.0,   32183930.0, 2093834863.0 }
       }

const double Eaagles::Basic::A2p76[3][3] [static]

Initial value:

 {
       {    1511326704.0, 3759209742.0, 1610795712.0 },
       {    4292754251.0, 1511326704.0, 3889917532.0 },
       {    3859662829.0, 4292754251.0, 3708466080.0 }
       }

Eaagles::Basic::active

Eaagles::Basic::alpha

Eaagles::Basic::alpha

Eaagles::Basic::Antithetic

Eaagles::Basic::blue

Eaagles::Basic::blue

Eaagles::Basic::breakcolors

Eaagles::Basic::breakpoints

Eaagles::Basic::components

Eaagles::Basic::cyan

Eaagles::Basic::data

Eaagles::Basic::degrees

Eaagles::Basic::direction

const double Eaagles::Basic::ellipseA = 6378137

const double Eaagles::Basic::ellipseAsq = ellipseA * ellipseA

const double Eaagles::Basic::ellipseAsqOverB = ellipseAsq / ellipseB

const double Eaagles::Basic::ellipseB = ellipseA * (1.0 - ellipseF)

const double Eaagles::Basic::ellipseBsq = ellipseB * ellipseB

const double Eaagles::Basic::ellipseC1 = (1.0 - ellipseF) * (1.0 - ellipseF)

const double Eaagles::Basic::ellipseE = ellipseF * (2.0 - ellipseF)

const double Eaagles::Basic::ellipseF = 1/298.257223563

Eaagles::Basic::enableTimingStats

Eaagles::Basic::extrapolate

const double Eaagles::Basic::fact = 5.9604644775390625e-8 [static]

Eaagles::Basic::file

Eaagles::Basic::file

Eaagles::Basic::filename

Eaagles::Basic::firstColor

Eaagles::Basic::freeze

Eaagles::Basic::green

Eaagles::Basic::green

Eaagles::Basic::hue

Eaagles::Basic::hue

Eaagles::Basic::i

const double Eaagles::Basic::InvA1[3][3] [static]

Initial value:

 {          
       { 184888585.0,   0.0,  1945170933.0 },
       {         1.0,   0.0,           0.0 },
       {         0.0,   1.0,           0.0 }
       }

const double Eaagles::Basic::InvA2[3][3] [static]

Initial value:

 {          
       {      0.0,  360363334.0,  4225571728.0 },
       {      1.0,          0.0,           0.0 },
       {      0.0,          1.0,           0.0 }
       }

Eaagles::Basic::ipAddress

Eaagles::Basic::ipAddress

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

class DLLEXP Eaagles::Basic::LcObject

Eaagles::Basic::lightness

Eaagles::Basic::logger

Eaagles::Basic::luminance

const double Eaagles::Basic::m1 = 4294967087.0 [static]

const double Eaagles::Basic::m2 = 4294944443.0 [static]

Eaagles::Basic::magenta

Eaagles::Basic::Mean

Eaagles::Basic::Min

Eaagles::Basic::minutes

Eaagles::Basic::monitor

Eaagles::Basic::multicastGroup

Eaagles::Basic::n10

Eaagles::Basic::n2

Eaagles::Basic::n3

Eaagles::Basic::n4

Eaagles::Basic::n5

Eaagles::Basic::n6

Eaagles::Basic::n7

Eaagles::Basic::n8

Eaagles::Basic::n9

Eaagles::Basic::networkAddr

Eaagles::Basic::networkMask

const double Eaagles::Basic::norm = 1.0 / (m1 + 1.0) [static]

Eaagles::Basic::path

Eaagles::Basic::path

Eaagles::Basic::pathname

Eaagles::Basic::phosphors

Eaagles::Basic::port

Eaagles::Basic::printTimingStats

Eaagles::Basic::q

Eaagles::Basic::recordLength

Eaagles::Basic::recvBuffSizeKb

Eaagles::Basic::red

Eaagles::Basic::red

Eaagles::Basic::saturation

Eaagles::Basic::saturation

Eaagles::Basic::secondColor

Eaagles::Basic::seconds

Eaagles::Basic::Seed

Eaagles::Basic::select

Eaagles::Basic::sendBuffSizeKb

Eaagles::Basic::shared

Eaagles::Basic::sourcePort

Eaagles::Basic::timerValue

Eaagles::Basic::ttl

const double Eaagles::Basic::two17 = 131072.0 [static]

const double Eaagles::Basic::two53 = 9007199254740992.0 [static]

Eaagles::Basic::v

Eaagles::Basic::value

Eaagles::Basic::value

Eaagles::Basic::w

Eaagles::Basic::whiteCIE

Eaagles::Basic::whiteRGB

Eaagles::Basic::x

Eaagles::Basic::x

Eaagles::Basic::x

Eaagles::Basic::y

Eaagles::Basic::y

Eaagles::Basic::y

Eaagles::Basic::y

Eaagles::Basic::yellow

Eaagles::Basic::z

Eaagles::Basic::z

---