ast::detail Namespace Reference

Functions
template<class AstMapT , class MapT >
AstMapT *	polyTranImpl (MapT const &mapping, bool forward, double acc, double maxacc, int maxorder, std::vector< double > const &lbnd, std::vector< double > const &ubnd)
	Call astPolyTran to set (or replace) one direction of a polynomial transform with a fit based on the other direction. More...
FrameDict	makeFrameDict (FrameSet const &frameSet)
	Make a FrameDict from a copy of a FrameSet. More...
void	annulAstObject (AstObject *object)
	A wrapper around astAnnul; intended as a custom deleter for std::unique_ptr. More...
template<typename T1 , typename T2 >
void	assertEqual (T1 val1, std::string const &descr1, T2 val2, std::string const &descr2)
void	astBadToNan (std::vector< double > &p)
	Replace AST__BAD with a quiet NaN in a vector. More...
void	astBadToNan (ast::Array2D const &arr)
	Replace AST__BAD with a quiet NaN in a 2-D array. More...
std::string	formatAxisAttr (std::string const &name, int axis)
	Format an axis-specific attribute by appending the axis index. More...
bool	isSeries (AstCmpMap const *cmpMap)
	Return true if the compound map is in series. More...
std::string	getClassName (AstObject const *rawObj)
	Get the AST class name, changing CmpMap to SeriesMap or ParallelMap as appropriate. More...
double	safeDouble (double val)
	Return a double value after checking status and replacing AST__BAD with nan More...
std::string	stringToUpper (std::string const &str)
	Return a copy of a string in which all characters are uppercase. More...
const char *	source ()
	Source function that allows astChannel to source from a Stream. More...
void	sink (const char *cstr)
	Sink function that allows astChannel to sink to a Stream. More...
template AstChebyMap *	polyTranImpl< AstChebyMap > (ChebyMap const &, bool, double, double, int, std::vector< double > const &, std::vector< double > const &)
template AstPolyMap *	polyTranImpl< AstPolyMap > (PolyMap const &, bool, double, double, int, std::vector< double > const &, std::vector< double > const &)

Function Documentation

annulAstObject()

void ast::detail::annulAstObject ( AstObject *  object )

inline

A wrapper around astAnnul; intended as a custom deleter for std::unique_ptr.

Definition at line 40 of file utils.h.

                                              {
    if (object != nullptr) {
        astAnnul(object);
        assertOK();
    }
}

assertEqual()

template<typename T1 , typename T2 >

void ast::detail::assertEqual ( T1  val1, std::string const &  descr1, T2  val2, std::string const &  descr2  )

inline

Definition at line 48 of file utils.h.

                                                                                            {
    if (val1 != val2) {
        std::ostringstream os;
        os << descr1 << " = " << val1 << " != " << descr2 << " = " << val2;
        throw std::invalid_argument(os.str());
    }
}

astBadToNan() [1/2]

void ast::detail::astBadToNan ( std::vector< double > &  p )

inline

Replace AST__BAD with a quiet NaN in a vector.

Definition at line 59 of file utils.h.

                                              {
    for (auto &val : p) {
        if (val == AST__BAD) {
            val = std::numeric_limits<double>::quiet_NaN();
        }
    }
}

astBadToNan() [2/2]

void ast::detail::astBadToNan

(

ast::Array2D const &

arr

)

Replace AST__BAD with a quiet NaN in a 2-D array.

Definition at line 27 of file utils.cc.

                                        {
    for (auto i = arr.begin(); i != arr.end(); ++i) {
        for (auto j = i->begin(); j != i->end(); ++j) {
            if (*j == AST__BAD) {
                *j = std::numeric_limits<double>::quiet_NaN();
            }
        }
    }
}

formatAxisAttr()

std::string ast::detail::formatAxisAttr ( std::string const &  name, int  axis  )

inline

Format an axis-specific attribute by appending the axis index.

Parameters

[in]	name	Attribute name
[in]	axis	Axis index, starting at 1

Returns

"<name>(<axis>)"

Definition at line 79 of file utils.h.

                                                                 {
    std::stringstream os;
    os << name << "(" << axis << ")";
    return os.str();
}

getClassName()

std::string ast::detail::getClassName

(

AstObject const *

rawObj

)

Get the AST class name, changing CmpMap to SeriesMap or ParallelMap as appropriate.

Parameters

[in]

rawObj

Raw AST object pointer

Definition at line 37 of file utils.cc.

                                                {
    std::string name = astGetC(rawObj, "Class");
    assertOK();
    if (name != "CmpMap") {
        return name;
    }
    bool series = isSeries(reinterpret_cast<AstCmpMap const *>(rawObj));
    return series ? "SeriesMap" : "ParallelMap";
}

isSeries()

bool ast::detail::isSeries

(

AstCmpMap const *

cmpMap

)

Return true if the compound map is in series.

Definition at line 47 of file utils.cc.

                                       {
    AstMapping *rawMap1;
    AstMapping *rawMap2;
    int series, invert1, invert2;
    astDecompose(cmpMap, &rawMap1, &rawMap2, &series, &invert1, &invert2);
    astAnnul(rawMap1);
    astAnnul(rawMap2);
    assertOK();
    return series;
}

makeFrameDict()

FrameDict ast::detail::makeFrameDict

(

FrameSet const &

frameSet

)

Make a FrameDict from a copy of a FrameSet.

This exists purely to test FrameDict(FrameSet const &) from Python, as the standard pybind11 wrapper isn't sufficient to exercise a bug that was found.

