Py::Fmt Namespace Reference

Description

Utility functions for writing Python code snippets.

Functions
std::string	indent (size_t width=4u)
	Returns a string of blanks with given width. By default the width equals standard offset in python files. More...
bool	isHexagonal (double length1, double length2, double angle)
bool	isSquare (double length1, double length2, double angle)
std::string	printArguments (const std::vector< std::pair< double, std::string >> &arguments)
	Takes pairs of value/unit and concatenates them for an argument list. Each pair's content will be processed by printValue(), so the meaning of the content is the same as in printValue(). More...
std::string	printArguments (const std::vector< std::pair< std::variant< double, int >, std::string >> &arguments)
	Convenience overload for printing arguments containing a mixture of int and double. More...
std::string	printBool (double value)
std::string	printDegrees (double input)
std::string	printDouble (double input)
std::string	printFunction (const std::string &name, const std::vector< std::pair< double, std::string >> &arguments)
	Print a function in the form "<name>(<arguments>)". arguments will be processed by printArguments(), see there for details. More...
std::string	printFunction (const std::string &name, double value, const std::string &unit)
	Convenience overload for printing a function with one argument. More...
std::string	printFunction (const std::string &name, double value1, const std::string &unit1, double value2, const std::string &unit2)
	Convenience overload for printing a function with two arguments. More...
std::string	printImportedSymbols (const std::string &code)
std::string	printInt (int value)
std::string	printKvector (const R3 value)
std::string	printLightDouble (double input)
	prints double as an integer, if possible within standard accuracy More...
std::string	printNm (double input)
std::string	printNm2 (double input)
std::string	printRealLimits (const RealLimits &limits, const std::string &units)
std::string	printRealLimitsArg (const RealLimits &limits, const std::string &units)
	Prints RealLimits in the form of argument (in the context of ParameterDistribution and similar). Default RealLimits will not be printed, any other will be printed as ", ba.RealLimits.limited(1*deg, 2*deg)". More...
std::string	printScientificDouble (double input)
std::string	printString (const std::string &value)
std::string	printValue (double value, const std::string &units)
std::string	printValue (std::variant< double, int > value, const std::string &units)

Function Documentation

indent()

std::string Py::Fmt::indent

(

size_t

width

)

Returns a string of blanks with given width. By default the width equals standard offset in python files.

Definition at line 203 of file PyFmt.cpp.

{
    return std::string(width, ' ');
}

Referenced by SampleToPython::defineCoreShellParticles(), SampleToPython::defineCrystals(), SampleToPython::defineFormFactors(), SampleToPython::defineInterferences(), SampleToPython::defineLattices2D(), SampleToPython::defineLattices3D(), SampleToPython::defineLayers(), SampleToPython::defineMaterials(), SampleToPython::defineMesoCrystals(), SampleToPython::defineMultiLayers(), SampleToPython::defineParticleCompositions(), SampleToPython::defineParticleLayouts(), SampleToPython::defineParticles(), SampleToPython::defineRoughnesses(), Py::Fmt2::printRangedDistribution(), and Py::Fmt2::representShape2D().

isHexagonal()

bool Py::Fmt::isHexagonal	(	double	length1,
		double	length2,
		double	angle
	)

Definition at line 190 of file PyFmt.cpp.

{
    return length1 == length2 && BaseUtils::algo::almostEqual(angle, M_TWOPI / 3.0);
}

References BaseUtils::algo::almostEqual(), and M_TWOPI.

Here is the call graph for this function:

isSquare()

bool Py::Fmt::isSquare	(	double	length1,
		double	length2,
		double	angle
	)

Definition at line 185 of file PyFmt.cpp.

{
    return length1 == length2 && BaseUtils::algo::almostEqual(angle, M_PI_2);
}

References BaseUtils::algo::almostEqual(), and M_PI_2.

Here is the call graph for this function:

printArguments() [1/2]

std::string Py::Fmt::printArguments

(

const std::vector< std::pair< double, std::string >> &

arguments

)

Takes pairs of value/unit and concatenates them for an argument list. Each pair's content will be processed by printValue(), so the meaning of the content is the same as in printValue().

Definition at line 151 of file PyFmt.cpp.

{
    std::vector<std::string> args;
    for (const auto& argument : arguments)
        args.push_back(Py::Fmt::printValue(argument.first, argument.second));
    return BaseUtils::String::join(args, ", ");
}

References BaseUtils::String::join(), and printValue().

Referenced by printFunction().

Here is the call graph for this function:

printArguments() [2/2]

std::string Py::Fmt::printArguments

(

const std::vector< std::pair< std::variant< double, int >, std::string >> &

arguments

)

Convenience overload for printing arguments containing a mixture of int and double.

Definition at line 160 of file PyFmt.cpp.

{
    std::vector<std::string> args;
    for (const auto& argument : arguments)
        args.push_back(Py::Fmt::printValue(argument.first, argument.second));
    return BaseUtils::String::join(args, ", ");
}

References BaseUtils::String::join(), and printValue().

Here is the call graph for this function:

printBool()

std::string Py::Fmt::printBool

