larcfm Namespace Reference

Classes
class	ACCoRDConfig
class	AircraftState
class	Alerter
class	AlertingHysteresis
class	AlertingMofN
class	AlertLevels
class	AlertThresholds
class	AziEquiProjection
class	Bands
class	BandsCore
class	BandsHysteresis
class	BandsMofN
class	BandsRange
class	BandsRegion
class	BoundingBox
class	BoundingRectangle
class	CD2D
class	CD3D
class	CD3DTable
class	CDCylinder
class	CDII
class	CDIICore
class	CDIIPolygon
class	CDPolycarp
class	CDPolyIter
class	CDPolyIter2D
class	CDSI
class	CDSICore
class	CDSIPolygon
class	CDSS
class	CDSSCore
class	CDSSCyl
class	ColoredValue
class	ColorValue
class	ConflictBandsTwoTimes
class	ConflictData
class	Constants
class	CoordinationFilter
class	CR3D
class	Criteria
class	CriteriaCore
class	CriticalVectors
class	CriticalVectors2D
class	CriticalVectorsSI
class	CRSS
class	CRSSConfig
class	Daidalus
class	DaidalusAltBands
class	DaidalusCore
class	DaidalusDirBands
class	DaidalusFileWalker
class	DaidalusHsBands
class	DaidalusIntegerBands
class	DaidalusParameters
class	DaidalusRealBands
class	DaidalusVsBands
class	DataServer
class	DCPAUrgencyStrategy
class	Debug
class	DebugSupport
class	DensityGrid
class	DensityGridAStarSearch
class	DensityGridMovingPolys
class	DensityGridMovingPolysEst
class	DensityGridSearch
class	DensityGridTimed
class	DensityGridTimedSearch
class	Detection3D
class	Detection3DAcceptor
class	Detection3DParameterReader
class	Detection3DParameterWriter
class	Detection3DResAcceptor
class	Detection3DSUM
class	DetectionPolygon
class	DetectionPolygonAcceptor
class	DetectionPolygonParameterReader
class	DetectionPolygonParameterWriter
class	DetectionPolygonResAcceptor
class	ENUProjection
class	ErrorLog
class	ErrorReporter
class	FilePushTransmitter
class	FixedAircraftUrgencyStrategy
class	Function
class	General3DState
class	GeneralPlan
class	GeneralPlanWriter
class	GeneralState
class	GeneralStateReader
class	GeneralStateWriter
class	GenericBands
class	GenericDHStateBands
class	GenericIntentBands
class	GenericStateBands
class	GreatCircle
class	GsPlan
class	Horizontal
class	HysteresisData
class	IndexLevelT
class	Integerval
class	IntentBands
class	IntentBandsCore
class	Interval
class	IntervalSet
class	KinematicAltBands
class	KinematicBands
class	KinematicBandsCore
class	KinematicBandsParameters
class	KinematicGsBands
class	KinematicIntegerBands
class	KinematicMultiBands
class	KinematicRealBands
class	Kinematics
class	KinematicsDist
class	KinematicsLatLon
class	KinematicsPosition
class	KinematicTrkBands
class	KinematicVsBands
class	LatLonAlt
class	LossData
class	MofN
class	MovingPolygon2D
class	MovingPolygon3D
class	NavPoint
class	NoneUrgencyStrategy
class	OrthographicProjection
class	OutputList
class	Pair
class	ParameterAcceptor
class	ParameterData
class	ParameterEntry
class	ParameterProvider
class	ParameterReader
class	ParameterTable
class	Plan
class	PlanIO
class	PlanReader
class	PlanUtil
class	PlanWriter
class	Point
class	Poly2D
class	Poly2DLLCore
class	Poly3D
class	Poly3DLL
class	Polycarp3D
class	PolycarpAcceptablePolygon
class	PolycarpContain
class	PolycarpDetection
class	PolycarpDoubleQuadratic
class	PolycarpEdgeProximity
class	PolycarpQuadMinmax
class	PolycarpResolution
class	PolyPath
class	PolyReader
class	PolyUtil
class	Position
class	PositionUtil
class	Priority
class	PriorityCore
class	ProjectedKinematics
class	Projection
class	Quad
class	RecoveryInformation
class	Route
class	SafetyBuffers
class	SeparatedInput
class	SeparatedOutput
class	SequenceReader
class	SimpleMovingPoly
class	SimpleNoPolarProjection
class	SimplePoly
class	SimpleProjection
class	StateReader
class	StateVector
class	StateWriter
struct	stringCaseInsensitive
class	SUMData
class	TangentLine
class	TargetUrgency
class	TCAS2D
class	TCAS3D
class	TCASTable
class	TcpData
class	TrafficCoreState
class	TrafficState
class	TrajGen
class	TrajTemplates
class	Transmitter
class	Triple
class	TripleBands
class	Tuple5
class	Tuple6
class	TurnGeneration
class	Units
class	UrgencyStrategy
class	Util
class	Vect2
class	Vect3
class	Vect4
class	VectFuns
class	Velocity
class	Vertical
class	WCV_HZ
class	WCV_TAUMOD
class	WCV_TAUMOD_SUM
class	WCV_TCOA
class	WCV_TCPA
class	WCV_TEP
class	WCV_tvar
class	WCV_Vertical
class	WCV_VMOD
class	WCVTable
class	WeatherUtil
class	Wx

Typedefs
typedef int	ProjectionType

Enumerations
enum	{   UNKNOWN_PROJECTION , SIMPLE , SIMPLE_NO_POLAR , ENU ,   AZIEQUI , ORTHO }