Definition at line 44 of file testUtils.h.

                                                   {
    return FrameDict(frameSet);
}

polyTranImpl()

template<class AstMapT , class MapT >

AstMapT * ast::detail::polyTranImpl	(	MapT const &	mapping,
		bool	forward,
		double	acc,
		double	maxacc,
		int	maxorder,
		std::vector< double > const &	lbnd,
		std::vector< double > const &	ubnd
	)

Call astPolyTran to set (or replace) one direction of a polynomial transform with a fit based on the other direction.

Template Parameters

AstMapT	AST mapping class: one of AstChebyMap or AstPolyMap
MapT	Corresponding astshim class: one of ast::ChebyMap or ast::PolyMap; this template parameter is second because it can always be deduced.

Parameters

[in]	mapping
[in]	forward	If true the forward transformation is replaced. Otherwise the inverse transformation is replaced.
[in]	acc	The target accuracy, expressed as a geodesic distance within the ChebyMap's input space (if forward is false) or output space (if forward is true).
[in]	maxacc	The maximum allowed accuracy for an acceptable polynomial, expressed as a geodesic distance within the ChebyMap's input space (if forward is false) or output space (if forward is true).
[in]	maxorder	The maximum allowed polynomial order. This is one more than the maximum power of either input axis. So for instance, a value of 3 refers to a quadratic polynomial. Note, cross terms with total powers greater than or equal to maxorder are not inlcuded in the fit. So the maximum number of terms in each of the fitted polynomials is maxorder*(maxorder + 1)/2.
[in]	lbnd	A vector holding the lower bounds of a rectangular region within the ChebyMap's input space (if forward is false) or output space (if forward is true). The new polynomial will be evaluated over this rectangle. The length should equal getNIn() or getNOut(), depending on forward.
[in]	ubnd	A vector holding the upper bounds of a rectangular region within the ChebyMap's input space (if forward is false) or output space (if forward is true). The new polynomial will be evaluated over this rectangle. The length should equal getNIn() or getNOut(), depending on forward.

Exceptions

std::invalid_argument

if the size of lbnd or ubnd does not match getNIn() (if forward false) or getNOut() (if forward true).

Definition at line 30 of file polyMapUtils.cc.

                                                                                    {
    // desired size of lbnd and ubnd
    auto const bndSize = static_cast<unsigned int>(forward ? mapping.getNOut() : mapping.getNIn());

    if (lbnd.size() != bndSize) {
        std::ostringstream os;
        os << "lbnd.size() = " << lbnd.size() << " != " << bndSize << " = "
           << (forward ? "getNOut()" : "getNIn()");
        throw std::invalid_argument(os.str());
    }
    if (ubnd.size() != bndSize) {
        std::ostringstream os;
        os << "ubnd.size() = " << ubnd.size() << " != " << bndSize << " = "
           << (forward ? "getNOut()" : "getNIn()");
        throw std::invalid_argument(os.str());
    }

    void *outRawMap = astPolyTran(mapping.getRawPtr(), static_cast<int>(forward), acc, maxacc, maxorder,
                                  lbnd.data(), ubnd.data());
    // Failure should result in a null pointer, so calling assertOK is unlikely to do anything,
    // but better to be sure and than risk missing an uncaught error.
    assertOK(reinterpret_cast<AstObject *>(outRawMap));
    if (!outRawMap) {
        throw std::runtime_error("Could not compute an inverse mapping");
    }
    return reinterpret_cast<AstMapT *>(outRawMap);
}

polyTranImpl< AstChebyMap >()

template AstChebyMap* ast::detail::polyTranImpl< AstChebyMap >	(	ChebyMap const &	,
		bool	,
		double	,
		double	,
		int	,
		std::vector< double > const &	,
		std::vector< double > const &
	)

polyTranImpl< AstPolyMap >()

template AstPolyMap* ast::detail::polyTranImpl< AstPolyMap >	(	PolyMap const &	,
		bool	,
		double	,
		double	,
		int	,
		std::vector< double > const &	,
		std::vector< double > const &
	)

safeDouble()

double ast::detail::safeDouble ( double  val )

inline

Return a double value after checking status and replacing AST__BAD with nan

Definition at line 100 of file utils.h.

                                     {
    assertOK();
    return val != AST__BAD ? val : std::numeric_limits<double>::quiet_NaN();
}

sink()

void ast::detail::sink ( const char *  cstr )

inline

Sink function that allows astChannel to sink to a Stream.

This function retrieves a pointer to a Stream ssptr using astChannelData, then calls ssptr->sink(cstr).

Definition at line 239 of file Stream.h.

                                   {
    auto ssptr = reinterpret_cast<Stream *>(astChannelData);
    if (ssptr) {
        auto isok = ssptr->sink(cstr);
        if (!isok) {
            astSetStatus(AST__ATGER);
        }
    }
}

source()

const char* ast::detail::source ( )

inline

Source function that allows astChannel to source from a Stream.

This function retrieves a pointer to a Stream ssptr using astChannelData, then returns the result of calling ssptr->source()

Definition at line 224 of file Stream.h.

                            {
    auto ssptr = reinterpret_cast<Stream *>(astChannelData);
    if (ssptr) {
        return ssptr->source();
    } else {
        return nullptr;
    }
}

stringToUpper()

std::string ast::detail::stringToUpper ( std::string const &  str )

inline

Return a copy of a string in which all characters are uppercase.

Definition at line 108 of file utils.h.

                                                     {
    std::string upstr;
    upstr.reserve(str.size());
    for (char c : str) {
        upstr += std::toupper(c);
    }
    return upstr;
}