(

double

value

)

Definition at line 41 of file PyFmt.cpp.

{
    return value ? "True" : "False";
}

Referenced by Py::Fmt2::representShape2D().

printDegrees()

std::string Py::Fmt::printDegrees

(

double

input

)

Definition at line 116 of file PyFmt.cpp.

{
    std::ostringstream inter;
    inter << printLightDouble(Units::rad2deg(input)) << "*deg";
    return inter.str();
}

References printLightDouble(), and Units::rad2deg().

Referenced by SampleToPython::defineInterferences(), SampleToPython::defineLattices2D(), printValue(), and Py::Fmt2::representShape2D().

Here is the call graph for this function:

printDouble()

std::string Py::Fmt::printDouble

(

double

input

)

Definition at line 46 of file PyFmt.cpp.

{
    std::ostringstream inter;
    inter << std::setprecision(12);
    if (std::abs(input) < std::numeric_limits<double>::epsilon()) {
        inter << "0.0";
        return inter.str();
    }
    inter << input;
    if (inter.str().find('e') == std::string::npos && inter.str().find('.') == std::string::npos)
        inter << ".0";
    return inter.str();
}

Referenced by SampleToPython::defineInterferences(), SampleToPython::defineMaterials(), SampleToPython::defineParticleLayouts(), printKvector(), Py::Fmt2::printParameterDistribution(), Py::Fmt2::printRangedDistribution(), and printValue().

printFunction() [1/3]

std::string Py::Fmt::printFunction	(	const std::string &	name,
		const std::vector< std::pair< double, std::string >> &	arguments
	)

Print a function in the form "<name>(<arguments>)". arguments will be processed by printArguments(), see there for details.

Definition at line 168 of file PyFmt.cpp.

{
    return name + "(" + printArguments(arguments) + ")";
}

References printArguments().

Referenced by printFunction(), IProfile1D::pythonConstructor(), IProfile2D::pythonConstructor(), LayerRoughness::pythonConstructor(), IFormFactor::pythonConstructor(), Profile1DVoigt::pythonConstructor(), Profile2DVoigt::pythonConstructor(), DistributionGate::pythonConstructor(), DistributionLorentz::pythonConstructor(), DistributionGaussian::pythonConstructor(), DistributionLogNormal::pythonConstructor(), DistributionCosine::pythonConstructor(), and DistributionTrapezoid::pythonConstructor().

Here is the call graph for this function:

printFunction() [2/3]

std::string Py::Fmt::printFunction	(	const std::string &	name,
		double	value,
		const std::string &	unit
	)

Convenience overload for printing a function with one argument.

Definition at line 174 of file PyFmt.cpp.

{
    return printFunction(name, {{value, unit}});
}

References printFunction().

Here is the call graph for this function:

printFunction() [3/3]

std::string Py::Fmt::printFunction	(	const std::string &	name,
		double	value1,
		const std::string &	unit1,
		double	value2,
		const std::string &	unit2
	)

Convenience overload for printing a function with two arguments.

Definition at line 179 of file PyFmt.cpp.

{
    return printFunction(name, {{value1, unit1}, {value2, unit2}});
}

References printFunction().

Here is the call graph for this function:

printImportedSymbols()

std::string Py::Fmt::printImportedSymbols

(

const std::string &

code

)

Definition at line 24 of file PyFmt.cpp.

{
    std::vector<std::string> to_declare;
    for (const std::string key : {"angstrom", "deg", "nm", "nm2", "micrometer"})
        if (code.find("*" + key) != std::string::npos)
            to_declare.push_back(key);
    for (const std::string key : {"R3"})
        if (code.find(key) != std::string::npos)
            to_declare.push_back(key);
    return "from bornagain import " + BaseUtils::String::join(to_declare, ", ") + "\n";
}

References BaseUtils::String::join().

Here is the call graph for this function:

printInt()

std::string Py::Fmt::printInt

(

int

value

)

Definition at line 36 of file PyFmt.cpp.

{
    return std::to_string(value);
}

Referenced by printValue().

printKvector()

std::string Py::Fmt::printKvector

(

const R3

value

)

Definition at line 195 of file PyFmt.cpp.

{
    std::ostringstream result;
    result << "R3(" << printDouble(value.x()) << ", " << printDouble(value.y()) << ", "
           << printDouble(value.z()) << ")";
    return result.str();
}

References printDouble().

Here is the call graph for this function:

printLightDouble()

std::string Py::Fmt::printLightDouble

(

double

input

)

prints double as an integer, if possible within standard accuracy

Definition at line 61 of file PyFmt.cpp.

{
    std::ostringstream inter;
    int ival = std::lround(input);
    if (std::abs(input - ival) < 1e-11)
        inter << ival;
    else {
        inter << std::setprecision(12);
        if (std::abs(input) < std::numeric_limits<double>::epsilon())
            return "0.0";
        inter << input;
        if (inter.str().find('e') == std::string::npos
            && inter.str().find('.') == std::string::npos)
            inter << ".0";
    }
    return inter.str();
}

Referenced by printDegrees(), printNm(), and printNm2().

printNm()