Functions
void	set_time_accuracy (double acc)
void	set_horizontal_accuracy (double acc)
void	set_vertical_accuracy (double acc)
double	get_time_accuracy ()
double	get_horizontal_accuracy ()
double	get_vertical_accuracy ()
bool	almost_equals_time (double t1, double t2)
bool	almost_equals_xy (double x1, double y1, double x2, double y2)
bool	almost_equals_distance (double d)
bool	almost_equals_radian (double d1, double d2)
bool	almost_equals_radian (double d)
bool	almost_equals_alt (double a1, double a2)
template<typename T >
T	parameter_data (const ParameterData &p, const std::string &key, Function< const std::string &, T > &f)
std::string	Fmi (int v)
std::string	Fmui (unsigned int v)
std::string	Fmul (unsigned long v)
std::string	Fm0 (double v)
std::string	Fm1 (double v)
std::string	Fm2 (double v)
std::string	Fm2z (double v)
std::string	Fm3 (double v)
std::string	Fm3z (double v)
std::string	Fm4 (double v)
std::string	Fm6 (double v)
std::string	Fm8 (double v)
std::string	Fm12 (double v)
std::string	Fm16 (double v)
std::string	FmLead (int i, int minLength)
std::string	FmPrecision (double v)
std::string	FmPrecision (double v, int precision)
std::string	FmPrecision (double v, int precision, bool includeTrailingZeros)
std::string	Fmb (bool b)
std::string	FmVec (Vect2 v)
std::string	FmVec (Vect3 v)
std::string	padLeft (std::string s, int n)
std::string	padRight (std::string s, int n)
std::string	bool2str (bool b)
void	fpln (const std::string &str)
void	fp (const std::string &str)
void	fpln (std::ostream *os, const std::string &str)
void	fp (std::ostream *os, const std::string &str)
void	fdln (const std::string &str)
std::string	fsStr (const Vect2 &s)
std::string	fsStr (const Vect3 &s)
std::string	fsStrNP (const Vect3 &v, int prec, const std::string &xunits, const std::string &yunits, const std::string &zunits)
std::string	fsStrNP (const Vect3 &s, int prec)
std::string	fsStr8NP (const Vect3 &s)
std::string	fsStr15NP (const Vect3 &s)
std::string	fvStr (const Vect2 &s)
std::string	fvStr (const Vect3 &s)
std::string	fvStr2 (const Vect2 &v)
std::string	fvStr2 (const Vect3 &v)
std::string	FmPair (const std::pair< int, int > &p)
std::string	FmPair (const std::pair< double, double > &p)
std::string	FmTriple (const Triple< int, int, int > &p)
std::string	FmTriple (const Triple< double, double, double > &p)
std::string	Fobj (const std::vector< int > &v)
std::string	Fobj (const std::vector< double > &v)
std::string	Fobj (const std::vector< std::string > &v)
std::string	Fobj (const std::vector< std::pair< int, int > > &v)
std::string	Fobj (const std::vector< std::pair< double, double > > &v)
std::string	Fobj (const std::vector< Triple< int, int, int > > &v)
std::string	Fobj (const std::vector< Triple< double, double, double > > &v)
std::string	Fobj (const std::map< std::string, std::string > &v)
std::string	Fobj (const std::map< int, int > &v)
std::string	Fobj (const std::map< int, std::string > &v)
std::string	Fobj (const std::map< std::string, int > &v)
std::string	Fobj (const std::map< double, double > &v)
std::string	Fobj (const std::map< double, std::string > &v)
std::string	Fobj (const std::map< std::string, double > &v)
std::string	list2str (const std::vector< std::string > &l, const std::string &delimiter)
std::string	Farray (int const v[], int sz)
std::string	Farray (double const v[], int sz)
std::string	Farray (std::string const v[], int sz)
std::string	double2PVS (double val)
std::string	double2PVS (double val, int precision)
template<typename L , typename R >
Pair< L, R >	make (const L &left, const R &right)
template<typename L , typename R >
bool	operator== (const Pair< L, R > &t1, const Pair< L, R > &t2)
template<typename L , typename R >
bool	operator!= (const Pair< L, R > &t1, const Pair< L, R > &t2)
std::ostream &	operator<< (std::ostream &os, const Plan &f)
EuclideanProjection	getProjection (double lat, double lon, double alt)
EuclideanProjection	getProjection (const LatLonAlt &lla)
double	projectionConflictRange (double lat, double accuracy)
double	projectionMaxRange ()
void	setProjectionType (ProjectionType t)
ProjectionType	getProjectionTypeFromString (std::string s)
ProjectionType	getProjectionType ()
template<typename T1 , typename T2 , typename T3 , typename T4 >
bool	operator== (const Quad< T1, T2, T3, T4 > &q1, const Quad< T1, T2, T3, T4 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 >
bool	operator!= (const Quad< T1, T2, T3, T4 > &q1, const Quad< T1, T2, T3, T4 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 >
bool	operator< (const Quad< T1, T2, T3, T4 > &q1, const Quad< T1, T2, T3, T4 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 >
bool	operator> (const Quad< T1, T2, T3, T4 > &q1, const Quad< T1, T2, T3, T4 > &q2)
Vect2	polar_xy (const LatLonAlt &lla, bool north)
LatLonAlt	polar_inverse (const Vect2 &v, double alt, bool north)
std::vector< std::string >	split (const std::string &str, const std::string &delimiters)
std::vector< std::string >	split_empty (const std::string &str, const std::string &delimiters)
std::vector< std::string >	split_string_empty (const std::string &str, const std::string &delimiter)
std::vector< std::string >	split_regex (const std::string &str, const std::string &delimiters)
bool	matches (const std::string &s, const std::string &rgx_str)
std::string	substring (const std::string &s, int begin, int end)
std::string	substring (const std::string &s, int begin)
void	trim (std::string &s, const std::string &drop=" \t\r\n")
std::string	trimCopy (const std::string &s, const std::string &drop=" \t\r\n")
std::string	toLowerCase (const std::string &str)
std::string	toUpperCase (const std::string &str)
bool	equals (const std::string &, const std::string &)
bool	equalsIgnoreCase (const std::string &, const std::string &)
void	replace (std::string &s, char c1, char c2)
std::string	replace (const std::string &s, const std::string &s1, const std::string &s2)
bool	contains (const std::vector< std::string > &v, const std::string &s)
bool	contains (const std::string &str, const std::string &sub)
bool	startsWith (const std::string &str, const std::string &prefix)
bool	endsWith (const std::string &str, const std::string &suffix)
int	parseInt (const std::string &str)
bool	operator< (const TrafficCoreState &lhs, const TrafficCoreState &rhs)
template<typename L , typename C , typename R >
Triple< L, C, R >	make (const L &left, const C &center, const R &right)
template<typename L , typename C , typename R >
bool	operator== (const Triple< L, R, C > &t1, const Triple< L, R, C > &t2)
template<typename L , typename C , typename R >
bool	operator!= (const Triple< L, R, C > &t1, const Triple< L, R, C > &t2)
template<typename L , typename C , typename R >
bool	operator< (const Triple< L, R, C > &t1, const Triple< L, R, C > &t2)
template<typename L , typename C , typename R >
bool	operator> (const Triple< L, R, C > &t1, const Triple< L, R, C > &t2)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
bool	operator== (const Tuple5< T1, T2, T3, T4, T5 > &q1, const Tuple5< T1, T2, T3, T4, T5 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
bool	operator!= (const Tuple5< T1, T2, T3, T4, T5 > &q1, const Tuple5< T1, T2, T3, T4, T5 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
bool	operator< (const Tuple5< T1, T2, T3, T4, T5 > &q1, const Tuple5< T1, T2, T3, T4, T5 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >
bool	operator> (const Tuple5< T1, T2, T3, T4, T5 > &q1, const Tuple5< T1, T2, T3, T4, T5 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
bool	operator== (const Tuple6< T1, T2, T3, T4, T5, T6 > &q1, const Tuple6< T1, T2, T3, T4, T5, T6 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
bool	operator!= (const Tuple6< T1, T2, T3, T4, T5, T6 > &q1, const Tuple6< T1, T2, T3, T4, T5, T6 > &q2)
template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >
bool	operator< (const Tuple6< T1, T2, T3, T4, T5, T6 > &q1, const Tuple6< T1, T2, T3, T4, T5, T6 > &q2)
double	_FormalATM_gn ()
double	_FormalATM_P0 ()
template<class T >
std::string	to_string (const T &t)
template<typename T >
void	remove (T a[], int i, int size)
double	sq (const double x)
INT64FM	llabs (const INT64FM x)
	‍** More...
double	sqrt_safe (const double x)
double	atan2_safe (const double y, const double x)
double	asin_safe (double x)
double	acos_safe (double x)
double	discr (const double a, const double b, const double c)
double	root (const double a, const double b, const double c, int eps)
double	root2b (const double a, const double b, const double c, const int eps)
int	sign (const double x)
double	to_pi (double rad)
double	to_360 (double deg)
double	to_2pi (double rad)
double	to_pi2_cont (double rad)
double	to_180 (double deg)
double	trkgs2vx (double trk, double gs)
double	trkgs2vy (double trk, double gs)
Vect2	trkgs2v (double trk, double gs)
double	tau_vv (const Vect2 &s, const Vect2 &v, const double B, const double T)
double	omega_vv (const Vect2 &s, const Vect2 &v, const double D, const double B, const double T)
void	setCoreDetection (Detection3D *c)
Horizontal	losr_gs_iter_aux (const Vect3 &s, const Vect3 &vo, const Vect3 &vi, double minrelgs, double mings, double maxgs, double step, int epsh)
bool	eq (double a, double b, double e)
bool	gt (double a, double b, double e)
double	R (const Vect2 &sp, double D)
bool	closed_region_3D (const Vect3 &s, const Vect3 &p, int eps, int dir, const Vect3 &v, double D, double H)
bool	horizontal_los (const Vect2 &s, double D)
bool	vertical_los (double sz, double H)
std::list< double >	verticalSpeeds1D (const double sz, const double viz, const double H, const double B, const double T)
double	fm_nz (double v, int precision)
string	padLeft (string s, int n)
string	padRight (string s, int n)
void	fpln (const string &str)
void	fp (const string &str)
void	fpln (ostream *os, const string &str)
void	fp (ostream *os, const string &str)
void	fdln (const string &str)
std::vector< std::string >	toStringList (const Vect3 &v, const string &unitx, const string &unity, const string &unitz, int precision, bool units)
string	fsStrNP (const Vect3 &v, int prec, const string &xunits, const string &yunits, const string &zunits)
Vect2	Q (const Vect2 &s, double D, int eps)
bool	isLeftTurn (const Vect2 &from, const Vect2 &to)
int	boolean2eps (bool b)
double	V1 (double voz, double a1, double t)
	‍** returns Pair that contains position and velocity at time t due to level out maneuver More...
double	S1 (double voz, double a1, double t)
double	T3 (double voz, double a1)
double	S3 (double voz, double a1)
const LossData &	EMPTY ()
std::vector< Position >	genList_l (const std::vector< LatLonAlt > &lList)
std::vector< Position >	genList_v (const std::vector< Vect2 > &vList)
vector< string >	split (const string &str, const string &delimiters)
vector< string >	split_empty (const string &str, const string &delimiters)
vector< string >	split_string_empty (const string &str, const string &delimiter)
bool	matches (const string &s, const string &rgx_str)
string	substring (const string &s, int begin, int end)
string	substring (const string &s, int begin)
void	trim (string &s, const string &drop)
std::string	trimCopy (const string &s, const string &drop)
string	toLowerCase (const string &strToConvert)
string	toUpperCase (const string &strToConvert)
bool	equals (const string &s1, const string &s2)
bool	equalsIgnoreCase (const string &s1, const string &s2)
double	InitTangentLineX (const Vect2 &s, const double D, const int eps)
double	InitTangentLineY (const Vect2 &s, const double D, const int eps)
Vertical	vs_at (const double sz, const double t, const int eps, const double H)
Vertical	vs_only (const Vect3 &s, const Vect2 &v, const double t, const int eps, const double D, const double H)

Variables
const double	em6DegtoMeter = 0.15
const double	minDist = 1E-9
const double	gsAccel = 2
const double	vsAccel = 1
const double	bankAngle = Units::from("deg", 10)

Detailed Description

CriteriaCore.cpp

State-based Implicit Criteria

Copyright (c) 2011-2020 United States Government as represented by the National Aeronautics and Space Administration. No copyright is claimed in the United States under Title 17, U.S.Code. All Other Rights Reserved.

Objects of class "Daidalus" compute the conflict bands using kinematic single-maneuver projections of the ownship and linear preditions of (multiple) traffic aircraft positions. The bands consist of ranges of guidance maneuvers: direction angles, horizontal speeds, vertical speeds, and altitude.

An assumption of the bands information is that the traffic aircraft do not maneuver. If the ownship immediately executes a NONE guidance maneuver, then the new path is conflict free (within a lookahead time of the parameter). If the ownship immediately executes a NEAR/MID/FAR guidance maneuver and no traffic aircraft maneuvers, then there will corresponding alert within the corresponding alerting level thresholds.

If recovery bands are set and the ownship is in a violation path, loss of separation recovery bands and recovery times are computed for each type of maneuver. If the ownship immediately executes a RECOVERY guidance maneuver, then the new path is conflict-free after the recovery time. Furthermore, the recovery time is the minimum time for which there exists a kinematic conflict-free maneuver in the future.

Note that in the case of geodetic coordinates this version of bands performs an internal projection of the coordinates and velocities into the Euclidean frame (see Util/Projection). Accuracy may be reduced if the traffic plans involve any segments longer than Util.Projection.projectionConflictRange(lat,acc), and an error will be logged if the distance between traffic and ownship exceeds Util.Projection.projectionMaxRange() at any point in the lookahead range.

Disclaimers: The formal proofs of the core algorithms use real numbers, however these implementations use floating point numbers, so numerical differences could result. In addition, the geodetic computations include certain inaccuracies, especially near the poles.

The basic usage is

Daidalus daa = new Daidalus();
daa.loadFromFile(<configurationfile>);

...
daa.setOwnshipState(position of ownship, velocity of ownship);
daa.addTrafficState(position of (one) traffic aircraft, velocity of traffic);
daa.addTrafficState(position of (another) traffic aircraft, velocity of traffic);
...add other traffic aircraft...

for (int i = 0; i < daa.horizontalDirectionBandsLength(); i++ ) {
   interval = daa.horizontalDirectionIntervalAt(i);
   lower_ang = intrval.low;
   upper_ang = intrval.up;
   regionType = daa.horizontalDirectionRegionAt(i);
   ..do something with this information..
}

...similar for horizontal speed and vertical speed...

Encapsulates a geometric polygon. The polygon is defined in terms of its vertex coordinates. This implementation assumes a simply connected polygon. The Polygon is otherwise quite general allowing multiply connected regions. The class provides a containment test for points and uses bounding rectangles to speed up computations.

Projection from Spherical Earth to Euclidean Plane

Authors: George Hagen NASA Langley Research Center Ricky Butler NASA Langley Research Center Jeff Maddalon NASA Langley Research Center Anthony Narkawicz NASA Langley Research Center

Holding area for universal projection information. All projection objects should be retrieved using these functions.

Copyright (c) 2011-2020 United States Government as represented by the National Aeronautics and Space Administration. No copyright is claimed in the United States under Title 17, U.S.Code. All Other Rights Reserved.

A basic polygon that describes a volume. This volume has a flat bottom and top (specified as altitude values). Points describe the cross-section area vertices in a consistently clockwise (or consistently counter-clockwise) manner. The cross-section need not be convex, but an "out of order" listing of the vertices will result in edges that cross, and will cause several calculations to fail (with no warning).

A SimplePoly sets the altitude for all its points to be the bottom altitude, while the top is stored elsewhere as a single value. The exact position for "top" vertices is computed on demand.

The cross-section must be a simple polygon, that is it allows for non-convex areas, but vertices and edges may not overlap or cross. Vertices may be ordered in either a clockwise or counterclockwise manner.

(A vertex-complete polygon allows for vertices and edges to overlap but not cross, while a general polygon allows for edges to cross.)

Point indices are based on the order they are added.

Note: polygon support is experimental and the interface is subject to change!

Function Documentation

_FormalATM_gn()

double larcfm::_FormalATM_gn

(

)

See Units::gn

_FormalATM_P0()

double larcfm::_FormalATM_P0

(

)

See Units::P0

acos_safe()

double larcfm::acos_safe

(

double

x

)

Deprecated:

{Use Util:: version.} a safe (won't return NaN or throw exceptions) of arc-cosine

almost_equals_alt()

bool larcfm::almost_equals_alt	(	double	a1,
		double	a2
	)

Deprecated:

{Use Constants:: version} Return true, if these two altitudes are within the vertical accuracy of each other

almost_equals_distance()

bool larcfm::almost_equals_distance

(

double

d

)

Deprecated:

{Use Constants:: version} Return true, if this distance [m] is within the horizontal accuracy of zero

almost_equals_radian() [1/2]

bool larcfm::almost_equals_radian

(

double

d

)

Deprecated:

{Use Constants:: version} Return true, if this angle [rad] is within the horizontal accuracy of zero

almost_equals_radian() [2/2]

bool larcfm::almost_equals_radian	(	double	d1,
		double	d2
	)

Deprecated:

{Use Constants:: version} Return true, if these two angles [rad] are within the horizontal accuracy of each other

almost_equals_time()

bool larcfm::almost_equals_time	(	double	t1,
		double	t2
	)

Deprecated:

{Use Constants:: version} Return true, if these two times are within the time accuracy of each other

almost_equals_xy()

bool larcfm::almost_equals_xy	(	double	x1,
		double	y1,
		double	x2,
		double	y2
	)

Deprecated:

{Use Constants:: version} Return true, if these two positions [m] within the horizontal accuracy of each other

asin_safe()

double larcfm::asin_safe

(

double

x

)

Deprecated:

{Use Util:: version.} a safe (won't return NaN or throw exceptions) of arc-sine

atan2_safe()

double larcfm::atan2_safe	(	const double	y,
		const double	x
	)

Deprecated:

{Use Util:: version.} a safe (won't return NaN or throw exceptions) of arc-tangent

bool2str()

string larcfm::bool2str

(

bool

b

)

Returns true/false string

boolean2eps()

int larcfm::boolean2eps

(

bool

b

)

Converts a "true" to a +1 value, a "false" to a -1

contains() [1/2]

bool larcfm::contains	(	const std::string &	str,
		const std::string &	sub
	)

Is the given string sub a substring of str?

contains() [2/2]

bool larcfm::contains	(	const std::vector< std::string > &	v,
		const std::string &	s
	)

Is the given string in the list?

discr()

double larcfm::discr	(	const double	a,
		const double	b,
		const double	c
	)

Deprecated:

{Use Util:: version.} Discriminant of a quadratic

endsWith()

bool larcfm::endsWith	(	const std::string &	str,
		const std::string &	suffix
	)

Does str end with the suffix?

eq()

bool larcfm::eq	(	double	a,
		double	b,
		double	e
	)

An algebraic way to determine a*sqrt(b) = e.

Returns

true, if a*sqrt(b) = e

equals()

bool larcfm::equals	(	const std::string &	,
		const std::string &
	)

return true if two strings are the same values

equalsIgnoreCase()

bool larcfm::equalsIgnoreCase	(	const std::string &	,
		const std::string &
	)

return true if two strings are the same values, ignoring case

Farray() [1/3]

string larcfm::Farray	(	double const	v[],
		int	sz
	)

Print double array

Farray() [2/3]

string larcfm::Farray	(	int const	v[],
		int	sz
	)

Print int array

Farray() [3/3]

string larcfm::Farray	(	std::string const	v[],
		int	sz
	)

Print string array

fdln()

void larcfm::fdln

(

const std::string &

str

)

send string to the error console with a "carriage return"

Fm0()

string larcfm::Fm0

(

double

v

)

Format a double with 0 decimal places

Fm1()

string larcfm::Fm1

(

double

v

)

Format a double with 1 decimal place

Fm12()

string larcfm::Fm12

(

double

v

)

Format a double with 12 decimal place

Fm16()

string larcfm::Fm16

(

double

v

)

Format a double with 16 decimal place

Fm2()

string larcfm::Fm2

(

double

v

)

Format a double with 2 decimal place

Fm2z()

string larcfm::Fm2z

(

double

v

)

Format a double with 2 decimal place, filled with zeros

Fm3()

string larcfm::Fm3

(

double

v

)

Format a double with 3 decimal place

Fm3z()

string larcfm::Fm3z

(

double

v

)

Format a double with 3 decimal place, filled with zeros

Fm4()

string larcfm::Fm4

(

double

v

)

Format a double with 4 decimal place

Fm6()

string larcfm::Fm6

(

double

v

)

Format a double with 6 decimal place

Fm8()

string larcfm::Fm8

(

double

v

)

Format a double with 8 decimal place

Fmi()

string larcfm::Fmi

(

int

v

)

Format an int with 0 decimal places

FmLead()

string larcfm::FmLead	(	int	i,
		int	minLength
	)

Format an integer to have at least minLength digits, prepending zeros as necessary

Fmui()

string larcfm::Fmui

(

unsigned int

v

)

Format an unsigned in with 0 decimal places

Fmul()

string larcfm::Fmul

(

unsigned long

v

)

Format an unsigned long with 0 decimal places

FmVec() [1/2]

string larcfm::FmVec

(

Vect2

v

)

Format a vector

FmVec() [2/2]

string larcfm::FmVec

(

Vect3

v

)

Format a vector

fp() [1/2]

void larcfm::fp

(

const std::string &

str

)

send a string to the console without a "carriage return"

fp() [2/2]

void larcfm::fp	(	std::ostream *	os,
		const std::string &	str
	)

send a string to the console without a "carriage return"

fpln() [1/2]

void larcfm::fpln

(

const std::string &

str

)

send string to the console with a "carriage return"

fpln() [2/2]

void larcfm::fpln	(	std::ostream *	os,
		const std::string &	str
	)

send string to the console with a "carriage return"

fsStr() [1/2]

string larcfm::fsStr

(

const Vect2 &

s

)

Format a position vector

fsStr() [2/2]

string larcfm::fsStr

(

const Vect3 &

s

)

Format a position vector

fvStr() [1/2]

string larcfm::fvStr

(

const Vect2 &

s

)

Format a velocity vector as a Euclidean velocity

fvStr() [2/2]

string larcfm::fvStr

(

const Vect3 &

s

)

Format a velocity vector as a Euclidean velocity

fvStr2() [1/2]

string larcfm::fvStr2

(

const Vect2 &

v

)

Format a velocity vector as a polar velocity

fvStr2() [2/2]

string larcfm::fvStr2

(

const Vect3 &

v

)

Format a velocity vector as a polar velocity

get_horizontal_accuracy()

double larcfm::get_horizontal_accuracy

(

)

Deprecated:

{Use Constants:: version} Return the horizontal accuracy value

get_time_accuracy()

double larcfm::get_time_accuracy

(

)

Deprecated:

{Use Constants:: version} Return the time accuracy value

get_vertical_accuracy()

double larcfm::get_vertical_accuracy

(

)

Deprecated:

{Use Constants:: version} Return the vertical accuracy value

getProjection() [1/2]

EuclideanProjection larcfm::getProjection

(

const LatLonAlt &

lla

)

Deprecated:

{Use Projection:: version.} Returns a new projection for the current type with the given reference point.

getProjection() [2/2]

EuclideanProjection larcfm::getProjection	(	double	lat,
		double	lon,
		double	alt
	)

Deprecated:

{Use Projection:: version.} Returns a new projection for the current type with the given reference point.

getProjectionType()

ProjectionType larcfm::getProjectionType

(

)

Deprecated:

{Use Projection:: version.} Return the current ProjectionType

getProjectionTypeFromString()

ProjectionType larcfm::getProjectionTypeFromString

(

std::string

s

)

Deprecated:

{Use Projection:: version.} Given a string representation of a ProjectionType, return the ProjectionType

gt()

bool larcfm::gt	(	double	a,
		double	b,
		double	e
	)

An algebraic way to determine a*sqrt(b) > e.

Returns

true, if a*sqrt(b) > e

isLeftTurn()

bool larcfm::isLeftTurn	(	const Vect2 &	from,
		const Vect2 &	to
	)

true iff the trajectory following "from" to "to" is a left turn "from" is your current vector of travel, "to" is your goal vector of travel

llabs()

INT64FM larcfm::llabs

(

const INT64FM

x

)

Deprecated:

{Use Util:: version.} return the absolute value

make() [1/2]

template<typename L , typename C , typename R >

Triple< L, C, R > larcfm::make	(	const L &	left,
		const C &	center,
		const R &	right
	)

Make a Triple

Parameters

left	first element of tuple
center	second element of tuple
right	third element of tuple
<L>	Type of the first element of the tuple
<C>	Type of the second element of the tuple
<R>	Type of the third element of the tuple

Returns

new triple

make() [2/2]

template<typename L , typename R >

Pair< L, R > larcfm::make	(	const L &	left,
		const R &	right
	)

Make a Pair

Parameters

left	left element
right	right element
<L>	Type of leftmost element
<R>	Type of rightmost element

Returns

pair

operator!=() [1/5]

template<typename L , typename R >

bool larcfm::operator!=	(	const Pair< L, R > &	t1,
		const Pair< L, R > &	t2
	)

Are these two Pairs unequal?

operator!=() [2/5]

template<typename T1 , typename T2 , typename T3 , typename T4 >

bool larcfm::operator!=	(	const Quad< T1, T2, T3, T4 > &	q1,
		const Quad< T1, T2, T3, T4 > &	q2
	)

Are these two Quad objects unequal?

operator!=() [3/5]

template<typename L , typename C , typename R >

bool larcfm::operator!=	(	const Triple< L, R, C > &	t1,
		const Triple< L, R, C > &	t2
	)

Are these two Triples unequal?

operator!=() [4/5]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >

bool larcfm::operator!=	(	const Tuple5< T1, T2, T3, T4, T5 > &	q1,
		const Tuple5< T1, T2, T3, T4, T5 > &	q2
	)

Are these two Tuple5 objects unequal?

operator!=() [5/5]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >

bool larcfm::operator!=	(	const Tuple6< T1, T2, T3, T4, T5, T6 > &	q1,
		const Tuple6< T1, T2, T3, T4, T5, T6 > &	q2
	)

Are these two Tuple6 objects unequal?

operator<() [1/4]

template<typename T1 , typename T2 , typename T3 , typename T4 >

bool larcfm::operator<	(	const Quad< T1, T2, T3, T4 > &	q1,
		const Quad< T1, T2, T3, T4 > &	q2
	)

ordering

operator<() [2/4]

template<typename L , typename C , typename R >

bool larcfm::operator<	(	const Triple< L, R, C > &	t1,
		const Triple< L, R, C > &	t2
	)

ordering

operator<() [3/4]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >

bool larcfm::operator<	(	const Tuple5< T1, T2, T3, T4, T5 > &	q1,
		const Tuple5< T1, T2, T3, T4, T5 > &	q2
	)

ordering

operator<() [4/4]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >

bool larcfm::operator<	(	const Tuple6< T1, T2, T3, T4, T5, T6 > &	q1,
		const Tuple6< T1, T2, T3, T4, T5, T6 > &	q2
	)

ordering

operator<<()

std::ostream & larcfm::operator<<	(	std::ostream &	os,
		const Plan &	f
	)

Stream output for plans

operator==() [1/5]

template<typename L , typename R >

bool larcfm::operator==	(	const Pair< L, R > &	t1,
		const Pair< L, R > &	t2
	)

Are these two Pairs equal?

operator==() [2/5]

template<typename T1 , typename T2 , typename T3 , typename T4 >

bool larcfm::operator==	(	const Quad< T1, T2, T3, T4 > &	q1,
		const Quad< T1, T2, T3, T4 > &	q2
	)

Are these two Quad objects equal?

operator==() [3/5]

template<typename L , typename C , typename R >

bool larcfm::operator==	(	const Triple< L, R, C > &	t1,
		const Triple< L, R, C > &	t2
	)

Are these two Triples equal?

operator==() [4/5]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >

bool larcfm::operator==	(	const Tuple5< T1, T2, T3, T4, T5 > &	q1,
		const Tuple5< T1, T2, T3, T4, T5 > &	q2
	)

Are these two Tuple5 objects equal?

operator==() [5/5]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 , typename T6 >

bool larcfm::operator==	(	const Tuple6< T1, T2, T3, T4, T5, T6 > &	q1,
		const Tuple6< T1, T2, T3, T4, T5, T6 > &	q2
	)

Are these two Tuple6 objects equal?

operator>() [1/3]

template<typename T1 , typename T2 , typename T3 , typename T4 >

bool larcfm::operator>	(	const Quad< T1, T2, T3, T4 > &	q1,
		const Quad< T1, T2, T3, T4 > &	q2
	)

ordering

operator>() [2/3]

template<typename L , typename C , typename R >

bool larcfm::operator>	(	const Triple< L, R, C > &	t1,
		const Triple< L, R, C > &	t2
	)

ordering

operator>() [3/3]

template<typename T1 , typename T2 , typename T3 , typename T4 , typename T5 >

bool larcfm::operator>	(	const Tuple5< T1, T2, T3, T4, T5 > &	q1,
		const Tuple5< T1, T2, T3, T4, T5 > &	q2
	)

ordering

padLeft()

std::string larcfm::padLeft	(	std::string	s,
		int	n
	)

Return a string 'n' long with 's' left-justified

padRight()

std::string larcfm::padRight	(	std::string	s,
		int	n
	)

Return a string 'n' long with 's' right-justified

parseInt()

int larcfm::parseInt

(

const std::string &

str

)

parse a string into an integer

polar_inverse()

LatLonAlt larcfm::polar_inverse	(	const Vect2 &	v,
		double	alt,
		bool	north
	)

Deprecated:

{Used SimpleProjection:: version.} Invert a projection, using the pole as a reference point.

polar_xy()

Vect2 larcfm::polar_xy	(	const LatLonAlt &	lla,
		bool	north
	)

Deprecated:

{Used SimpleProjection:: version.} Return a projection with the pole as a reference point.

projectionConflictRange()

double larcfm::projectionConflictRange	(	double	lat,
		double	accuracy
	)

Deprecated:

{Use Projection:: version.} Geodetic projections into the Euclidean frame, for various reasons, tend to lose accuracy over long distances or when close to the poles. This can be countered by examining shorter segments at a time.
This is already done in Detector and Stratway, but not in any other tools. For CDII, it is best to break up the ownship's plan in this way. For CDSI and IntentBands, it is better to break up the traffic in this way.

This return an estimate on the suggested maximum segment size, depending on the current projection.

Parameters

lat	- latitude [radians]
accuracy	- desired accuracy (allowable error) [m]

Returns

the maximum length of a trajectory segment at the given latitude that preserves the desired accuracy.

projectionMaxRange()

double larcfm::projectionMaxRange

(

)

Deprecated:

{Use Projection:: version.} This is a range about which the projection will completely break down and start producing nonsensical answers. Attempting to use the projection at ranges greater than this is an error state (at ranges less than this but greater than the conflictRange, it may still be unacceptably inaccurate, however).

Returns

maximum range for the projection

Q()

Vect2 larcfm::Q	(	const Vect2 &	s,
		double	D,
		int	eps
	)

Q function from ACCoRD.TangentLine. Returns the point on the circle (with 0,0 origin) that is tangent with the outside point

Parameters

s	vertex point
D	radius of the circle
eps	direction of turn (+1 is turn LEFT, -1 is turn RIGHT in he absolute frame)

Returns

tangent point on the circle, or an INVALID vector if the vertex is within the circle

remove()

template<typename T >

void larcfm::remove	(	T	a[],
		int	i,
		int	size
	)

Remove element i from the array

replace() [1/2]

std::string larcfm::replace	(	const std::string &	s,
		const std::string &	s1,
		const std::string &	s2
	)

Replaces all occurrences of s1 with s2 in string s

replace() [2/2]

void larcfm::replace	(	std::string &	s,
		char	c1,
		char	c2
	)

Replaces all occurrences of c1 with c2 in string s

root()

double larcfm::root	(	const double	a,
		const double	b,
		const double	c,
		int	eps
	)

Deprecated:

{Use Util:: version.} Quadratic equation

root2b()

double larcfm::root2b	(	const double	a,
		const double	b,
		const double	c,
		const int	eps
	)

Deprecated:

{Use Util:: version.} root2b(a,b,c,eps) = root(a,2*b,c,eps)

set_horizontal_accuracy()

void larcfm::set_horizontal_accuracy

(

double

acc

)

Deprecated:

{Use Constants:: version} Set the horizontal accuracy value. This value means any two positions that are within this value of each other are considered the same [m].

set_time_accuracy()

void larcfm::set_time_accuracy

(

double

acc

)

Deprecated:

{Use Constants:: version} Set the time accuracy value. This value means any two times that are within this value of each other are considered the same [s].

set_vertical_accuracy()

void larcfm::set_vertical_accuracy

(

double

acc

)

Deprecated:

{Use Constants:: version} Set the vertical accuracy value. This value means any two positions that are within this value of each other are considered the same [m].

setCoreDetection()

void larcfm::setCoreDetection

(

Detection3D *

c

)

Experimental. You are responsible for deleting c after this call.

setProjectionType()

void larcfm::setProjectionType

(

ProjectionType

t

)

Deprecated:

{Use Projection:: version.} Set the projection to a new type. This is a global change.

sign()

int larcfm::sign

(

const double

x

)

Deprecated:

{Use Util:: version.} Returns +1 if the arguement is positive or 0, -1 otherwise

split()

std::vector< std::string > larcfm::split	(	const std::string &	str,
		const std::string &	delimiters
	)

return a vector of strings, split from a list of delimiters in str. The pattern is not a regular expression, instead it is a delimiter represented as a string.

split_empty()

std::vector< std::string > larcfm::split_empty	(	const std::string &	str,
		const std::string &	delimiters
	)

return a vector of strings, split from a list of delimiters in str. Allows empty strings

split_regex()

vector< string > larcfm::split_regex	(	const std::string &	str,
		const std::string &	delimiters
	)

return a vector of strings, split from str based on the pattern given as a regular expression.

split_string_empty()

std::vector< std::string > larcfm::split_string_empty	(	const std::string &	str,
		const std::string &	delimiter
	)

return a vector of strings, split from str based on the string. Allows empty strings

sq()

double larcfm::sq

(

const double

x

)

Deprecated:

{Use Util:: version.} Square

sqrt_safe()

double larcfm::sqrt_safe

(

const double

x

)

Deprecated:

{Use Util:: version.} a safe (won't return NaN or throw exceptions) of square root

startsWith()

bool larcfm::startsWith	(	const std::string &	str,
		const std::string &	prefix
	)

Does str start with the prefix?

substring() [1/2]

std::string larcfm::substring	(	const std::string &	s,
		int	begin
	)

a C++ substring method that behaves more like Java's String.subString method. the beginning index is inclusive, and the ending index is exclusive.

substring() [2/2]

std::string larcfm::substring	(	const std::string &	s,
		int	begin,
		int	end
	)

a C++ substring method that behaves more like Java's String.subString method. the beginning index is inclusive, and the ending index is exclusive.

to_180()

double larcfm::to_180

(

double

deg

)

Deprecated:

{Use Util:: version.} Converts deg degrees to the range (-180, 180].

Parameters

deg

Degrees

Returns

deg in the range (-180, 180].

to_2pi()

double larcfm::to_2pi

(

double

rad

)

Deprecated:

{Use Util:: version.} Converts rad radians to the range [0, 2*pi].

Parameters

rad

Radians

Returns

rad in the range [-0, 2*pi).

to_360()

double larcfm::to_360

(

double

deg

)

Deprecated:

{Use Util:: version.} Converts deg degrees to the range [0, 360).

Parameters

deg

Degrees

Returns

deg in the range [0, 360).

to_pi()

double larcfm::to_pi

(

double

rad

)

Deprecated:

{Use Util:: version.} Converts rad radians to the range (-pi, pi].

Parameters

rad

Radians

Returns

rad in the range [-pi, pi].

to_pi2_cont()

double larcfm::to_pi2_cont

(

double

rad

)

Deprecated:

{Use Util:: version.} Converts rad radians to the range [-Math.PI/2, Math.PI/2). This function is continuous, so to_pi2_cont(PI/2+eps) equals PI/2-eps.

Parameters

rad

Radians

Returns

rad in the range [-Math.PI/2, Math.PI/2).

to_string()

template<class T >

std::string larcfm::to_string ( const T &  t )

inline

Convert arbitrary parameter to a string

toLowerCase()

std::string larcfm::toLowerCase

(

const std::string &

str

)

return an all lower case copy of str

toUpperCase()

std::string larcfm::toUpperCase

(

const std::string &

str

)

return an all upper case copy of str

trim()

void larcfm::trim	(	std::string &	s,
		const std::string &	drop = " \t\r\n"
	)

remove specified characters from beginning & end of string s

trimCopy()

std::string larcfm::trimCopy	(	const std::string &	s,
		const std::string &	drop = " \t\r\n"
	)

remove specified characters from beginning & end of string s

trkgs2v()

Vect2 larcfm::trkgs2v	(	double	trk,
		double	gs
	)

Deprecated:

{Use Velocity:: version.} Return the 2-dimensional Euclidean vector for velocity given the track and ground speed. The track angle is assumed to use the radians from true North-clockwise convention.

trkgs2vx()

double larcfm::trkgs2vx	(	double	trk,
		double	gs
	)

Deprecated:

{Use Velocity:: version.} Return the x component of velocity given the track and ground speed. The track angle is assumed to use the radians from true North-clockwise convention.

trkgs2vy()

double larcfm::trkgs2vy	(	double	trk,
		double	gs
	)

Deprecated:

{Use Velocity:: version.} Return the y component of velocity given the track and ground speed. The track angle is assumed to use the radians from true North-clockwise convention.

V1()

double larcfm::V1	(	double	voz,
		double	a1,
		double	t
	)

‍** This version prioritizes being able to reach an altitude at all and then achieving the specified climb rate.