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.

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Function Documentation

◆ _FormalATM_gn()

◆ _FormalATM_P0()

◆ acos_safe()

◆ almost_equals_alt()

◆ almost_equals_distance()

◆ almost_equals_radian() [1/2]

◆ almost_equals_radian() [2/2]

◆ almost_equals_time()

◆ almost_equals_xy()

◆ asin_safe()

◆ atan2_safe()

◆ bool2str()

◆ boolean2eps()

◆ contains() [1/2]

◆ contains() [2/2]

◆ discr()

◆ endsWith()

◆ eq()

◆ equals()

◆ equalsIgnoreCase()

◆ Farray() [1/3]

◆ Farray() [2/3]

◆ Farray() [3/3]

◆ fdln()

◆ Fm0()

◆ Fm1()

◆ Fm12()

◆ Fm16()

◆ Fm2()

◆ Fm2z()

◆ Fm3()

◆ Fm3z()

◆ Fm4()

◆ Fm6()

◆ Fm8()

◆ Fmi()

◆ FmLead()

◆ Fmui()

◆ Fmul()

◆ FmVec() [1/2]

◆ FmVec() [2/2]

◆ fp() [1/2]

◆ fp() [2/2]

◆ fpln() [1/2]

◆ fpln() [2/2]

◆ fsStr() [1/2]

◆ fsStr() [2/2]

◆ fvStr() [1/2]

◆ fvStr() [2/2]

◆ fvStr2() [1/2]

◆ fvStr2() [2/2]

◆ get_horizontal_accuracy()

◆ get_time_accuracy()

◆ get_vertical_accuracy()

◆ getProjection() [1/2]

◆ getProjection() [2/2]

◆ getProjectionType()

◆ getProjectionTypeFromString()

◆ gt()

◆ isLeftTurn()

◆ llabs()

◆ make() [1/2]

◆ make() [2/2]

◆ operator!=() [1/5]

◆ operator!=() [2/5]

◆ operator!=() [3/5]

◆ operator!=() [4/5]

◆ operator!=() [5/5]

◆ operator<() [1/4]

◆ operator<() [2/4]

◆ operator<() [3/4]

◆ operator<() [4/4]

◆ operator<<()