std::string Py::Fmt::printNm

(

double

input

)

Definition at line 79 of file PyFmt.cpp.

{
    std::ostringstream inter;
    inter << std::setprecision(12);
    inter << printLightDouble(input) << "*nm";
    return inter.str();
}

References printLightDouble().

Referenced by SampleToPython::defineInterferences(), SampleToPython::defineLattices2D(), SampleToPython::defineLattices3D(), SampleToPython::defineLayers(), and printValue().

Here is the call graph for this function:

printNm2()

std::string Py::Fmt::printNm2

(

double

input

)

Definition at line 87 of file PyFmt.cpp.

{
    std::ostringstream inter;
    inter << std::setprecision(12);
    inter << printLightDouble(input) << "*nm2";
    return inter.str();
}

References printLightDouble().

Referenced by SampleToPython::defineInterferences().

Here is the call graph for this function:

printRealLimits()

std::string Py::Fmt::printRealLimits	(	const RealLimits &	limits,
		const std::string &	units
	)

Definition at line 22 of file PyFmtLimits.cpp.

{
    std::ostringstream result;
 
    if (limits.isLimitless())
        result << "RealLimits()";
 
    else if (limits.isPositive())
        result << "RealLimits.positive()";
 
 
    else if (limits.isNonnegative())
        result << "RealLimits.nonnegative()";
 
 
    else if (limits.isLowerLimited()) {
        result << "RealLimits.lowerLimited(" << Py::Fmt::printValue(limits.lowerLimit(), units)
               << ")";
    }
 
    else if (limits.isUpperLimited()) {
        result << "RealLimits.upperLimited(" << Py::Fmt::printValue(limits.upperLimit(), units)
               << ")";
    }
 
    else if (limits.isLimited()) {
        result << "RealLimits.limited(" << Py::Fmt::printValue(limits.lowerLimit(), units) << ", "
               << Py::Fmt::printValue(limits.upperLimit(), units) << ")";
    }
 
    return result.str();
}

References RealLimits::isLimited(), RealLimits::isLimitless(), RealLimits::isLowerLimited(), RealLimits::isNonnegative(), RealLimits::isPositive(), RealLimits::isUpperLimited(), RealLimits::lowerLimit(), printValue(), and RealLimits::upperLimit().

Referenced by printRealLimitsArg().

Here is the call graph for this function:

printRealLimitsArg()

std::string Py::Fmt::printRealLimitsArg	(	const RealLimits &	limits,
		const std::string &	units
	)

Prints RealLimits in the form of argument (in the context of ParameterDistribution and similar). Default RealLimits will not be printed, any other will be printed as ", ba.RealLimits.limited(1*deg, 2*deg)".

Definition at line 59 of file PyFmtLimits.cpp.

{
    return limits.isLimitless() ? "" : ", ba." + printRealLimits(limits, units);
}

References RealLimits::isLimitless(), and printRealLimits().

Referenced by Py::Fmt2::printParameterDistribution(), and Py::Fmt2::printRangedDistribution().

Here is the call graph for this function:

printScientificDouble()

std::string Py::Fmt::printScientificDouble

(

double

input

)

Definition at line 96 of file PyFmt.cpp.

{
    std::ostringstream inter;
    inter << std::scientific;
    inter << input;
 
    std::string::size_type pos = inter.str().find('e');
    if (pos == std::string::npos)
        return inter.str();
 
    std::string part1 = inter.str().substr(0, pos);
    std::string part2 = inter.str().substr(pos, std::string::npos);
 
    part1.erase(part1.find_last_not_of('0') + 1, std::string::npos);
    if (part1.back() == '.')
        part1 += "0";
 
    return part1 + part2;
}

References BaseUtils::String::scientific().

Referenced by SampleToPython::defineMultiLayers().

Here is the call graph for this function:

printString()

std::string Py::Fmt::printString

(

const std::string &

value

)

Definition at line 144 of file PyFmt.cpp.

{
    std::ostringstream result;
    result << "\"" << value << "\"";
    return result.str();
}

Referenced by Py::Fmt2::printAxis().

printValue() [1/2]

std::string Py::Fmt::printValue	(	double	value,
		const std::string &	units
	)

Definition at line 123 of file PyFmt.cpp.

{
    if (units == "rad")
        return printDegrees(value);
    if (units == "nm")
        return printNm(value);
    if (units.empty())
        return printDouble(value);
    ASSERT(0);
}

References ASSERT, printDegrees(), printDouble(), and printNm().

Referenced by printArguments(), Py::Fmt2::printAxis(), printRealLimits(), and printValue().

Here is the call graph for this function:

printValue() [2/2]

std::string Py::Fmt::printValue	(	std::variant< double, int >	value,
		const std::string &	units
	)

Definition at line 134 of file PyFmt.cpp.

{
    if (std::holds_alternative<int>(value)) {
        ASSERT(units.empty()); // int with units is not supported. Implement when necessary.
        return printInt(std::get<int>(value));
    }
 
    return printValue(std::get<double>(value), units);
}

References ASSERT, printInt(), and printValue().

Here is the call graph for this function: