numeric¶

Bindings for ::numeric namespace

class pyrosetta.rosetta.numeric.AgglomerativeHierarchicalClusterer¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.AgglomerativeHierarchicalClusterer, : pyrosetta.rosetta.numeric.AgglomerativeHierarchicalClusterer) → pyrosetta.rosetta.numeric.AgglomerativeHierarchicalClusterer¶: C++: numeric::AgglomerativeHierarchicalClusterer::operator=(const class numeric::AgglomerativeHierarchicalClusterer &) –> class numeric::AgglomerativeHierarchicalClusterer &

comparator(self: pyrosetta.rosetta.numeric.AgglomerativeHierarchicalClusterer, distance_matrix: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, members1: pyrosetta.rosetta.utility.vector1_unsigned_long, members2: pyrosetta.rosetta.utility.vector1_unsigned_long, co: pyrosetta.rosetta.numeric.ClusterOptions) → None¶: C++: numeric::AgglomerativeHierarchicalClusterer::comparator(class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class numeric::ClusterOptions &) –> void

class pyrosetta.rosetta.numeric.AverageLinkClusterer¶

Bases: AgglomerativeHierarchicalClusterer

assign(self: pyrosetta.rosetta.numeric.AverageLinkClusterer, : pyrosetta.rosetta.numeric.AverageLinkClusterer) → pyrosetta.rosetta.numeric.AverageLinkClusterer¶: C++: numeric::AverageLinkClusterer::operator=(const class numeric::AverageLinkClusterer &) –> class numeric::AverageLinkClusterer &

comparator(self: pyrosetta.rosetta.numeric.AverageLinkClusterer, distance_matrix: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, members1: pyrosetta.rosetta.utility.vector1_unsigned_long, members2: pyrosetta.rosetta.utility.vector1_unsigned_long, co: pyrosetta.rosetta.numeric.ClusterOptions) → None¶: C++: numeric::AverageLinkClusterer::comparator(class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class numeric::ClusterOptions &) –> void

class pyrosetta.rosetta.numeric.AxisRotationSampler¶

Bases: pybind11_object

get(self: pyrosetta.rosetta.numeric.AxisRotationSampler, ii: int, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None¶: C++: numeric::AxisRotationSampler::get(unsigned long, class numeric::xyzMatrix<double> &) const –> void

nrots(self: pyrosetta.rosetta.numeric.AxisRotationSampler) → int¶: C++: numeric::AxisRotationSampler::nrots() const –> unsigned long

class pyrosetta.rosetta.numeric.Calculator¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.Calculator, : pyrosetta.rosetta.numeric.Calculator) → pyrosetta.rosetta.numeric.Calculator¶: C++: numeric::Calculator::operator=(const class numeric::Calculator &) –> class numeric::Calculator &

compute(self: pyrosetta.rosetta.numeric.Calculator, values: pyrosetta.rosetta.std.map_std_string_double, output: float) → bool¶

Calculate the value of the equation, putting it in output: Return true if the computation failed.

C++: numeric::Calculator::compute(class std::map<std::string, double, struct std::less<std::string >, class std::allocator<struct std::pair<const std::string, double> > > &, double &) const –> bool

equation(self: pyrosetta.rosetta.numeric.Calculator) → str¶

Get access to the equation held in this object.

C++: numeric::Calculator::equation() const –> const std::string &

class pyrosetta.rosetta.numeric.ClusterOptions¶

Bases: pybind11_object

property min_¶

property min_i_¶

property min_j_¶

property node1_¶

property node2_¶

class pyrosetta.rosetta.numeric.ClusteringTreeNode¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.ClusteringTreeNode, : pyrosetta.rosetta.numeric.ClusteringTreeNode) → pyrosetta.rosetta.numeric.ClusteringTreeNode¶: C++: numeric::ClusteringTreeNode::operator=(const class numeric::ClusteringTreeNode &) –> class numeric::ClusteringTreeNode &

copy_leaf_ids(self: pyrosetta.rosetta.numeric.ClusteringTreeNode, dst: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶: C++: numeric::ClusteringTreeNode::copy_leaf_ids(class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

copy_member_ids(self: pyrosetta.rosetta.numeric.ClusteringTreeNode, dst: pyrosetta.rosetta.utility.vector1_unsigned_long) → None¶: C++: numeric::ClusteringTreeNode::copy_member_ids(class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

distance(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) → float¶: C++: numeric::ClusteringTreeNode::distance() –> double

id(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) → int¶: C++: numeric::ClusteringTreeNode::id() –> unsigned long

left(*args, **kwargs)¶

Overloaded function.

left(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) -> pyrosetta.rosetta.numeric.ClusteringTreeNode

C++: numeric::ClusteringTreeNode::left() –> class std::shared_ptr<class numeric::ClusteringTreeNode>

left(self: pyrosetta.rosetta.numeric.ClusteringTreeNode, new_left: pyrosetta.rosetta.std.weak_ptr_numeric_ClusteringTreeNode_t) -> None

C++: numeric::ClusteringTreeNode::left(class std::weak_ptr<class numeric::ClusteringTreeNode>) –> void

static newClusteringTreeNode(*args, **kwargs)¶

Overloaded function.

newClusteringTreeNode() -> pyrosetta.rosetta.numeric.ClusteringTreeNode

Creates a node with no leaves

leaves are NULLs, parent is set to this

C++: numeric::ClusteringTreeNode::newClusteringTreeNode() –> class std::shared_ptr<class numeric::ClusteringTreeNode>

newClusteringTreeNode(id: int) -> pyrosetta.rosetta.numeric.ClusteringTreeNode

C++: numeric::ClusteringTreeNode::newClusteringTreeNode(unsigned long) –> class std::shared_ptr<class numeric::ClusteringTreeNode>

newClusteringTreeNode(id: int, left: pyrosetta.rosetta.numeric.ClusteringTreeNode, right: pyrosetta.rosetta.numeric.ClusteringTreeNode) -> pyrosetta.rosetta.numeric.ClusteringTreeNode
newClusteringTreeNode(id: int, left: pyrosetta.rosetta.numeric.ClusteringTreeNode, right: pyrosetta.rosetta.numeric.ClusteringTreeNode, distance: float) -> pyrosetta.rosetta.numeric.ClusteringTreeNode

Creates a node with given leaves

parent of the newly created node is set to itself (this pointer); left and right nodes are also chilred of this

C++: numeric::ClusteringTreeNode::newClusteringTreeNode(unsigned long, class std::shared_ptr<class numeric::ClusteringTreeNode>, class std::shared_ptr<class numeric::ClusteringTreeNode>, double) –> class std::shared_ptr<class numeric::ClusteringTreeNode>

parent(*args, **kwargs)¶

Overloaded function.

parent(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) -> pyrosetta.rosetta.numeric.ClusteringTreeNode

C++: numeric::ClusteringTreeNode::parent() –> class std::shared_ptr<class numeric::ClusteringTreeNode>

parent(self: pyrosetta.rosetta.numeric.ClusteringTreeNode, new_parent: pyrosetta.rosetta.std.weak_ptr_numeric_ClusteringTreeNode_t) -> None

C++: numeric::ClusteringTreeNode::parent(class std::weak_ptr<class numeric::ClusteringTreeNode>) –> void

reset_all_flags(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) → None¶: C++: numeric::ClusteringTreeNode::reset_all_flags() –> void

right(*args, **kwargs)¶

Overloaded function.

right(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) -> pyrosetta.rosetta.numeric.ClusteringTreeNode

C++: numeric::ClusteringTreeNode::right() –> class std::shared_ptr<class numeric::ClusteringTreeNode>

right(self: pyrosetta.rosetta.numeric.ClusteringTreeNode, new_right: pyrosetta.rosetta.std.weak_ptr_numeric_ClusteringTreeNode_t) -> None

C++: numeric::ClusteringTreeNode::right(class std::weak_ptr<class numeric::ClusteringTreeNode>) –> void

set_all_flags(self: pyrosetta.rosetta.numeric.ClusteringTreeNode, new_flag_value: int) → None¶: C++: numeric::ClusteringTreeNode::set_all_flags(unsigned long) –> void

set_visited(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) → None¶: C++: numeric::ClusteringTreeNode::set_visited() –> void

size(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) → int¶: C++: numeric::ClusteringTreeNode::size() –> unsigned long

visit_next_leaf(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) → pyrosetta.rosetta.numeric.ClusteringTreeNode¶: C++: numeric::ClusteringTreeNode::visit_next_leaf() –> class std::shared_ptr<class numeric::ClusteringTreeNode>

was_visited(self: pyrosetta.rosetta.numeric.ClusteringTreeNode) → bool¶: C++: numeric::ClusteringTreeNode::was_visited() –> bool

class pyrosetta.rosetta.numeric.CompleteLinkClusterer¶

Bases: AgglomerativeHierarchicalClusterer

assign(self: pyrosetta.rosetta.numeric.CompleteLinkClusterer, : pyrosetta.rosetta.numeric.CompleteLinkClusterer) → pyrosetta.rosetta.numeric.CompleteLinkClusterer¶: C++: numeric::CompleteLinkClusterer::operator=(const class numeric::CompleteLinkClusterer &) –> class numeric::CompleteLinkClusterer &

comparator(self: pyrosetta.rosetta.numeric.CompleteLinkClusterer, distance_matrix: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, members1: pyrosetta.rosetta.utility.vector1_unsigned_long, members2: pyrosetta.rosetta.utility.vector1_unsigned_long, co: pyrosetta.rosetta.numeric.ClusterOptions) → None¶: C++: numeric::CompleteLinkClusterer::comparator(class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class numeric::ClusterOptions &) –> void

class pyrosetta.rosetta.numeric.CubicPolynomial¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.CubicPolynomial, : pyrosetta.rosetta.numeric.CubicPolynomial) → pyrosetta.rosetta.numeric.CubicPolynomial¶: C++: numeric::CubicPolynomial::operator=(const struct numeric::CubicPolynomial &) –> struct numeric::CubicPolynomial &

property c0¶

property c1¶

property c2¶

property c3¶

class pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t, : pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t) → pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t¶: C++: numeric::DiscreteIntervalEncodingTree<unsigned long>::operator=(const class numeric::DiscreteIntervalEncodingTree<unsigned long> &) –> class numeric::DiscreteIntervalEncodingTree<unsigned long> &

correct(self: pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t) → bool¶: C++: numeric::DiscreteIntervalEncodingTree<unsigned long>::correct() const –> bool

insert(self: pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t, val: int) → None¶: C++: numeric::DiscreteIntervalEncodingTree<unsigned long>::insert(unsigned long) –> void

member(self: pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t, val: int) → bool¶: C++: numeric::DiscreteIntervalEncodingTree<unsigned long>::member(unsigned long) const –> bool

ranges(self: pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t) → pyrosetta.rosetta.std.list_std_pair_unsigned_long_unsigned_long_t¶: C++: numeric::DiscreteIntervalEncodingTree<unsigned long>::ranges() const –> class std::list<struct std::pair<unsigned long, unsigned long>, class std::allocator<struct std::pair<unsigned long, unsigned long> > >

size(self: pyrosetta.rosetta.numeric.DiscreteIntervalEncodingTree_unsigned_long_t) → int¶: C++: numeric::DiscreteIntervalEncodingTree<unsigned long>::size() const –> int

class pyrosetta.rosetta.numeric.HomogeneousTransform_Double¶

Bases: HomogeneousTransform_double_t

as_array()¶

Convert self a numpy.array and return it.

Returns:: numpy.array: the 4x4 matrix representing the homogenous transform.

assign(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, : pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.HomogeneousTransform_double_t¶: C++: numeric::HomogeneousTransform<double>::operator=(const class numeric::HomogeneousTransform<double> &) –> class numeric::HomogeneousTransform<double> &

euler_angles_ZYX_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::euler_angles_ZYX_rad() const –> class numeric::xyzVector<double>

euler_angles_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::euler_angles_deg() const –> class numeric::xyzVector<double>

euler_angles_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::euler_angles_rad() const –> class numeric::xyzVector<double>

classmethod from_RT(RTinstance)¶

classmethod from_array(xform)¶

from_euler_angles_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, euler: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::from_euler_angles_deg(const class numeric::xyzVector<double> &) –> void

from_euler_angles_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, euler: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::from_euler_angles_rad(const class numeric::xyzVector<double> &) –> void

inverse(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.HomogeneousTransform_double_t¶: C++: numeric::HomogeneousTransform<double>::inverse() const –> class numeric::HomogeneousTransform<double>

is_close(*args, **kwargs)¶

Overloaded function.

is_close(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, other: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) -> bool
is_close(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, other: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, threshold: float) -> bool

C++: numeric::HomogeneousTransform<double>::is_close(const class numeric::HomogeneousTransform<double> &, const double) –> bool

point(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::point() const –> class numeric::xyzVector<double>

px(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::px() const –> double

py(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::py() const –> double

pz(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::pz() const –> double

rotation_matrix(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::HomogeneousTransform<double>::rotation_matrix() const –> class numeric::xyzMatrix<double>

set_identity(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_identity() –> void

set_identity_rotation(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_identity_rotation() –> void

set_identity_transform(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_identity_transform() –> void

set_point(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, p: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_point(const class numeric::xyzVector<double> &) –> void

set_transform(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, t: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_transform(const class numeric::xyzVector<double> &) –> void

set_xaxis_rotation_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_xaxis_rotation_deg(double) –> void

set_xaxis_rotation_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_xaxis_rotation_rad(double) –> void

set_yaxis_rotation_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_yaxis_rotation_deg(double) –> void

set_yaxis_rotation_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_yaxis_rotation_rad(double) –> void

set_zaxis_rotation_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_zaxis_rotation_deg(double) –> void

set_zaxis_rotation_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_zaxis_rotation_rad(double) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) -> pyrosetta.rosetta.std.ostream
show(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, stream: pyrosetta.rosetta.std.ostream) -> pyrosetta.rosetta.std.ostream

C++: numeric::HomogeneousTransform<double>::show(std::ostream &) const –> std::ostream &

to_local_coordinate(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::to_local_coordinate(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

walk_along_x(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, delta: float) → None¶: C++: numeric::HomogeneousTransform<double>::walk_along_x(double) –> void

walk_along_y(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, delta: float) → None¶: C++: numeric::HomogeneousTransform<double>::walk_along_y(double) –> void

walk_along_z(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, delta: float) → None¶: C++: numeric::HomogeneousTransform<double>::walk_along_z(double) –> void

xaxis(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::xaxis() const –> class numeric::xyzVector<double>

xform_magnitude(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, radius_of_gyration: float) → float¶: C++: numeric::HomogeneousTransform<double>::xform_magnitude(double) –> double

xx(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::xx() const –> double

xy(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::xy() const –> double

xz(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::xz() const –> double

yaxis(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::yaxis() const –> class numeric::xyzVector<double>

yx(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::yx() const –> double

yy(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::yy() const –> double

yz(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::yz() const –> double

zaxis(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::zaxis() const –> class numeric::xyzVector<double>

zx(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::zx() const –> double

zy(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::zy() const –> double

zz(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::zz() const –> double

class pyrosetta.rosetta.numeric.HomogeneousTransform_double_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, : pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.HomogeneousTransform_double_t¶: C++: numeric::HomogeneousTransform<double>::operator=(const class numeric::HomogeneousTransform<double> &) –> class numeric::HomogeneousTransform<double> &

euler_angles_ZYX_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::euler_angles_ZYX_rad() const –> class numeric::xyzVector<double>

euler_angles_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::euler_angles_deg() const –> class numeric::xyzVector<double>

euler_angles_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::euler_angles_rad() const –> class numeric::xyzVector<double>

from_euler_angles_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, euler: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::from_euler_angles_deg(const class numeric::xyzVector<double> &) –> void

from_euler_angles_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, euler: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::from_euler_angles_rad(const class numeric::xyzVector<double> &) –> void

inverse(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.HomogeneousTransform_double_t¶: C++: numeric::HomogeneousTransform<double>::inverse() const –> class numeric::HomogeneousTransform<double>

is_close(*args, **kwargs)¶

Overloaded function.

is_close(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, other: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) -> bool
is_close(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, other: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, threshold: float) -> bool

C++: numeric::HomogeneousTransform<double>::is_close(const class numeric::HomogeneousTransform<double> &, const double) –> bool

point(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::point() const –> class numeric::xyzVector<double>

px(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::px() const –> double

py(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::py() const –> double

pz(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::pz() const –> double

rotation_matrix(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::HomogeneousTransform<double>::rotation_matrix() const –> class numeric::xyzMatrix<double>

set_identity(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_identity() –> void

set_identity_rotation(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_identity_rotation() –> void

set_identity_transform(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_identity_transform() –> void

set_point(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, p: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_point(const class numeric::xyzVector<double> &) –> void

set_transform(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, t: pyrosetta.rosetta.numeric.xyzVector_double_t) → None¶: C++: numeric::HomogeneousTransform<double>::set_transform(const class numeric::xyzVector<double> &) –> void

set_xaxis_rotation_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_xaxis_rotation_deg(double) –> void

set_xaxis_rotation_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_xaxis_rotation_rad(double) –> void

set_yaxis_rotation_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_yaxis_rotation_deg(double) –> void

set_yaxis_rotation_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_yaxis_rotation_rad(double) –> void

set_zaxis_rotation_deg(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_zaxis_rotation_deg(double) –> void

set_zaxis_rotation_rad(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, angle: float) → None¶: C++: numeric::HomogeneousTransform<double>::set_zaxis_rotation_rad(double) –> void

show(*args, **kwargs)¶

Overloaded function.

show(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) -> pyrosetta.rosetta.std.ostream
show(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, stream: pyrosetta.rosetta.std.ostream) -> pyrosetta.rosetta.std.ostream

C++: numeric::HomogeneousTransform<double>::show(std::ostream &) const –> std::ostream &

to_local_coordinate(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::to_local_coordinate(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

walk_along_x(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, delta: float) → None¶: C++: numeric::HomogeneousTransform<double>::walk_along_x(double) –> void

walk_along_y(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, delta: float) → None¶: C++: numeric::HomogeneousTransform<double>::walk_along_y(double) –> void

walk_along_z(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, delta: float) → None¶: C++: numeric::HomogeneousTransform<double>::walk_along_z(double) –> void

xaxis(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::xaxis() const –> class numeric::xyzVector<double>

xform_magnitude(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t, radius_of_gyration: float) → float¶: C++: numeric::HomogeneousTransform<double>::xform_magnitude(double) –> double

xx(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::xx() const –> double

xy(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::xy() const –> double

xz(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::xz() const –> double

yaxis(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::yaxis() const –> class numeric::xyzVector<double>

yx(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::yx() const –> double

yy(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::yy() const –> double

yz(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::yz() const –> double

zaxis(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::HomogeneousTransform<double>::zaxis() const –> class numeric::xyzVector<double>

zx(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::zx() const –> double

zy(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::zy() const –> double

zz(self: pyrosetta.rosetta.numeric.HomogeneousTransform_double_t) → float¶: C++: numeric::HomogeneousTransform<double>::zz() const –> double

class pyrosetta.rosetta.numeric.IOTraits_double_t¶

Bases: pybind11_object

Numerics input/output type traits double specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<double>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<double>::width() –> int

class pyrosetta.rosetta.numeric.IOTraits_float_t¶

Bases: pybind11_object

Numerics input/output type traits float Specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<float>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<float>::width() –> int

class pyrosetta.rosetta.numeric.IOTraits_int_t¶

Bases: pybind11_object

Numerics input/output type traits int specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<int>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<int>::width() –> int

class pyrosetta.rosetta.numeric.IOTraits_long_double_t¶

Bases: pybind11_object

Numerics input/output type traits long double specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<long double>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<long double>::width() –> int

class pyrosetta.rosetta.numeric.IOTraits_long_t¶

Bases: pybind11_object

: Numerics input/output type traits long int specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<long>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<long>::width() –> int

class pyrosetta.rosetta.numeric.IOTraits_short_t¶

Bases: pybind11_object

Numerics input/output type traits short int specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<short>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<short>::width() –> int

class pyrosetta.rosetta.numeric.IOTraits_unsigned_int_t¶

Bases: pybind11_object

: Numerics input/output type traits unsigned int specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<unsigned int>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<unsigned int>::width() –> int

class pyrosetta.rosetta.numeric.IOTraits_unsigned_long_t¶

Bases: pybind11_object

Numerics input/output type traits unsigned long int specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<unsigned long>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<unsigned long>::width() –> int

class pyrosetta.rosetta.numeric.IOTraits_unsigned_short_t¶

Bases: pybind11_object

: Numerics input/output type traits unsigned short int specialization

static precision() → int¶

Precision

C++: numeric::IOTraits<unsigned short>::precision() –> int

static width() → int¶

Width

C++: numeric::IOTraits<unsigned short>::width() –> int

class pyrosetta.rosetta.numeric.IntervalSet_Double¶

Bases: IntervalSet_double_t

clear(self: pyrosetta.rosetta.numeric.IntervalSet_double_t) → None¶: C++: numeric::IntervalSet<double>::clear() –> void

endpoints(self: pyrosetta.rosetta.numeric.IntervalSet_double_t) → pyrosetta.rosetta.utility.vector0_double¶: C++: numeric::IntervalSet<double>::endpoints() const –> const class utility::vector0<double, class std::allocator<double> > &

is_inside(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, point: float) → bool¶: C++: numeric::IntervalSet<double>::is_inside(double) –> bool

length(self: pyrosetta.rosetta.numeric.IntervalSet_double_t) → float¶: C++: numeric::IntervalSet<double>::length() –> double

push_back(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, start: float, end: float) → None¶: C++: numeric::IntervalSet<double>::push_back(double, double) –> void

random_point(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, RG: pyrosetta.rosetta.numeric.random.RandomGenerator) → float¶: C++: numeric::IntervalSet<double>::random_point(class numeric::random::RandomGenerator &) –> double

set(*args, **kwargs)¶

Overloaded function.

set(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, start: float, end: float) -> None

C++: numeric::IntervalSet<double>::set(double, double) –> void

set(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, start1: float, end1: float, start2: float, end2: float) -> None

C++: numeric::IntervalSet<double>::set(double, double, double, double) –> void

class pyrosetta.rosetta.numeric.IntervalSet_double_t¶

Bases: pybind11_object

clear(self: pyrosetta.rosetta.numeric.IntervalSet_double_t) → None¶: C++: numeric::IntervalSet<double>::clear() –> void

endpoints(self: pyrosetta.rosetta.numeric.IntervalSet_double_t) → pyrosetta.rosetta.utility.vector0_double¶: C++: numeric::IntervalSet<double>::endpoints() const –> const class utility::vector0<double, class std::allocator<double> > &

is_inside(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, point: float) → bool¶: C++: numeric::IntervalSet<double>::is_inside(double) –> bool

length(self: pyrosetta.rosetta.numeric.IntervalSet_double_t) → float¶: C++: numeric::IntervalSet<double>::length() –> double

push_back(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, start: float, end: float) → None¶: C++: numeric::IntervalSet<double>::push_back(double, double) –> void

random_point(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, RG: pyrosetta.rosetta.numeric.random.RandomGenerator) → float¶: C++: numeric::IntervalSet<double>::random_point(class numeric::random::RandomGenerator &) –> double

set(*args, **kwargs)¶

Overloaded function.

set(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, start: float, end: float) -> None

C++: numeric::IntervalSet<double>::set(double, double) –> void

set(self: pyrosetta.rosetta.numeric.IntervalSet_double_t, start1: float, end1: float, start2: float, end2: float) -> None

C++: numeric::IntervalSet<double>::set(double, double, double, double) –> void

class pyrosetta.rosetta.numeric.MathMatrix_double_t¶

Bases: pybind11_object

Clone(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::Clone() const –> class numeric::MathMatrix<double> *

IsValidPosition(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, ROW: int, COL: int) → bool¶: C++: numeric::MathMatrix<double>::IsValidPosition(const unsigned long, const unsigned long) const –> bool

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, MATRIX: pyrosetta.rosetta.numeric.MathMatrix_double_t) -> pyrosetta.rosetta.numeric.MathMatrix_double_t

C++: numeric::MathMatrix<double>::operator=(const class numeric::MathMatrix<double> &) –> class numeric::MathMatrix<double> &

assign(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, VALUE: float) -> pyrosetta.rosetta.numeric.MathMatrix_double_t

C++: numeric::MathMatrix<double>::operator=(const double &) –> class numeric::MathMatrix<double> &

begin(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → float¶: C++: numeric::MathMatrix<double>::begin() –> double *

end(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → float¶: C++: numeric::MathMatrix<double>::end() –> double *

get_col(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, COL: int) → pyrosetta.rosetta.numeric.MathVector_double_t¶: C++: numeric::MathMatrix<double>::get_col(const unsigned long) const –> class numeric::MathVector<double>

get_number_cols(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → int¶: C++: numeric::MathMatrix<double>::get_number_cols() const –> unsigned long

get_number_elements(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → int¶: C++: numeric::MathMatrix<double>::get_number_elements() const –> unsigned long

get_number_rows(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → int¶: C++: numeric::MathMatrix<double>::get_number_rows() const –> unsigned long

get_row(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, ROW: int) → pyrosetta.rosetta.numeric.MathVector_double_t¶: C++: numeric::MathMatrix<double>::get_row(const unsigned long) const –> class numeric::MathVector<double>

inverse(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::inverse() –> class numeric::MathMatrix<double> &

inverse_diagonal_matrix(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::inverse_diagonal_matrix() –> class numeric::MathMatrix<double> &

inverse_dimensions(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, MATRIX_LHS: pyrosetta.rosetta.numeric.MathMatrix_double_t, MATRIX_RHS: pyrosetta.rosetta.numeric.MathMatrix_double_t) → bool¶: C++: numeric::MathMatrix<double>::inverse_dimensions(const class numeric::MathMatrix<double> &, const class numeric::MathMatrix<double> &) –> bool

inverse_rectangular_matrix(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::inverse_rectangular_matrix() –> class numeric::MathMatrix<double> &

inverse_square_matrix(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::inverse_square_matrix() –> class numeric::MathMatrix<double>

inverse_tridiagonal_matrix(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::inverse_tridiagonal_matrix() –> class numeric::MathMatrix<double> &

is_diagonal(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → bool¶: C++: numeric::MathMatrix<double>::is_diagonal() const –> bool

is_square(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → bool¶: C++: numeric::MathMatrix<double>::is_square() const –> bool

is_tri_diagonal(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → bool¶: C++: numeric::MathMatrix<double>::is_tri_diagonal() const –> bool

multiplication_dimension(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, MATRIX_LHS: pyrosetta.rosetta.numeric.MathMatrix_double_t, MATRIX_RHS: pyrosetta.rosetta.numeric.MathMatrix_double_t) → bool¶: C++: numeric::MathMatrix<double>::multiplication_dimension(const class numeric::MathMatrix<double> &, const class numeric::MathMatrix<double> &) –> bool

pivot(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, ROW: int) → int¶: C++: numeric::MathMatrix<double>::pivot(const unsigned long) –> unsigned long

replace_col(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, COL: int, VECTOR: pyrosetta.rosetta.numeric.MathVector_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::replace_col(const unsigned long, const class numeric::MathVector<double> &) –> class numeric::MathMatrix<double> &

replace_row(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, ROW: int, VECTOR: pyrosetta.rosetta.numeric.MathVector_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::replace_row(const unsigned long, const class numeric::MathVector<double> &) –> class numeric::MathMatrix<double> &

same_dimensions(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, MATRIX_LHS: pyrosetta.rosetta.numeric.MathMatrix_double_t, MATRIX_RHS: pyrosetta.rosetta.numeric.MathMatrix_double_t) → bool¶: C++: numeric::MathMatrix<double>::same_dimensions(const class numeric::MathMatrix<double> &, const class numeric::MathMatrix<double> &) –> bool

set_unit(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::set_unit() –> class numeric::MathMatrix<double> &

set_zero(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::set_zero() –> class numeric::MathMatrix<double> &

size(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) → int¶: C++: numeric::MathMatrix<double>::size() const –> unsigned long

swap_cols(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, COL_A: int, COL_B: int) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::swap_cols(const unsigned long, const unsigned long) –> class numeric::MathMatrix<double> &

swap_rows(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, ROW_A: int, ROW_B: int) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathMatrix<double>::swap_rows(const unsigned long, const unsigned long) –> class numeric::MathMatrix<double> &

transpose(*args, **kwargs)¶

Overloaded function.

transpose(self: pyrosetta.rosetta.numeric.MathMatrix_double_t, MATRIX: pyrosetta.rosetta.numeric.MathMatrix_double_t) -> pyrosetta.rosetta.numeric.MathMatrix_double_t

C++: numeric::MathMatrix<double>::transpose(const class numeric::MathMatrix<double> &) –> class numeric::MathMatrix<double>

transpose(self: pyrosetta.rosetta.numeric.MathMatrix_double_t) -> pyrosetta.rosetta.numeric.MathMatrix_double_t

C++: numeric::MathMatrix<double>::transpose() –> class numeric::MathMatrix<double> &

class pyrosetta.rosetta.numeric.MathMatrix_float_t¶

Bases: pybind11_object

Clone(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::Clone() const –> class numeric::MathMatrix<float> *

IsValidPosition(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, ROW: int, COL: int) → bool¶: C++: numeric::MathMatrix<float>::IsValidPosition(const unsigned long, const unsigned long) const –> bool

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, MATRIX: pyrosetta.rosetta.numeric.MathMatrix_float_t) -> pyrosetta.rosetta.numeric.MathMatrix_float_t

C++: numeric::MathMatrix<float>::operator=(const class numeric::MathMatrix<float> &) –> class numeric::MathMatrix<float> &

assign(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, VALUE: float) -> pyrosetta.rosetta.numeric.MathMatrix_float_t

C++: numeric::MathMatrix<float>::operator=(const float &) –> class numeric::MathMatrix<float> &

begin(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → float¶: C++: numeric::MathMatrix<float>::begin() –> float *

end(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → float¶: C++: numeric::MathMatrix<float>::end() –> float *

get_number_cols(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → int¶: C++: numeric::MathMatrix<float>::get_number_cols() const –> unsigned long

get_number_elements(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → int¶: C++: numeric::MathMatrix<float>::get_number_elements() const –> unsigned long

get_number_rows(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → int¶: C++: numeric::MathMatrix<float>::get_number_rows() const –> unsigned long

inverse(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::inverse() –> class numeric::MathMatrix<float> &

inverse_diagonal_matrix(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::inverse_diagonal_matrix() –> class numeric::MathMatrix<float> &

inverse_dimensions(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, MATRIX_LHS: pyrosetta.rosetta.numeric.MathMatrix_float_t, MATRIX_RHS: pyrosetta.rosetta.numeric.MathMatrix_float_t) → bool¶: C++: numeric::MathMatrix<float>::inverse_dimensions(const class numeric::MathMatrix<float> &, const class numeric::MathMatrix<float> &) –> bool

inverse_rectangular_matrix(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::inverse_rectangular_matrix() –> class numeric::MathMatrix<float> &

inverse_square_matrix(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::inverse_square_matrix() –> class numeric::MathMatrix<float>

inverse_tridiagonal_matrix(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::inverse_tridiagonal_matrix() –> class numeric::MathMatrix<float> &

is_diagonal(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → bool¶: C++: numeric::MathMatrix<float>::is_diagonal() const –> bool

is_square(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → bool¶: C++: numeric::MathMatrix<float>::is_square() const –> bool

is_tri_diagonal(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → bool¶: C++: numeric::MathMatrix<float>::is_tri_diagonal() const –> bool

multiplication_dimension(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, MATRIX_LHS: pyrosetta.rosetta.numeric.MathMatrix_float_t, MATRIX_RHS: pyrosetta.rosetta.numeric.MathMatrix_float_t) → bool¶: C++: numeric::MathMatrix<float>::multiplication_dimension(const class numeric::MathMatrix<float> &, const class numeric::MathMatrix<float> &) –> bool

pivot(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, ROW: int) → int¶: C++: numeric::MathMatrix<float>::pivot(const unsigned long) –> unsigned long

same_dimensions(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, MATRIX_LHS: pyrosetta.rosetta.numeric.MathMatrix_float_t, MATRIX_RHS: pyrosetta.rosetta.numeric.MathMatrix_float_t) → bool¶: C++: numeric::MathMatrix<float>::same_dimensions(const class numeric::MathMatrix<float> &, const class numeric::MathMatrix<float> &) –> bool

set_unit(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::set_unit() –> class numeric::MathMatrix<float> &

set_zero(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::set_zero() –> class numeric::MathMatrix<float> &

size(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) → int¶: C++: numeric::MathMatrix<float>::size() const –> unsigned long

swap_cols(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, COL_A: int, COL_B: int) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::swap_cols(const unsigned long, const unsigned long) –> class numeric::MathMatrix<float> &

swap_rows(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, ROW_A: int, ROW_B: int) → pyrosetta.rosetta.numeric.MathMatrix_float_t¶: C++: numeric::MathMatrix<float>::swap_rows(const unsigned long, const unsigned long) –> class numeric::MathMatrix<float> &

transpose(*args, **kwargs)¶

Overloaded function.

transpose(self: pyrosetta.rosetta.numeric.MathMatrix_float_t, MATRIX: pyrosetta.rosetta.numeric.MathMatrix_float_t) -> pyrosetta.rosetta.numeric.MathMatrix_float_t

C++: numeric::MathMatrix<float>::transpose(const class numeric::MathMatrix<float> &) –> class numeric::MathMatrix<float>

transpose(self: pyrosetta.rosetta.numeric.MathMatrix_float_t) -> pyrosetta.rosetta.numeric.MathMatrix_float_t

C++: numeric::MathMatrix<float>::transpose() –> class numeric::MathMatrix<float> &

class pyrosetta.rosetta.numeric.MathNTensorBase_bool_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t, : pyrosetta.rosetta.numeric.MathNTensorBase_bool_t) → pyrosetta.rosetta.numeric.MathNTensorBase_bool_t¶: C++: numeric::MathNTensorBase<bool>::operator=(const class numeric::MathNTensorBase<bool> &) –> class numeric::MathNTensorBase<bool> &

clone(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t) → pyrosetta.rosetta.numeric.MathNTensorBase_bool_t¶: C++: numeric::MathNTensorBase<bool>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<bool> >

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t) → int¶: C++: numeric::MathNTensorBase<bool>::dimensionality() const –> unsigned long

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool¶: C++: numeric::MathNTensorBase<bool>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t) → bool¶: C++: numeric::MathNTensorBase<bool>::max() const –> bool

min(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t) → bool¶: C++: numeric::MathNTensorBase<bool>::min() const –> bool

n_bins(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t, dimension: int) → int¶: C++: numeric::MathNTensorBase<bool>::n_bins(const unsigned long) const –> unsigned long

set_value(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: bool) → None¶: C++: numeric::MathNTensorBase<bool>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const bool &) –> void

value(self: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool¶: C++: numeric::MathNTensorBase<bool>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const bool &

class pyrosetta.rosetta.numeric.MathNTensorBase_double_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t, : pyrosetta.rosetta.numeric.MathNTensorBase_double_t) → pyrosetta.rosetta.numeric.MathNTensorBase_double_t¶: C++: numeric::MathNTensorBase<double>::operator=(const class numeric::MathNTensorBase<double> &) –> class numeric::MathNTensorBase<double> &

clone(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t) → pyrosetta.rosetta.numeric.MathNTensorBase_double_t¶: C++: numeric::MathNTensorBase<double>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t) → int¶: C++: numeric::MathNTensorBase<double>::dimensionality() const –> unsigned long

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) → bool¶: C++: numeric::MathNTensorBase<double>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t) → float¶: C++: numeric::MathNTensorBase<double>::max() const –> double

min(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t) → float¶: C++: numeric::MathNTensorBase<double>::min() const –> double

n_bins(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t, dimension: int) → int¶: C++: numeric::MathNTensorBase<double>::n_bins(const unsigned long) const –> unsigned long

set_value(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) → None¶: C++: numeric::MathNTensorBase<double>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

value(self: pyrosetta.rosetta.numeric.MathNTensorBase_double_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) → float¶: C++: numeric::MathNTensorBase<double>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

class pyrosetta.rosetta.numeric.MathNTensor_bool_3_t¶

Bases: MathNTensorBase_bool_t

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, rhs: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) -> pyrosetta.rosetta.numeric.MathNTensor_bool_3_t

C++: numeric::MathNTensor<bool, 3>::operator=(const class numeric::MathNTensor<bool, 3> &) –> class numeric::MathNTensor<bool, 3> &

assign(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, : pyrosetta.rosetta.numeric.MathNTensorBase_bool_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_bool_t

C++: numeric::MathNTensorBase<bool>::operator=(const class numeric::MathNTensorBase<bool> &) –> class numeric::MathNTensorBase<bool> &

clone(*args, **kwargs)¶

Overloaded function.

clone(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_bool_t

C++: numeric::MathNTensor<bool, 3>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<bool> >

clone(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_bool_t

C++: numeric::MathNTensorBase<bool>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<bool> >

data(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, index: int) → bool¶: C++: numeric::MathNTensor<bool, 3>::data(const unsigned long) const –> const bool &

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) → int¶: C++: numeric::MathNTensorBase<bool>::dimensionality() const –> unsigned long

is_valid_position(*args, **kwargs)¶

Overloaded function.

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, positions: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t) -> bool

C++: numeric::MathNTensor<bool, 3>::is_valid_position(const class utility::fixedsizearray1<unsigned long, 3> &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensor<bool, 3>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensorBase<bool>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(*args, **kwargs)¶

Overloaded function.

max(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) -> bool

C++: numeric::MathNTensor<bool, 3>::max() const –> bool

max(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) -> bool

C++: numeric::MathNTensorBase<bool>::max() const –> bool

min(*args, **kwargs)¶

Overloaded function.

min(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) -> bool

C++: numeric::MathNTensor<bool, 3>::min() const –> bool

min(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) -> bool

C++: numeric::MathNTensorBase<bool>::min() const –> bool

n_bins(*args, **kwargs)¶

Overloaded function.

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, dimension: int) -> int

C++: numeric::MathNTensor<bool, 3>::n_bins(const unsigned long) const –> unsigned long

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) -> pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t

C++: numeric::MathNTensor<bool, 3>::n_bins() const –> const class utility::fixedsizearray1<unsigned long, 3> &

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, dimension: int) -> int

C++: numeric::MathNTensorBase<bool>::n_bins(const unsigned long) const –> unsigned long

num_dimensions(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) → int¶: C++: numeric::MathNTensor<bool, 3>::num_dimensions() const –> unsigned long

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: bool) -> None

C++: numeric::MathNTensor<bool, 3>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const bool &) –> void

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: bool) -> None

C++: numeric::MathNTensorBase<bool>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const bool &) –> void

size(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) → int¶: C++: numeric::MathNTensor<bool, 3>::size() const –> unsigned long

sum(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t) → bool¶: C++: numeric::MathNTensor<bool, 3>::sum() const –> bool

value(*args, **kwargs)¶

Overloaded function.

value(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensor<bool, 3>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const bool &

value(self: pyrosetta.rosetta.numeric.MathNTensor_bool_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensorBase<bool>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const bool &

class pyrosetta.rosetta.numeric.MathNTensor_double_1_t¶

Bases: MathNTensorBase_double_t

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, rhs: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> pyrosetta.rosetta.numeric.MathNTensor_double_1_t

C++: numeric::MathNTensor<double, 1>::operator=(const class numeric::MathNTensor<double, 1> &) –> class numeric::MathNTensor<double, 1> &

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, : pyrosetta.rosetta.numeric.MathNTensorBase_double_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::operator=(const class numeric::MathNTensorBase<double> &) –> class numeric::MathNTensorBase<double> &

clone(*args, **kwargs)¶

Overloaded function.

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensor<double, 1>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

data(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, index: int) → float¶: C++: numeric::MathNTensor<double, 1>::data(const unsigned long) const –> const double &

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) → int¶: C++: numeric::MathNTensorBase<double>::dimensionality() const –> unsigned long

get_mathmatrix(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathNTensor<double, 1>::get_mathmatrix() –> class numeric::MathMatrix<double>

is_valid_position(*args, **kwargs)¶

Overloaded function.

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, positions: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_1_t) -> bool

C++: numeric::MathNTensor<double, 1>::is_valid_position(const class utility::fixedsizearray1<unsigned long, 1> &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensor<double, 1>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensorBase<double>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(*args, **kwargs)¶

Overloaded function.

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> float

C++: numeric::MathNTensor<double, 1>::max() const –> double

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> float

C++: numeric::MathNTensorBase<double>::max() const –> double

min(*args, **kwargs)¶

Overloaded function.

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> float

C++: numeric::MathNTensor<double, 1>::min() const –> double

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> float

C++: numeric::MathNTensorBase<double>::min() const –> double

n_bins(*args, **kwargs)¶

Overloaded function.

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, dimension: int) -> int

C++: numeric::MathNTensor<double, 1>::n_bins(const unsigned long) const –> unsigned long

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_1_t

C++: numeric::MathNTensor<double, 1>::n_bins() const –> const class utility::fixedsizearray1<unsigned long, 1> &

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, dimension: int) -> int

C++: numeric::MathNTensorBase<double>::n_bins(const unsigned long) const –> unsigned long

num_dimensions(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) → int¶: C++: numeric::MathNTensor<double, 1>::num_dimensions() const –> unsigned long

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathMatrix_double_t) → None¶: C++: numeric::MathNTensor<double, 1>::replace_layer(const unsigned long, const class numeric::MathMatrix<double> &) –> void

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensor<double, 1>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensorBase<double>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

size(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) → int¶: C++: numeric::MathNTensor<double, 1>::size() const –> unsigned long

sum(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) → float¶: C++: numeric::MathNTensor<double, 1>::sum() const –> double

value(*args, **kwargs)¶

Overloaded function.

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensor<double, 1>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_1_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensorBase<double>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

class pyrosetta.rosetta.numeric.MathNTensor_double_2_t¶

Bases: MathNTensorBase_double_t

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, rhs: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> pyrosetta.rosetta.numeric.MathNTensor_double_2_t

C++: numeric::MathNTensor<double, 2>::operator=(const class numeric::MathNTensor<double, 2> &) –> class numeric::MathNTensor<double, 2> &

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, : pyrosetta.rosetta.numeric.MathNTensorBase_double_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::operator=(const class numeric::MathNTensorBase<double> &) –> class numeric::MathNTensorBase<double> &

clone(*args, **kwargs)¶

Overloaded function.

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensor<double, 2>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

data(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, index: int) → float¶: C++: numeric::MathNTensor<double, 2>::data(const unsigned long) const –> const double &

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) → int¶: C++: numeric::MathNTensorBase<double>::dimensionality() const –> unsigned long

get_mathmatrix(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathNTensor<double, 2>::get_mathmatrix() –> class numeric::MathMatrix<double>

is_valid_position(*args, **kwargs)¶

Overloaded function.

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, positions: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_2_t) -> bool

C++: numeric::MathNTensor<double, 2>::is_valid_position(const class utility::fixedsizearray1<unsigned long, 2> &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensor<double, 2>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensorBase<double>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(*args, **kwargs)¶

Overloaded function.

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> float

C++: numeric::MathNTensor<double, 2>::max() const –> double

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> float

C++: numeric::MathNTensorBase<double>::max() const –> double

min(*args, **kwargs)¶

Overloaded function.

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> float

C++: numeric::MathNTensor<double, 2>::min() const –> double

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> float

C++: numeric::MathNTensorBase<double>::min() const –> double

n_bins(*args, **kwargs)¶

Overloaded function.

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, dimension: int) -> int

C++: numeric::MathNTensor<double, 2>::n_bins(const unsigned long) const –> unsigned long

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_2_t

C++: numeric::MathNTensor<double, 2>::n_bins() const –> const class utility::fixedsizearray1<unsigned long, 2> &

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, dimension: int) -> int

C++: numeric::MathNTensorBase<double>::n_bins(const unsigned long) const –> unsigned long

num_dimensions(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) → int¶: C++: numeric::MathNTensor<double, 2>::num_dimensions() const –> unsigned long

replace_layer(*args, **kwargs)¶

Overloaded function.

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathNTensor_double_1_t) -> None

C++: numeric::MathNTensor<double, 2>::replace_layer(unsigned long, const class numeric::MathNTensor<double, 1> &) –> void

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathMatrix_double_t) -> None

C++: numeric::MathNTensor<double, 2>::replace_layer(const unsigned long, const class numeric::MathMatrix<double> &) –> void

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensor<double, 2>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensorBase<double>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

size(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) → int¶: C++: numeric::MathNTensor<double, 2>::size() const –> unsigned long

sum(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) → float¶: C++: numeric::MathNTensor<double, 2>::sum() const –> double

value(*args, **kwargs)¶

Overloaded function.

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensor<double, 2>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_2_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensorBase<double>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

class pyrosetta.rosetta.numeric.MathNTensor_double_3_t¶

Bases: MathNTensorBase_double_t

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, rhs: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> pyrosetta.rosetta.numeric.MathNTensor_double_3_t

C++: numeric::MathNTensor<double, 3>::operator=(const class numeric::MathNTensor<double, 3> &) –> class numeric::MathNTensor<double, 3> &

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, : pyrosetta.rosetta.numeric.MathNTensorBase_double_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::operator=(const class numeric::MathNTensorBase<double> &) –> class numeric::MathNTensorBase<double> &

clone(*args, **kwargs)¶

Overloaded function.

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensor<double, 3>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

data(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, index: int) → float¶: C++: numeric::MathNTensor<double, 3>::data(const unsigned long) const –> const double &

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) → int¶: C++: numeric::MathNTensorBase<double>::dimensionality() const –> unsigned long

get_mathmatrix(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathNTensor<double, 3>::get_mathmatrix() –> class numeric::MathMatrix<double>

is_valid_position(*args, **kwargs)¶

Overloaded function.

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, positions: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t) -> bool

C++: numeric::MathNTensor<double, 3>::is_valid_position(const class utility::fixedsizearray1<unsigned long, 3> &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensor<double, 3>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensorBase<double>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(*args, **kwargs)¶

Overloaded function.

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> float

C++: numeric::MathNTensor<double, 3>::max() const –> double

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> float

C++: numeric::MathNTensorBase<double>::max() const –> double

min(*args, **kwargs)¶

Overloaded function.

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> float

C++: numeric::MathNTensor<double, 3>::min() const –> double

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> float

C++: numeric::MathNTensorBase<double>::min() const –> double

n_bins(*args, **kwargs)¶

Overloaded function.

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, dimension: int) -> int

C++: numeric::MathNTensor<double, 3>::n_bins(const unsigned long) const –> unsigned long

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_3_t

C++: numeric::MathNTensor<double, 3>::n_bins() const –> const class utility::fixedsizearray1<unsigned long, 3> &

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, dimension: int) -> int

C++: numeric::MathNTensorBase<double>::n_bins(const unsigned long) const –> unsigned long

num_dimensions(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) → int¶: C++: numeric::MathNTensor<double, 3>::num_dimensions() const –> unsigned long

replace_layer(*args, **kwargs)¶

Overloaded function.

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathNTensor_double_2_t) -> None

C++: numeric::MathNTensor<double, 3>::replace_layer(unsigned long, const class numeric::MathNTensor<double, 2> &) –> void

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathMatrix_double_t) -> None

C++: numeric::MathNTensor<double, 3>::replace_layer(const unsigned long, const class numeric::MathMatrix<double> &) –> void

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensor<double, 3>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensorBase<double>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

size(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) → int¶: C++: numeric::MathNTensor<double, 3>::size() const –> unsigned long

sum(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) → float¶: C++: numeric::MathNTensor<double, 3>::sum() const –> double

value(*args, **kwargs)¶

Overloaded function.

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensor<double, 3>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_3_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensorBase<double>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

class pyrosetta.rosetta.numeric.MathNTensor_double_4_t¶

Bases: MathNTensorBase_double_t

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, rhs: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> pyrosetta.rosetta.numeric.MathNTensor_double_4_t

C++: numeric::MathNTensor<double, 4>::operator=(const class numeric::MathNTensor<double, 4> &) –> class numeric::MathNTensor<double, 4> &

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, : pyrosetta.rosetta.numeric.MathNTensorBase_double_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::operator=(const class numeric::MathNTensorBase<double> &) –> class numeric::MathNTensorBase<double> &

clone(*args, **kwargs)¶

Overloaded function.

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensor<double, 4>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

data(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, index: int) → float¶: C++: numeric::MathNTensor<double, 4>::data(const unsigned long) const –> const double &

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) → int¶: C++: numeric::MathNTensorBase<double>::dimensionality() const –> unsigned long

get_mathmatrix(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathNTensor<double, 4>::get_mathmatrix() –> class numeric::MathMatrix<double>

is_valid_position(*args, **kwargs)¶

Overloaded function.

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, positions: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_4_t) -> bool

C++: numeric::MathNTensor<double, 4>::is_valid_position(const class utility::fixedsizearray1<unsigned long, 4> &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensor<double, 4>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensorBase<double>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(*args, **kwargs)¶

Overloaded function.

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> float

C++: numeric::MathNTensor<double, 4>::max() const –> double

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> float

C++: numeric::MathNTensorBase<double>::max() const –> double

min(*args, **kwargs)¶

Overloaded function.

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> float

C++: numeric::MathNTensor<double, 4>::min() const –> double

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> float

C++: numeric::MathNTensorBase<double>::min() const –> double

n_bins(*args, **kwargs)¶

Overloaded function.

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, dimension: int) -> int

C++: numeric::MathNTensor<double, 4>::n_bins(const unsigned long) const –> unsigned long

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_4_t

C++: numeric::MathNTensor<double, 4>::n_bins() const –> const class utility::fixedsizearray1<unsigned long, 4> &

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, dimension: int) -> int

C++: numeric::MathNTensorBase<double>::n_bins(const unsigned long) const –> unsigned long

num_dimensions(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) → int¶: C++: numeric::MathNTensor<double, 4>::num_dimensions() const –> unsigned long

replace_layer(*args, **kwargs)¶

Overloaded function.

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathNTensor_double_3_t) -> None

C++: numeric::MathNTensor<double, 4>::replace_layer(unsigned long, const class numeric::MathNTensor<double, 3> &) –> void

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathMatrix_double_t) -> None

C++: numeric::MathNTensor<double, 4>::replace_layer(const unsigned long, const class numeric::MathMatrix<double> &) –> void

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensor<double, 4>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensorBase<double>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

size(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) → int¶: C++: numeric::MathNTensor<double, 4>::size() const –> unsigned long

sum(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) → float¶: C++: numeric::MathNTensor<double, 4>::sum() const –> double

value(*args, **kwargs)¶

Overloaded function.

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensor<double, 4>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_4_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensorBase<double>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

class pyrosetta.rosetta.numeric.MathNTensor_double_5_t¶

Bases: MathNTensorBase_double_t

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, rhs: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> pyrosetta.rosetta.numeric.MathNTensor_double_5_t

C++: numeric::MathNTensor<double, 5>::operator=(const class numeric::MathNTensor<double, 5> &) –> class numeric::MathNTensor<double, 5> &

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, : pyrosetta.rosetta.numeric.MathNTensorBase_double_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::operator=(const class numeric::MathNTensorBase<double> &) –> class numeric::MathNTensorBase<double> &

clone(*args, **kwargs)¶

Overloaded function.

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensor<double, 5>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

data(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, index: int) → float¶: C++: numeric::MathNTensor<double, 5>::data(const unsigned long) const –> const double &

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) → int¶: C++: numeric::MathNTensorBase<double>::dimensionality() const –> unsigned long

get_mathmatrix(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathNTensor<double, 5>::get_mathmatrix() –> class numeric::MathMatrix<double>

is_valid_position(*args, **kwargs)¶

Overloaded function.

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, positions: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_5_t) -> bool

C++: numeric::MathNTensor<double, 5>::is_valid_position(const class utility::fixedsizearray1<unsigned long, 5> &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensor<double, 5>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensorBase<double>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(*args, **kwargs)¶

Overloaded function.

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> float

C++: numeric::MathNTensor<double, 5>::max() const –> double

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> float

C++: numeric::MathNTensorBase<double>::max() const –> double

min(*args, **kwargs)¶

Overloaded function.

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> float

C++: numeric::MathNTensor<double, 5>::min() const –> double

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> float

C++: numeric::MathNTensorBase<double>::min() const –> double

n_bins(*args, **kwargs)¶

Overloaded function.

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, dimension: int) -> int

C++: numeric::MathNTensor<double, 5>::n_bins(const unsigned long) const –> unsigned long

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_5_t

C++: numeric::MathNTensor<double, 5>::n_bins() const –> const class utility::fixedsizearray1<unsigned long, 5> &

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, dimension: int) -> int

C++: numeric::MathNTensorBase<double>::n_bins(const unsigned long) const –> unsigned long

num_dimensions(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) → int¶: C++: numeric::MathNTensor<double, 5>::num_dimensions() const –> unsigned long

replace_layer(*args, **kwargs)¶

Overloaded function.

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathNTensor_double_4_t) -> None

C++: numeric::MathNTensor<double, 5>::replace_layer(unsigned long, const class numeric::MathNTensor<double, 4> &) –> void

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathMatrix_double_t) -> None

C++: numeric::MathNTensor<double, 5>::replace_layer(const unsigned long, const class numeric::MathMatrix<double> &) –> void

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensor<double, 5>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensorBase<double>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

size(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) → int¶: C++: numeric::MathNTensor<double, 5>::size() const –> unsigned long

sum(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) → float¶: C++: numeric::MathNTensor<double, 5>::sum() const –> double

value(*args, **kwargs)¶

Overloaded function.

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensor<double, 5>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_5_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensorBase<double>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

class pyrosetta.rosetta.numeric.MathNTensor_double_6_t¶

Bases: MathNTensorBase_double_t

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, rhs: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) -> pyrosetta.rosetta.numeric.MathNTensor_double_6_t

C++: numeric::MathNTensor<double, 6>::operator=(const class numeric::MathNTensor<double, 6> &) –> class numeric::MathNTensor<double, 6> &

assign(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, : pyrosetta.rosetta.numeric.MathNTensorBase_double_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::operator=(const class numeric::MathNTensorBase<double> &) –> class numeric::MathNTensorBase<double> &

clone(*args, **kwargs)¶

Overloaded function.

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensor<double, 6>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

clone(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) -> pyrosetta.rosetta.numeric.MathNTensorBase_double_t

C++: numeric::MathNTensorBase<double>::clone() const –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

data(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, index: int) → float¶: C++: numeric::MathNTensor<double, 6>::data(const unsigned long) const –> const double &

dimensionality(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) → int¶: C++: numeric::MathNTensorBase<double>::dimensionality() const –> unsigned long

get_mathmatrix(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) → pyrosetta.rosetta.numeric.MathMatrix_double_t¶: C++: numeric::MathNTensor<double, 6>::get_mathmatrix() –> class numeric::MathMatrix<double>

is_valid_position(*args, **kwargs)¶

Overloaded function.

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, positions: pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_6_t) -> bool

C++: numeric::MathNTensor<double, 6>::is_valid_position(const class utility::fixedsizearray1<unsigned long, 6> &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, positions: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensor<double, 6>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

is_valid_position(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> bool

C++: numeric::MathNTensorBase<double>::is_valid_position(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> bool

max(*args, **kwargs)¶

Overloaded function.

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) -> float

C++: numeric::MathNTensor<double, 6>::max() const –> double

max(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) -> float

C++: numeric::MathNTensorBase<double>::max() const –> double

min(*args, **kwargs)¶

Overloaded function.

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) -> float

C++: numeric::MathNTensor<double, 6>::min() const –> double

min(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) -> float

C++: numeric::MathNTensorBase<double>::min() const –> double

n_bins(*args, **kwargs)¶

Overloaded function.

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, dimension: int) -> int

C++: numeric::MathNTensor<double, 6>::n_bins(const unsigned long) const –> unsigned long

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) -> pyrosetta.rosetta.utility.fixedsizearray1_unsigned_long_6_t

C++: numeric::MathNTensor<double, 6>::n_bins() const –> const class utility::fixedsizearray1<unsigned long, 6> &

n_bins(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, dimension: int) -> int

C++: numeric::MathNTensorBase<double>::n_bins(const unsigned long) const –> unsigned long

num_dimensions(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) → int¶: C++: numeric::MathNTensor<double, 6>::num_dimensions() const –> unsigned long

replace_layer(*args, **kwargs)¶

Overloaded function.

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathNTensor_double_5_t) -> None

C++: numeric::MathNTensor<double, 6>::replace_layer(unsigned long, const class numeric::MathNTensor<double, 5> &) –> void

replace_layer(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathMatrix_double_t) -> None

C++: numeric::MathNTensor<double, 6>::replace_layer(const unsigned long, const class numeric::MathMatrix<double> &) –> void

set_value(*args, **kwargs)¶

Overloaded function.

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensor<double, 6>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

set_value(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long, value_in: float) -> None

C++: numeric::MathNTensorBase<double>::set_value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const double &) –> void

size(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) → int¶: C++: numeric::MathNTensor<double, 6>::size() const –> unsigned long

sum(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t) → float¶: C++: numeric::MathNTensor<double, 6>::sum() const –> double

value(*args, **kwargs)¶

Overloaded function.

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensor<double, 6>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

value(self: pyrosetta.rosetta.numeric.MathNTensor_double_6_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) -> float

C++: numeric::MathNTensorBase<double>::value(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) const –> const double &

class pyrosetta.rosetta.numeric.MathTensor_double_t¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.MathTensor_double_t, rhs: pyrosetta.rosetta.numeric.MathTensor_double_t) → pyrosetta.rosetta.numeric.MathTensor_double_t¶: C++: numeric::MathTensor<double>::operator=(const class numeric::MathTensor<double> &) –> class numeric::MathTensor<double> &

is_valid_position(self: pyrosetta.rosetta.numeric.MathTensor_double_t, layer: int, row: int, column: int) → bool¶: C++: numeric::MathTensor<double>::is_valid_position(unsigned long, unsigned long, unsigned long) const –> bool

ncols(self: pyrosetta.rosetta.numeric.MathTensor_double_t) → int¶: C++: numeric::MathTensor<double>::ncols() const –> unsigned long

nlayers(self: pyrosetta.rosetta.numeric.MathTensor_double_t) → int¶: C++: numeric::MathTensor<double>::nlayers() const –> unsigned long

nrows(self: pyrosetta.rosetta.numeric.MathTensor_double_t) → int¶: C++: numeric::MathTensor<double>::nrows() const –> unsigned long

replace_layer(self: pyrosetta.rosetta.numeric.MathTensor_double_t, layer: int, matrix: pyrosetta.rosetta.numeric.MathMatrix_double_t) → None¶: C++: numeric::MathTensor<double>::replace_layer(const unsigned long, const class numeric::MathMatrix<double> &) –> void

class pyrosetta.rosetta.numeric.MathVector_double_t¶

Bases: pybind11_object

MakeVector(*args, **kwargs)¶

Overloaded function.

MakeVector(self: pyrosetta.rosetta.numeric.MathVector_double_t, X: float) -> pyrosetta.rosetta.numeric.MathVector_double_t

C++: numeric::MathVector<double>::MakeVector(const double &) –> class numeric::MathVector<double>

MakeVector(self: pyrosetta.rosetta.numeric.MathVector_double_t, X: float, Y: float) -> pyrosetta.rosetta.numeric.MathVector_double_t

C++: numeric::MathVector<double>::MakeVector(const double &, const double &) –> class numeric::MathVector<double>

MakeVector(self: pyrosetta.rosetta.numeric.MathVector_double_t, X: float, Y: float, Z: float) -> pyrosetta.rosetta.numeric.MathVector_double_t

C++: numeric::MathVector<double>::MakeVector(const double &, const double &, const double &) –> class numeric::MathVector<double>

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.MathVector_double_t, VECTOR: pyrosetta.rosetta.numeric.MathVector_double_t) -> pyrosetta.rosetta.numeric.MathVector_double_t

C++: numeric::MathVector<double>::operator=(const class numeric::MathVector<double> &) –> class numeric::MathVector<double> &

assign(self: pyrosetta.rosetta.numeric.MathVector_double_t, VALUE: float) -> pyrosetta.rosetta.numeric.MathVector_double_t

C++: numeric::MathVector<double>::operator=(const double &) –> class numeric::MathVector<double> &

begin(self: pyrosetta.rosetta.numeric.MathVector_double_t) → float¶: C++: numeric::MathVector<double>::begin() –> double *

clone(self: pyrosetta.rosetta.numeric.MathVector_double_t) → pyrosetta.rosetta.numeric.MathVector_double_t¶: C++: numeric::MathVector<double>::clone() const –> class numeric::MathVector<double> *

end(self: pyrosetta.rosetta.numeric.MathVector_double_t) → float¶: C++: numeric::MathVector<double>::end() –> double *

norm(self: pyrosetta.rosetta.numeric.MathVector_double_t) → float¶: C++: numeric::MathVector<double>::norm() const –> double

size(self: pyrosetta.rosetta.numeric.MathVector_double_t) → int¶: C++: numeric::MathVector<double>::size() const –> unsigned long

square_norm(self: pyrosetta.rosetta.numeric.MathVector_double_t) → float¶: C++: numeric::MathVector<double>::square_norm() const –> double

sum(self: pyrosetta.rosetta.numeric.MathVector_double_t) → float¶: C++: numeric::MathVector<double>::sum() const –> double

class pyrosetta.rosetta.numeric.ModSelector_long_true_t¶

Bases: pybind11_object

static mod(x: int, y: int) → int¶: C++: numeric::ModSelector<long, true>::mod(const long &, const long &) –> long

class pyrosetta.rosetta.numeric.ModSelector_unsigned_long_true_t¶

Bases: pybind11_object

static mod(x: int, y: int) → int¶: C++: numeric::ModSelector<unsigned long, true>::mod(const unsigned long &, const unsigned long &) –> unsigned long

class pyrosetta.rosetta.numeric.ModuloSelector_double_false_t¶

Bases: pybind11_object

static modulo(x: float, y: float) → float¶: C++: numeric::ModuloSelector<double, false>::modulo(const double &, const double &) –> double

class pyrosetta.rosetta.numeric.ModuloSelector_int_true_t¶

Bases: pybind11_object

static modulo(x: int, y: int) → int¶: C++: numeric::ModuloSelector<int, true>::modulo(const int &, const int &) –> int

class pyrosetta.rosetta.numeric.MultiDimensionalHistogram¶

Bases: pybind11_object

a class for accumulating a histogram of one or more numeric variables

assign(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, rhs: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) → pyrosetta.rosetta.numeric.MultiDimensionalHistogram¶

operator=

C++: numeric::MultiDimensionalHistogram::operator=(const class numeric::MultiDimensionalHistogram &) –> class numeric::MultiDimensionalHistogram &

collapse(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, dimensions: pyrosetta.rosetta.utility.vector1_unsigned_long) → pyrosetta.rosetta.numeric.MultiDimensionalHistogram¶: C++: numeric::MultiDimensionalHistogram::collapse(class utility::vector1<unsigned long, class std::allocator<unsigned long> >) const –> class numeric::MultiDimensionalHistogram

counts(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) → pyrosetta.rosetta.utility.vector0_unsigned_long¶: C++: numeric::MultiDimensionalHistogram::counts() const –> const class utility::vector0<unsigned long, class std::allocator<unsigned long> > &

dim_labels(*args, **kwargs)¶

Overloaded function.

dim_labels(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) -> pyrosetta.rosetta.utility.vector1_std_string

C++: numeric::MultiDimensionalHistogram::dim_labels() const –> class utility::vector1<std::string, class std::allocator<std::string > >

dim_labels(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, dim_labels1: pyrosetta.rosetta.utility.vector1_std_string) -> None

C++: numeric::MultiDimensionalHistogram::dim_labels(const class utility::vector1<std::string, class std::allocator<std::string > > &) –> void

end(*args, **kwargs)¶

Overloaded function.

end(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) -> pyrosetta.rosetta.utility.vector1_double

C++: numeric::MultiDimensionalHistogram::end() const –> class utility::vector1<double, class std::allocator<double> >

end(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, end: float) -> None

C++: numeric::MultiDimensionalHistogram::end(double) –> void

end(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, end1: pyrosetta.rosetta.utility.vector1_double) -> None

C++: numeric::MultiDimensionalHistogram::end(const class utility::vector1<double, class std::allocator<double> > &) –> void

end(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, dim: int, end: float) -> None

C++: numeric::MultiDimensionalHistogram::end(unsigned long, double) –> void

label(*args, **kwargs)¶

Overloaded function.

label(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) -> str

C++: numeric::MultiDimensionalHistogram::label() const –> const std::string &

label(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, label: str) -> None

C++: numeric::MultiDimensionalHistogram::label(const std::string &) –> void

mean_squared_error(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, expected_1d_frequencies: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t) → float¶: C++: numeric::MultiDimensionalHistogram::mean_squared_error(const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &) –> double

num_bins(*args, **kwargs)¶

Overloaded function.

num_bins(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) -> pyrosetta.rosetta.utility.vector1_unsigned_long

C++: numeric::MultiDimensionalHistogram::num_bins() const –> class utility::vector1<unsigned long, class std::allocator<unsigned long> >

num_bins(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, num_bins: int) -> None

C++: numeric::MultiDimensionalHistogram::num_bins(unsigned long) –> void

num_bins(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, num_bins1: pyrosetta.rosetta.utility.vector1_unsigned_long) -> None

C++: numeric::MultiDimensionalHistogram::num_bins(const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> void

num_bins(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, dim: int, num_bins: int) -> None

C++: numeric::MultiDimensionalHistogram::num_bins(unsigned long, unsigned long) –> void

num_dimensions(*args, **kwargs)¶

Overloaded function.

num_dimensions(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) -> int

C++: numeric::MultiDimensionalHistogram::num_dimensions() const –> unsigned long

num_dimensions(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, num: int) -> None

C++: numeric::MultiDimensionalHistogram::num_dimensions(unsigned long) –> void

range(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, dim: int, start: float, end: float) → None¶: C++: numeric::MultiDimensionalHistogram::range(unsigned long, double, double) –> void

record(*args, **kwargs)¶

Overloaded function.

record(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, values: pyrosetta.rosetta.utility.vector1_double) -> None

C++: numeric::MultiDimensionalHistogram::record(const class utility::vector1<double, class std::allocator<double> > &) –> void

record(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, value: float) -> None

C++: numeric::MultiDimensionalHistogram::record(double) –> void

reset_counts(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) → None¶: C++: numeric::MultiDimensionalHistogram::reset_counts() –> void

set_dimension(*args, **kwargs)¶

Overloaded function.

set_dimension(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, dim: int, num_bins: int, start: float, end: float) -> None
set_dimension(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, dim: int, num_bins: int, start: float, end: float, label: str) -> None

C++: numeric::MultiDimensionalHistogram::set_dimension(unsigned long, unsigned long, double, double, std::string) –> void

start(*args, **kwargs)¶

Overloaded function.

start(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, start: float) -> None

C++: numeric::MultiDimensionalHistogram::start(double) –> void

start(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) -> pyrosetta.rosetta.utility.vector1_double

C++: numeric::MultiDimensionalHistogram::start() const –> class utility::vector1<double, class std::allocator<double> >

start(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, start1: pyrosetta.rosetta.utility.vector1_double) -> None

C++: numeric::MultiDimensionalHistogram::start(const class utility::vector1<double, class std::allocator<double> > &) –> void

start(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram, dim: int, start: float) -> None

C++: numeric::MultiDimensionalHistogram::start(unsigned long, double) –> void

total_counts(self: pyrosetta.rosetta.numeric.MultiDimensionalHistogram) → int¶: C++: numeric::MultiDimensionalHistogram::total_counts() const –> unsigned long

class pyrosetta.rosetta.numeric.NumericTraits_double_t¶

Bases: pybind11_object

NumericTraits: Numeric type traits double specialization

static angle_tolerance() → float¶

Angle tolerance (radians)

C++: numeric::NumericTraits<double>::angle_tolerance() –> double

static deg2rad() → float¶

pi/180

C++: numeric::NumericTraits<double>::deg2rad() –> double

static degrees_to_radians() → float¶

pi/180

C++: numeric::NumericTraits<double>::degrees_to_radians() –> double

static length_tolerance() → float¶

Length tolerance

C++: numeric::NumericTraits<double>::length_tolerance() –> double

static one() → float¶

One

C++: numeric::NumericTraits<double>::one() –> double

static pi() → float¶

pi

C++: numeric::NumericTraits<double>::pi() –> double

static pi_2() → float¶

2*pi

C++: numeric::NumericTraits<double>::pi_2() –> double

static pi_2_over_3() → float¶

(2*pi)/3

C++: numeric::NumericTraits<double>::pi_2_over_3() –> double

static pi_3_over_4() → float¶

(3*pi)/4

C++: numeric::NumericTraits<double>::pi_3_over_4() –> double

static pi_over_180() → float¶

pi/180

C++: numeric::NumericTraits<double>::pi_over_180() –> double

static pi_over_2() → float¶

pi/2

C++: numeric::NumericTraits<double>::pi_over_2() –> double

static pi_over_3() → float¶

pi/3

C++: numeric::NumericTraits<double>::pi_over_3() –> double

static pi_over_4() → float¶

pi/4

C++: numeric::NumericTraits<double>::pi_over_4() –> double

static quaternion_tolerance() → float¶

Quaternion normalization tolerance

C++: numeric::NumericTraits<double>::quaternion_tolerance() –> double

static rad2deg() → float¶

180/pi

C++: numeric::NumericTraits<double>::rad2deg() –> double

static radians_to_degrees() → float¶

180/pi

C++: numeric::NumericTraits<double>::radians_to_degrees() –> double

static sin_cos_tolerance() → float¶

Sine cosine range tolerance

C++: numeric::NumericTraits<double>::sin_cos_tolerance() –> double

static sqrt_2pi() → float¶

sqrt(2*pi)

C++: numeric::NumericTraits<double>::sqrt_2pi() –> double

static tolerance() → float¶

Tolerance

C++: numeric::NumericTraits<double>::tolerance() –> double

static two() → float¶

Two

C++: numeric::NumericTraits<double>::two() –> double

static zero() → float¶

Zero

C++: numeric::NumericTraits<double>::zero() –> double

class pyrosetta.rosetta.numeric.NumericTraits_float_t¶

Bases: pybind11_object

NumericTraits: Numeric type traits float specialization

static angle_tolerance() → float¶

Angle tolerance (radians)

C++: numeric::NumericTraits<float>::angle_tolerance() –> float

static deg2rad() → float¶

pi/180

C++: numeric::NumericTraits<float>::deg2rad() –> float

static degrees_to_radians() → float¶

pi/180

C++: numeric::NumericTraits<float>::degrees_to_radians() –> float

static length_tolerance() → float¶

Length tolerance

C++: numeric::NumericTraits<float>::length_tolerance() –> float

static one() → float¶

One

C++: numeric::NumericTraits<float>::one() –> float

static pi() → float¶

pi

C++: numeric::NumericTraits<float>::pi() –> float

static pi_2() → float¶

2*pi

C++: numeric::NumericTraits<float>::pi_2() –> float

static pi_2_over_3() → float¶

(2*pi)/3

C++: numeric::NumericTraits<float>::pi_2_over_3() –> float

static pi_3_over_4() → float¶

(3*pi)/4

C++: numeric::NumericTraits<float>::pi_3_over_4() –> float

static pi_over_180() → float¶

pi/180

C++: numeric::NumericTraits<float>::pi_over_180() –> float

static pi_over_2() → float¶

pi/2

C++: numeric::NumericTraits<float>::pi_over_2() –> float

static pi_over_3() → float¶

pi/3

C++: numeric::NumericTraits<float>::pi_over_3() –> float

static pi_over_4() → float¶

pi/4

C++: numeric::NumericTraits<float>::pi_over_4() –> float

static quaternion_tolerance() → float¶

Quaternion normalization tolerance

C++: numeric::NumericTraits<float>::quaternion_tolerance() –> float

static rad2deg() → float¶

180/pi

C++: numeric::NumericTraits<float>::rad2deg() –> float

static radians_to_degrees() → float¶

180/pi

C++: numeric::NumericTraits<float>::radians_to_degrees() –> float

static sin_cos_tolerance() → float¶

Sine cosine range tolerance

C++: numeric::NumericTraits<float>::sin_cos_tolerance() –> float

static sqrt_2pi() → float¶

sqrt(2*pi)

C++: numeric::NumericTraits<float>::sqrt_2pi() –> float

static tolerance() → float¶

Tolerance

C++: numeric::NumericTraits<float>::tolerance() –> float

static two() → float¶

Two

C++: numeric::NumericTraits<float>::two() –> float

static zero() → float¶

Zero

C++: numeric::NumericTraits<float>::zero() –> float

class pyrosetta.rosetta.numeric.NumericTraits_long_double_t¶

Bases: pybind11_object

NumericTraits: Numeric type traits long double specialization

static angle_tolerance() → float¶

Angle tolerance (radians)

C++: numeric::NumericTraits<long double>::angle_tolerance() –> long double

static deg2rad() → float¶

pi/180

C++: numeric::NumericTraits<long double>::deg2rad() –> long double

static degrees_to_radians() → float¶

pi/180

C++: numeric::NumericTraits<long double>::degrees_to_radians() –> long double

static length_tolerance() → float¶

Length tolerance

C++: numeric::NumericTraits<long double>::length_tolerance() –> long double

static one() → float¶

One

C++: numeric::NumericTraits<long double>::one() –> long double

static pi() → float¶

pi

C++: numeric::NumericTraits<long double>::pi() –> long double

static pi_2() → float¶

2*pi

C++: numeric::NumericTraits<long double>::pi_2() –> long double

static pi_2_over_3() → float¶

(2*pi)/3

C++: numeric::NumericTraits<long double>::pi_2_over_3() –> long double

static pi_3_over_4() → float¶

(3*pi)/4

C++: numeric::NumericTraits<long double>::pi_3_over_4() –> long double

static pi_over_180() → float¶

pi/180

C++: numeric::NumericTraits<long double>::pi_over_180() –> long double

static pi_over_2() → float¶

pi/2

C++: numeric::NumericTraits<long double>::pi_over_2() –> long double

static pi_over_3() → float¶

pi/3

C++: numeric::NumericTraits<long double>::pi_over_3() –> long double

static pi_over_4() → float¶

pi/4

C++: numeric::NumericTraits<long double>::pi_over_4() –> long double

static quaternion_tolerance() → float¶

Quaternion normalization tolerance

C++: numeric::NumericTraits<long double>::quaternion_tolerance() –> long double

static rad2deg() → float¶

180/pi

C++: numeric::NumericTraits<long double>::rad2deg() –> long double

static radians_to_degrees() → float¶

180/pi

C++: numeric::NumericTraits<long double>::radians_to_degrees() –> long double

static sin_cos_tolerance() → float¶

Sine cosine range tolerance

C++: numeric::NumericTraits<long double>::sin_cos_tolerance() –> long double

static sqrt_2pi() → float¶

sqrt(2*pi)

C++: numeric::NumericTraits<long double>::sqrt_2pi() –> long double

static tolerance() → float¶

Tolerance

C++: numeric::NumericTraits<long double>::tolerance() –> long double

static two() → float¶

Two

C++: numeric::NumericTraits<long double>::two() –> long double

static zero() → float¶

Zero

C++: numeric::NumericTraits<long double>::zero() –> long double

class pyrosetta.rosetta.numeric.Polynomial_1d¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.Polynomial_1d, : pyrosetta.rosetta.numeric.Polynomial_1d) → pyrosetta.rosetta.numeric.Polynomial_1d¶: C++: numeric::Polynomial_1d::operator=(const class numeric::Polynomial_1d &) –> class numeric::Polynomial_1d &

check_invariants(self: pyrosetta.rosetta.numeric.Polynomial_1d) → None¶: C++: numeric::Polynomial_1d::check_invariants() const –> void

coefficients(self: pyrosetta.rosetta.numeric.Polynomial_1d) → pyrosetta.rosetta.utility.vector1_double¶: C++: numeric::Polynomial_1d::coefficients() const –> const class utility::vector1<double, class std::allocator<double> > &

degree(self: pyrosetta.rosetta.numeric.Polynomial_1d) → int¶: C++: numeric::Polynomial_1d::degree() const –> unsigned long

eval(self: pyrosetta.rosetta.numeric.Polynomial_1d, variable: float) → float¶

just evaluate the polynomial, w/o derivatives

C++: numeric::Polynomial_1d::eval(const double) –> double

max_val(self: pyrosetta.rosetta.numeric.Polynomial_1d) → float¶: C++: numeric::Polynomial_1d::max_val() const –> double

min_val(self: pyrosetta.rosetta.numeric.Polynomial_1d) → float¶: C++: numeric::Polynomial_1d::min_val() const –> double

name(self: pyrosetta.rosetta.numeric.Polynomial_1d) → str¶: C++: numeric::Polynomial_1d::name() const –> const std::string &

root1(self: pyrosetta.rosetta.numeric.Polynomial_1d) → float¶: C++: numeric::Polynomial_1d::root1() const –> double

root2(self: pyrosetta.rosetta.numeric.Polynomial_1d) → float¶: C++: numeric::Polynomial_1d::root2() const –> double

show(self: pyrosetta.rosetta.numeric.Polynomial_1d, out: pyrosetta.rosetta.std.ostream) → None¶: C++: numeric::Polynomial_1d::show(std::ostream &) const –> void

xmax(self: pyrosetta.rosetta.numeric.Polynomial_1d) → float¶: C++: numeric::Polynomial_1d::xmax() const –> double

xmin(self: pyrosetta.rosetta.numeric.Polynomial_1d) → float¶: C++: numeric::Polynomial_1d::xmin() const –> double

class pyrosetta.rosetta.numeric.Py_xyzTransform_double¶

Bases: xyzTransform_double_t

static BAD_RT6() → pyrosetta.rosetta.utility.fixedsizearray1_double_6_t¶: C++: numeric::xyzTransform<double>::BAD_RT6() –> class utility::fixedsizearray1<double, 6>

static BAD_XFORM() → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::BAD_XFORM() –> class numeric::xyzTransform<double>

property R¶

static align(*args, **kwargs)¶

Overloaded function.

align(to: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
align(to: pyrosetta.rosetta.numeric.xyzVector_double_t, from: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::align(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

static align_fast(*args, **kwargs)¶

Overloaded function.

align_fast(to: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
align_fast(to: pyrosetta.rosetta.numeric.xyzVector_double_t, from: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::align_fast(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

approx_lever_distance(*args, **kwargs)¶

Overloaded function.

approx_lever_distance(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, o: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> float
approx_lever_distance(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, o: pyrosetta.rosetta.numeric.xyzTransform_double_t, lever: float) -> float

C++: numeric::xyzTransform<double>::approx_lever_distance(const class numeric::xyzTransform<double> &, const double &) const –> double

assign(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, : pyrosetta.rosetta.numeric.xyzTransform_double_t) → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::operator=(const class numeric::xyzTransform<double> &) –> class numeric::xyzTransform<double> &

bad(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → bool¶: C++: numeric::xyzTransform<double>::bad() const –> bool

badfast(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → bool¶: C++: numeric::xyzTransform<double>::badfast() const –> bool

distance(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, b: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::distance(const class numeric::xyzTransform<double> &) const –> double

distance_squared(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, b: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::distance_squared(const class numeric::xyzTransform<double> &) const –> double

euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzTransform<double>::euler_angles_deg() const –> class numeric::xyzVector<double>

euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzTransform<double>::euler_angles_rad() const –> class numeric::xyzVector<double>

from_euler_angles_deg(*args, **kwargs)¶

Overloaded function.

from_euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, phi: float, psi: float, theta: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::from_euler_angles_deg(const double &, const double &, const double &) –> class numeric::xyzTransform<double> &

from_euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, euler: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::from_euler_angles_deg(const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double> &

from_euler_angles_rad(*args, **kwargs)¶

Overloaded function.

from_euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, phi: float, psi: float, theta: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::from_euler_angles_rad(const double &, const double &, const double &) –> class numeric::xyzTransform<double> &

from_euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, euler: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::from_euler_angles_rad(const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double> &

from_four_points(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, c: pyrosetta.rosetta.numeric.xyzVector_double_t, u: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t, w: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::from_four_points(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double> &

from_quaternion(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, qw: float, qx: float, qy: float, qz: float) → None¶: C++: numeric::xyzTransform<double>::from_quaternion(const double &, const double &, const double &, const double &) –> void

hash64(*args, **kwargs)¶

Overloaded function.

hash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> int
hash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, cw: float) -> int
hash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, cw: float, aw: float) -> int

C++: numeric::xyzTransform<double>::hash64(const double &, const double &) const –> unsigned long

static identity() → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::identity() –> class numeric::xyzTransform<double>

inv_xform(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzTransform<double>::inv_xform(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

inverse(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::inverse() const –> class numeric::xyzTransform<double>

px(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::px() –> double &

py(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::py() –> double &

pz(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::pz() –> double &

static rot(*args, **kwargs)¶

Overloaded function.

rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_double_t, o_cen: pyrosetta.rosetta.numeric.xyzVector_double_t, cen: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rot(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_double_t, cen: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rot(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

rot(axs: pyrosetta.rosetta.numeric.xyzVector_double_t, ang: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
rot(axs: pyrosetta.rosetta.numeric.xyzVector_double_t, ang: float, cen: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rot(const class numeric::xyzVector<double> &, const double &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

static rot_deg(*args, **kwargs)¶

Overloaded function.

rot_deg(axs: pyrosetta.rosetta.numeric.xyzVector_double_t, ang: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
rot_deg(axs: pyrosetta.rosetta.numeric.xyzVector_double_t, ang: float, cen: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rot_deg(const class numeric::xyzVector<double> &, const double &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

rotation_angle(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::rotation_angle() const –> double

rotation_angle_degrees(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::rotation_angle_degrees() const –> double

rotation_axis(*args, **kwargs)¶

Overloaded function.

rotation_axis(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, axis: pyrosetta.rosetta.numeric.xyzVector_double_t, cen: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::xyzTransform<double>::rotation_axis(class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, double &) const –> void

rotation_axis(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzTransform<double>::rotation_axis() const –> class numeric::xyzVector<double>

rotation_cosine(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::rotation_cosine() const –> double

rotation_sine(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::rotation_sine() const –> double

rt6(*args, **kwargs)¶

Overloaded function.

rt6(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> pyrosetta.rosetta.utility.fixedsizearray1_double_6_t

C++: numeric::xyzTransform<double>::rt6() const –> class utility::fixedsizearray1<double, 6>

rt6(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, rt6: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rt6(const class utility::fixedsizearray1<double, 6> &) –> class numeric::xyzTransform<double> &

rt6(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, i: float, j: float, k: float, l: float, m: float, n: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rt6(const double &, const double &, const double &, const double &, const double &, const double &) –> class numeric::xyzTransform<double> &

symhash64(*args, **kwargs)¶

Overloaded function.

symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> int
symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, cw: float) -> int
symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, cw: float, aw: float) -> int

C++: numeric::xyzTransform<double>::symhash64(const double &, const double &) const –> unsigned long

property t¶

to_quaternion(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, qw: float, qx: float, qy: float, qz: float) → None¶: C++: numeric::xyzTransform<double>::to_quaternion(double &, double &, double &, double &) const –> void

x(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::x() –> double &

xform(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzTransform<double>::xform(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

xx(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::xx() –> double &

xy(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::xy() –> double &

xz(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::xz() –> double &

y(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::y() –> double &

yx(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::yx() –> double &

yy(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::yy() –> double &

yz(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::yz() –> double &

z(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::z() –> double &

zx(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::zx() –> double &

zy(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::zy() –> double &

zz(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::zz() –> double &

class pyrosetta.rosetta.numeric.Quaternion_double_t¶

Bases: pybind11_object

static I() → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::I() –> const class numeric::Quaternion<double> &

angle(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::angle() const –> double

apply(*args, **kwargs)¶

Overloaded function.

apply(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t
apply(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t, precise: bool) -> pyrosetta.rosetta.numeric.Quaternion_double_t

C++: numeric::Quaternion<double>::apply(const class numeric::Quaternion<double> &, const bool) –> class numeric::Quaternion<double> &

assign(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::operator=(const class numeric::Quaternion<double> &) –> class numeric::Quaternion<double> &

axis(*args, **kwargs)¶

Overloaded function.

axis(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::Quaternion<double>::axis() const –> class numeric::xyzVector<double>

axis(self: pyrosetta.rosetta.numeric.Quaternion_double_t, u: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::Quaternion<double>::axis(class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double> &

conjugate(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::conjugate() –> class numeric::Quaternion<double> &

conjugated(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::conjugated() const –> class numeric::Quaternion<double>

dot(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::dot(const class numeric::Quaternion<double> &) const –> double

dot_product(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::dot_product(const class numeric::Quaternion<double> &) const –> double

static identity() → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::identity() –> class numeric::Quaternion<double>

inverse(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::inverse() const –> class numeric::Quaternion<double>

invert(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::invert() –> class numeric::Quaternion<double> &

is_normalized(*args, **kwargs)¶

Overloaded function.

is_normalized(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> bool
is_normalized(self: pyrosetta.rosetta.numeric.Quaternion_double_t, tol: float) -> bool

C++: numeric::Quaternion<double>::is_normalized(const double &) const –> bool

left_multiply_by(*args, **kwargs)¶

Overloaded function.

left_multiply_by(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t
left_multiply_by(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t, precise: bool) -> pyrosetta.rosetta.numeric.Quaternion_double_t

C++: numeric::Quaternion<double>::left_multiply_by(const class numeric::Quaternion<double> &, const bool) –> class numeric::Quaternion<double> &

left_multiply_by_inverse_of(*args, **kwargs)¶

Overloaded function.

left_multiply_by_inverse_of(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t
left_multiply_by_inverse_of(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t, precise: bool) -> pyrosetta.rosetta.numeric.Quaternion_double_t

C++: numeric::Quaternion<double>::left_multiply_by_inverse_of(const class numeric::Quaternion<double> &, const bool) –> class numeric::Quaternion<double> &

magnitude(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::magnitude() const –> double

magnitude_error(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::magnitude_error() const –> double

magnitude_squared(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::magnitude_squared() const –> double

magnitude_squared_error(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::magnitude_squared_error() const –> double

norm(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::norm() const –> double

norm_error(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::norm_error() const –> double

norm_squared(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::norm_squared() const –> double

norm_squared_error(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::norm_squared_error() const –> double

normalize(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::normalize() –> class numeric::Quaternion<double> &

normalize_if_needed(*args, **kwargs)¶

Overloaded function.

normalize_if_needed(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t
normalize_if_needed(self: pyrosetta.rosetta.numeric.Quaternion_double_t, tol: float) -> pyrosetta.rosetta.numeric.Quaternion_double_t

C++: numeric::Quaternion<double>::normalize_if_needed(const double &) –> class numeric::Quaternion<double> &

not_normalized(*args, **kwargs)¶

Overloaded function.

not_normalized(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> bool
not_normalized(self: pyrosetta.rosetta.numeric.Quaternion_double_t, tol: float) -> bool

C++: numeric::Quaternion<double>::not_normalized(const double &) const –> bool

right_multiply_by(*args, **kwargs)¶

Overloaded function.

right_multiply_by(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t
right_multiply_by(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t, precise: bool) -> pyrosetta.rosetta.numeric.Quaternion_double_t

C++: numeric::Quaternion<double>::right_multiply_by(const class numeric::Quaternion<double> &, const bool) –> class numeric::Quaternion<double> &

right_multiply_by_inverse_of(*args, **kwargs)¶

Overloaded function.

right_multiply_by_inverse_of(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t
right_multiply_by_inverse_of(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t, precise: bool) -> pyrosetta.rosetta.numeric.Quaternion_double_t

C++: numeric::Quaternion<double>::right_multiply_by_inverse_of(const class numeric::Quaternion<double> &, const bool) –> class numeric::Quaternion<double> &

swap(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) → None¶: C++: numeric::Quaternion<double>::swap(class numeric::Quaternion<double> &) –> void

to_identity(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → pyrosetta.rosetta.numeric.Quaternion_double_t¶: C++: numeric::Quaternion<double>::to_identity() –> class numeric::Quaternion<double> &

to_string(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → str¶: C++: numeric::Quaternion<double>::to_string() const –> std::string

w(*args, **kwargs)¶

Overloaded function.

w(self: pyrosetta.rosetta.numeric.Quaternion_double_t, newval: float) -> None

C++: numeric::Quaternion<double>::w(double) –> void

w(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> float

C++: numeric::Quaternion<double>::w() const –> const double &

w_squared(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::w_squared() const –> double

x(*args, **kwargs)¶

Overloaded function.

x(self: pyrosetta.rosetta.numeric.Quaternion_double_t, newval: float) -> None

C++: numeric::Quaternion<double>::x(double) –> void

x(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> float

C++: numeric::Quaternion<double>::x() const –> const double &

x_squared(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::x_squared() const –> double

y(*args, **kwargs)¶

Overloaded function.

y(self: pyrosetta.rosetta.numeric.Quaternion_double_t, newval: float) -> None

C++: numeric::Quaternion<double>::y(double) –> void

y(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> float

C++: numeric::Quaternion<double>::y() const –> const double &

y_squared(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::y_squared() const –> double

z(*args, **kwargs)¶

Overloaded function.

z(self: pyrosetta.rosetta.numeric.Quaternion_double_t, newval: float) -> None

C++: numeric::Quaternion<double>::z(double) –> void

z(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> float

C++: numeric::Quaternion<double>::z() const –> const double &

z_squared(self: pyrosetta.rosetta.numeric.Quaternion_double_t) → float¶: C++: numeric::Quaternion<double>::z_squared() const –> double

class pyrosetta.rosetta.numeric.RemainderSelector_double_false_t¶

Bases: pybind11_object

static remainder(x: float, y: float) → float¶: C++: numeric::RemainderSelector<double, false>::remainder(const double &, const double &) –> double

class pyrosetta.rosetta.numeric.RemainderSelector_int_true_t¶

Bases: pybind11_object

static remainder(x: int, y: int) → int¶: C++: numeric::RemainderSelector<int, true>::remainder(const int &, const int &) –> int

class pyrosetta.rosetta.numeric.RocCurve¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.RocCurve, : pyrosetta.rosetta.numeric.RocCurve) → pyrosetta.rosetta.numeric.RocCurve¶: C++: numeric::RocCurve::operator=(const class numeric::RocCurve &) –> class numeric::RocCurve &

calculate_auc(self: pyrosetta.rosetta.numeric.RocCurve) → float¶: C++: numeric::RocCurve::calculate_auc() –> double

generate_roc_curve(self: pyrosetta.rosetta.numeric.RocCurve) → None¶: C++: numeric::RocCurve::generate_roc_curve() –> void

insert_point(*args, **kwargs)¶

Overloaded function.

insert_point(self: pyrosetta.rosetta.numeric.RocCurve, roc_point: pyrosetta.rosetta.numeric.RocPoint) -> None

C++: numeric::RocCurve::insert_point(const class numeric::RocPoint &) –> void

insert_point(self: pyrosetta.rosetta.numeric.RocCurve, predicted: bool, actual: bool, tag: str, score: float) -> None

C++: numeric::RocCurve::insert_point(bool, bool, const std::string &, const double &) –> void

print_roc_curve(self: pyrosetta.rosetta.numeric.RocCurve) → None¶: C++: numeric::RocCurve::print_roc_curve() –> void

roc_curve(self: pyrosetta.rosetta.numeric.RocCurve) → pyrosetta.rosetta.utility.vector1_std_pair_double_double_t¶: C++: numeric::RocCurve::roc_curve() –> class utility::vector1<struct std::pair<double, double>, class std::allocator<struct std::pair<double, double> > >

class pyrosetta.rosetta.numeric.RocPoint¶

Bases: pybind11_object

assign(self: pyrosetta.rosetta.numeric.RocPoint, : pyrosetta.rosetta.numeric.RocPoint) → pyrosetta.rosetta.numeric.RocPoint¶: C++: numeric::RocPoint::operator=(const class numeric::RocPoint &) –> class numeric::RocPoint &

score(*args, **kwargs)¶

Overloaded function.

score(self: pyrosetta.rosetta.numeric.RocPoint) -> float

C++: numeric::RocPoint::score() const –> double

score(self: pyrosetta.rosetta.numeric.RocPoint, score: float) -> None

C++: numeric::RocPoint::score(const double &) –> void

status(*args, **kwargs)¶

Overloaded function.

status(self: pyrosetta.rosetta.numeric.RocPoint) -> pyrosetta.rosetta.numeric.RocStatus

C++: numeric::RocPoint::status() const –> enum numeric::RocStatus

status(self: pyrosetta.rosetta.numeric.RocPoint, status: pyrosetta.rosetta.numeric.RocStatus) -> None

C++: numeric::RocPoint::status(const enum numeric::RocStatus &) –> void

tag(*args, **kwargs)¶

Overloaded function.

tag(self: pyrosetta.rosetta.numeric.RocPoint) -> str

C++: numeric::RocPoint::tag() const –> std::string

tag(self: pyrosetta.rosetta.numeric.RocPoint, tag: str) -> None

C++: numeric::RocPoint::tag(const std::string &) –> void

class pyrosetta.rosetta.numeric.RocStatus¶

Bases: pybind11_object

Members:

true_positive

true_negative

false_positive

false_negative

false_negative = <RocStatus.false_negative: 3>¶

false_positive = <RocStatus.false_positive: 2>¶

property name¶

true_negative = <RocStatus.true_negative: 1>¶

true_positive = <RocStatus.true_positive: 0>¶

property value¶

class pyrosetta.rosetta.numeric.SingleLinkClusterer¶

Bases: AgglomerativeHierarchicalClusterer

assign(self: pyrosetta.rosetta.numeric.SingleLinkClusterer, : pyrosetta.rosetta.numeric.SingleLinkClusterer) → pyrosetta.rosetta.numeric.SingleLinkClusterer¶: C++: numeric::SingleLinkClusterer::operator=(const class numeric::SingleLinkClusterer &) –> class numeric::SingleLinkClusterer &

comparator(self: pyrosetta.rosetta.numeric.SingleLinkClusterer, distance_matrix: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, members1: pyrosetta.rosetta.utility.vector1_unsigned_long, members2: pyrosetta.rosetta.utility.vector1_unsigned_long, co: pyrosetta.rosetta.numeric.ClusterOptions) → None¶: C++: numeric::SingleLinkClusterer::comparator(class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &, class numeric::ClusterOptions &) –> void

class pyrosetta.rosetta.numeric.SplineParameters¶

Bases: pybind11_object

%SplineParameters is a simple struct for holding the cubic spline polynomials used in the etable to interpolate the lennard-jones attractive and LK-solvation terms to zero smoothly. These splines have exactly two knots to represent them, and the same x values are used for all the knots: thus the only parameters needed are the y values at the knots, and the second-derivatives for the polynomials at knots.

property y2hi¶

property y2lo¶

property yhi¶

property ylo¶

class pyrosetta.rosetta.numeric.UniformRotationSampler¶

Bases: pybind11_object

generateIcosahedralSamples(self: pyrosetta.rosetta.numeric.UniformRotationSampler, ico: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t, nsub: int) → None¶: C++: numeric::UniformRotationSampler::generateIcosahedralSamples(class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, unsigned long) –> void

get(self: pyrosetta.rosetta.numeric.UniformRotationSampler, ii: int, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None¶: C++: numeric::UniformRotationSampler::get(unsigned long, class numeric::xyzMatrix<double> &) const –> void

nrots(self: pyrosetta.rosetta.numeric.UniformRotationSampler) → int¶: C++: numeric::UniformRotationSampler::nrots() const –> unsigned long

remove_redundant(self: pyrosetta.rosetta.numeric.UniformRotationSampler, R0: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None¶: C++: numeric::UniformRotationSampler::remove_redundant(class numeric::xyzMatrix<double>) –> void

class pyrosetta.rosetta.numeric.XformHash32¶: Bases: pybind11_object

class pyrosetta.rosetta.numeric.XformHash64¶: Bases: pybind11_object

class pyrosetta.rosetta.numeric.Xforms¶

Bases: vector1_numeric_xyzTransform_double_t

append(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t, arg0: numeric::xyzTransform<double>) → None¶: adds an element to the end

assign(self: pyrosetta.rosetta.numeric.Xforms, : pyrosetta.rosetta.numeric.Xforms) → pyrosetta.rosetta.numeric.Xforms¶: C++: numeric::Xforms::operator=(const struct numeric::Xforms &) –> struct numeric::Xforms &

back(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) → numeric::xyzTransform<double>¶: access the last element

capacity(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) → int¶: returns the number of elements that can be held in currently allocated storage

clear(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) → None¶: clears the contents

count(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t, arg0: numeric::xyzTransform<double>) → int¶: counts the elements that are equal to value

erase(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t, arg0: int) → None¶: erases element at index

extend(othervec)¶

front(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) → numeric::xyzTransform<double>¶: access the first element

l(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) → int¶: lower index

max_size(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) → int¶: returns the maximum possible number of elements

pop(*args, **kwargs)¶

Overloaded function.

pop(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) -> numeric::xyzTransform<double>

remove and return last item

pop(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t, arg0: int) -> numeric::xyzTransform<double>

remove and return item at index

remove(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t, arg0: numeric::xyzTransform<double>) → None¶: Remove the first item from the list whose value is x. It is an error if there is no such item.

reserve(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t, arg0: int) → None¶: reserves storage

resize(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t, arg0: int) → None¶: changes the number of elements stored

shrink_to_fit(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) → None¶: reduces memory usage by freeing unused memory

u(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) → int¶: upper index

pyrosetta.rosetta.numeric._rotation_axis_angle_instantiation_for_PyRosetta() → None¶: C++: numeric::_rotation_axis_angle_instantiation_for_PyRosetta() –> void

pyrosetta.rosetta.numeric.access_Real_MathNTensor(tensorbase: pyrosetta.rosetta.numeric.MathNTensorBase_double_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) → float¶

Utility function to access an entry in a MathNTensor of arbitrary dimensionality unknown at compile time, given a MathNTensorBaseOP.

Vikram K. Mulligan (vmullig.edu).

C++: numeric::access_Real_MathNTensor(class std::shared_ptr<class numeric::MathNTensorBase<double> >, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> double &

pyrosetta.rosetta.numeric.angle_degrees(*args, **kwargs)¶

Overloaded function.

angle_degrees(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::angle_degrees(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

angle_degrees(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::angle_degrees(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.angle_degrees_double(*args, **kwargs)¶

Overloaded function.

angle_degrees_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::angle_degrees_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

angle_degrees_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::angle_degrees_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.angle_radians(*args, **kwargs)¶

Overloaded function.

angle_radians(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::angle_radians(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) –> void

angle_radians(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::angle_radians(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

angle_radians(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::angle_radians(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.angle_radians_double(*args, **kwargs)¶

Overloaded function.

angle_radians_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::angle_radians_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

angle_radians_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::angle_radians_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.boltzmann_accept_probability(score_before: float, score_after: float, temperature: float) → float¶

Calculates the acceptance probability of a given score-change at: the given temperature, generally used in simulated annealing algorithms. Returns a value in the range (0-1).

C++: numeric::boltzmann_accept_probability(const double, const double, const double) –> double

pyrosetta.rosetta.numeric.calc_zscore(*args, **kwargs)¶

Overloaded function.

calc_zscore(input_v: pyrosetta.rosetta.std.map_unsigned_long_double, zscore_v: pyrosetta.rosetta.std.map_unsigned_long_double) -> None
calc_zscore(input_v: pyrosetta.rosetta.std.map_unsigned_long_double, zscore_v: pyrosetta.rosetta.std.map_unsigned_long_double, negating: bool) -> None

Calculate a Z-score from a set of data.: Real i_zscore = (input_v[i]-mean)/stdev;

Ray Wang (wangyr.edu) Negating flips the zscore (i_zscore = -1*i_zscore)

C++: numeric::calc_zscore(const class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &, class std::map<unsigned long, double, struct std::less<unsigned long>, class std::allocator<struct std::pair<const unsigned long, double> > > &, bool) –> void

pyrosetta.rosetta.numeric.ccd_angle(F: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t, M: pyrosetta.rosetta.utility.vector1_numeric_xyzVector_double_t, axis_atom: pyrosetta.rosetta.numeric.xyzVector_double_t, theta_hat: pyrosetta.rosetta.numeric.xyzVector_double_t, alpha: float, S: float) → None¶: C++: numeric::ccd_angle(const class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class utility::vector1<class numeric::xyzVector<double>, class std::allocator<class numeric::xyzVector<double> > > &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &, double &) –> void

pyrosetta.rosetta.numeric.const_access_Real_MathNTensor(tensorbase: pyrosetta.rosetta.numeric.MathNTensorBase_double_t, position: pyrosetta.rosetta.utility.vector1_unsigned_long) → float¶

Utility function to get const access to an entry in a MathNTensor of arbitrary dimensionality unknown at compile time, given a MathNTensorBaseCOP.

Vikram K. Mulligan (vmullig.edu).

C++: numeric::const_access_Real_MathNTensor(class std::shared_ptr<const class numeric::MathNTensorBase<double> >, const class utility::vector1<unsigned long, class std::allocator<unsigned long> > &) –> const double &

pyrosetta.rosetta.numeric.cross(a: pyrosetta.rosetta.numeric.xyzVector_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::cross(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.numeric.cube(x: float) → float¶: C++: numeric::cube(const double &) –> double

pyrosetta.rosetta.numeric.cubic_polynomial_deriv(x: float, cp: pyrosetta.rosetta.numeric.CubicPolynomial) → float¶

Evaluate derivative of cubic polynomial given x and polynomial coefficients

C++: numeric::cubic_polynomial_deriv(const double, const struct numeric::CubicPolynomial &) –> double

pyrosetta.rosetta.numeric.cubic_polynomial_from_spline(xlo: float, xhi: float, sp: pyrosetta.rosetta.numeric.SplineParameters) → pyrosetta.rosetta.numeric.CubicPolynomial¶

Compute cubic polynomial coefficients from a set of SplineParameters

C++: numeric::cubic_polynomial_from_spline(double, double, const struct numeric::SplineParameters &) –> struct numeric::CubicPolynomial

pyrosetta.rosetta.numeric.deep_copy(source: pyrosetta.rosetta.numeric.MathNTensorBase_double_t) → pyrosetta.rosetta.numeric.MathNTensorBase_double_t¶: C++: numeric::deep_copy(const class numeric::MathNTensorBase<double> &) –> class std::shared_ptr<class numeric::MathNTensorBase<double> >

pyrosetta.rosetta.numeric.dihedral(*args, **kwargs)¶

Overloaded function.

dihedral(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::dihedral(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) –> void

dihedral(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::dihedral(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.dihedral_degrees(*args, **kwargs)¶

Overloaded function.

dihedral_degrees(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::dihedral_degrees(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) –> void

dihedral_degrees(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::dihedral_degrees(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.dihedral_degrees_double(*args, **kwargs)¶

Overloaded function.

dihedral_degrees_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::dihedral_degrees_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) –> void

dihedral_degrees_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::dihedral_degrees_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.dihedral_double(*args, **kwargs)¶

Overloaded function.

dihedral_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::dihedral_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) –> void

dihedral_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::dihedral_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.dihedral_radians(*args, **kwargs)¶

Overloaded function.

dihedral_radians(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::dihedral_radians(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) –> void

dihedral_radians(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::dihedral_radians(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.dihedral_radians_double(*args, **kwargs)¶

Overloaded function.

dihedral_radians_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::dihedral_radians_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, double &) –> void

dihedral_radians_double(p1: pyrosetta.rosetta.numeric.xyzVector_double_t, p2: pyrosetta.rosetta.numeric.xyzVector_double_t, p3: pyrosetta.rosetta.numeric.xyzVector_double_t, p4: pyrosetta.rosetta.numeric.xyzVector_double_t) -> float

C++: numeric::dihedral_radians_double(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.dot(a: pyrosetta.rosetta.numeric.xyzVector_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::dot(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> double

pyrosetta.rosetta.numeric.eigenvalue_jacobi(*args, **kwargs)¶

Overloaded function.

eigenvalue_jacobi(a: pyrosetta.rosetta.numeric.xyzMatrix_float_t, tol: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::eigenvalue_jacobi(const class numeric::xyzMatrix<float> &, const float &) –> class numeric::xyzVector<float>

eigenvalue_jacobi(a: pyrosetta.rosetta.numeric.xyzMatrix_double_t, tol: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::eigenvalue_jacobi(const class numeric::xyzMatrix<double> &, const double &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.numeric.eigenvector_jacobi(*args, **kwargs)¶

Overloaded function.

eigenvector_jacobi(a: pyrosetta.rosetta.numeric.xyzMatrix_float_t, tol: float, J: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::eigenvector_jacobi(const class numeric::xyzMatrix<float> &, const float &, class numeric::xyzMatrix<float> &) –> class numeric::xyzVector<float>

eigenvector_jacobi(a: pyrosetta.rosetta.numeric.xyzMatrix_double_t, tol: float, J: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::eigenvector_jacobi(const class numeric::xyzMatrix<double> &, const double &, class numeric::xyzMatrix<double> &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.numeric.equal_by_epsilon(value1: float, value2: float, epsilon: float) → bool¶

are two Real values are equal up to some epsilon

implemented only for Reals, to prevent unsigned hassle (Barak 30/6/2009)

C++: numeric::equal_by_epsilon(double, double, double) –> bool

pyrosetta.rosetta.numeric.eval_cubic_polynomial(x: float, cp: pyrosetta.rosetta.numeric.CubicPolynomial) → float¶

Evaluate cubic polynomial at value x given polynomial coefficients

C++: numeric::eval_cubic_polynomial(const double, const struct numeric::CubicPolynomial &) –> double

pyrosetta.rosetta.numeric.get_Real_MathNTensor_dimension_size(tensorbase: pyrosetta.rosetta.numeric.MathNTensorBase_double_t, dimension_index: int) → int¶

Given a MathNTensorBaseCOP, get the size along one dimension.

Vikram K. Mulligan (vmullig.edu).

C++: numeric::get_Real_MathNTensor_dimension_size(class std::shared_ptr<const class numeric::MathNTensorBase<double> >, const unsigned long) –> unsigned long

pyrosetta.rosetta.numeric.hsv_to_rgb(*args, **kwargs)¶

Overloaded function.

hsv_to_rgb(h: float, s: float, v: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

convert an HSV color to RGB

C++: numeric::hsv_to_rgb(double, double, double) –> class numeric::xyzVector<double>

hsv_to_rgb(hsv_triplet: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

convert an HSV color to RGB

C++: numeric::hsv_to_rgb(class numeric::xyzVector<double>) –> class numeric::xyzVector<double>

pyrosetta.rosetta.numeric.inplace_product(*args, **kwargs)¶

Overloaded function.

inplace_product(m: numeric::xyzMatrix<float>, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::inplace_product(const class numeric::xyzMatrix<float> &, class numeric::xyzVector<float> &) –> class numeric::xyzVector<float> &

inplace_product(m: numeric::xyzMatrix<double>, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::inplace_product(const class numeric::xyzMatrix<double> &, class numeric::xyzVector<double> &) –> class numeric::xyzVector<double> &

pyrosetta.rosetta.numeric.inplace_transpose_product(*args, **kwargs)¶

Overloaded function.

inplace_transpose_product(m: numeric::xyzMatrix<float>, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::inplace_transpose_product(const class numeric::xyzMatrix<float> &, class numeric::xyzVector<float> &) –> class numeric::xyzVector<float> &

inplace_transpose_product(m: numeric::xyzMatrix<double>, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::inplace_transpose_product(const class numeric::xyzMatrix<double> &, class numeric::xyzVector<double> &) –> class numeric::xyzVector<double> &

pyrosetta.rosetta.numeric.inverse(*args, **kwargs)¶

Overloaded function.

inverse(a: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::inverse(const class numeric::xyzMatrix<float> &) –> class numeric::xyzMatrix<float>

inverse(a: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::inverse(const class numeric::xyzMatrix<double> &) –> class numeric::xyzMatrix<double>

pyrosetta.rosetta.numeric.log(x: float, base: float) → float¶

Computes log(x) in the given base

C++: numeric::log(double, double) –> double

pyrosetta.rosetta.numeric.max(*args, **kwargs)¶

Overloaded function.

max(a: int, b: int) -> int

max( short int, short int )

C++: numeric::max(const short, const short) –> short

max(a: int, b: int) -> int

max( int, int )

C++: numeric::max(const int, const int) –> int

max(a: int, b: int) -> int

max( long int, long int )

C++: numeric::max(const long, const long) –> long

max(a: int, b: int) -> int

max( unsigned short int, unsigned short int )

C++: numeric::max(const unsigned short, const unsigned short) –> unsigned short

max(a: int, b: int) -> int

max( unsigned int, unsigned int )

C++: numeric::max(const unsigned int, const unsigned int) –> unsigned int

max(a: int, b: int) -> int

max( unsigned long int, unsigned long int )

C++: numeric::max(const unsigned long, const unsigned long) –> unsigned long

max(a: float, b: float) -> float

max( float, float )

C++: numeric::max(const float, const float) –> float

max(a: float, b: float) -> float

max( double, double )

C++: numeric::max(const double, const double) –> double

max(a: float, b: float) -> float

max( long double, long double )

C++: numeric::max(const long double, const long double) –> long double

pyrosetta.rosetta.numeric.mean(values: pyrosetta.rosetta.utility.vector1_double) → float¶: C++: numeric::mean(const class utility::vector1<double, class std::allocator<double> > &) –> double

pyrosetta.rosetta.numeric.median(values: pyrosetta.rosetta.utility.vector1_double) → float¶

Returns the median from a vector1 of Real values.

C++: numeric::median(const class utility::vector1<double, class std::allocator<double> > &) –> double

pyrosetta.rosetta.numeric.min(*args, **kwargs)¶

Overloaded function.

min(a: int, b: int) -> int

min( short int, short int )

C++: numeric::min(const short, const short) –> short

min(a: int, b: int) -> int

min( int, int )

C++: numeric::min(const int, const int) –> int

min(a: int, b: int) -> int

min( long int, long int )

C++: numeric::min(const long, const long) –> long

min(a: int, b: int) -> int

min( unsigned short int, unsigned short int )

C++: numeric::min(const unsigned short, const unsigned short) –> unsigned short

min(a: int, b: int) -> int

min( unsigned int, unsigned int )

C++: numeric::min(const unsigned int, const unsigned int) –> unsigned int

min(a: int, b: int) -> int

min( unsigned long int, unsigned long int )

C++: numeric::min(const unsigned long, const unsigned long) –> unsigned long

min(a: float, b: float) -> float

min( float, float )

C++: numeric::min(const float, const float) –> float

min(a: float, b: float) -> float

min( double, double )

C++: numeric::min(const double, const double) –> double

min(a: float, b: float) -> float

min( long double, long double )

C++: numeric::min(const long double, const long double) –> long double

pyrosetta.rosetta.numeric.mod(*args, **kwargs)¶

Overloaded function.

mod(x: int, y: int) -> int

C++: numeric::mod(const long &, const long &) –> long

mod(x: int, y: int) -> int

C++: numeric::mod(const unsigned long &, const unsigned long &) –> unsigned long

pyrosetta.rosetta.numeric.modulo(*args, **kwargs)¶

Overloaded function.

modulo(x: int, y: int) -> int

C++: numeric::modulo(const long &, const long &) –> long

modulo(x: float, y: float) -> float

C++: numeric::modulo(const double &, const double &) –> double

modulo(x: int, y: int) -> int

C++: numeric::modulo(const int &, const int &) –> int

pyrosetta.rosetta.numeric.nearest_ssize(*args, **kwargs)¶

Overloaded function.

nearest_ssize(x: float) -> int

C++: numeric::nearest_ssize(const long double &) –> long

nearest_ssize(x: float) -> int

C++: numeric::nearest_ssize(const double &) –> long

pyrosetta.rosetta.numeric.nonnegative_principal_angle_degrees(*args, **kwargs)¶

Overloaded function.

nonnegative_principal_angle_degrees(angle: float) -> float

C++: numeric::nonnegative_principal_angle_degrees(const double &) –> double

nonnegative_principal_angle_degrees(angle: int) -> int

C++: numeric::nonnegative_principal_angle_degrees(const int &) –> int

pyrosetta.rosetta.numeric.outer_product(*args, **kwargs)¶

Overloaded function.

outer_product(a: pyrosetta.rosetta.numeric.xyzVector_float_t, b: pyrosetta.rosetta.numeric.xyzVector_float_t) -> numeric::xyzMatrix<float>

C++: numeric::outer_product(const class numeric::xyzVector<float> &, const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float>

outer_product(a: pyrosetta.rosetta.numeric.xyzVector_double_t, b: pyrosetta.rosetta.numeric.xyzVector_double_t) -> numeric::xyzMatrix<double>

C++: numeric::outer_product(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double>

pyrosetta.rosetta.numeric.principal_angle_degrees(*args, **kwargs)¶

Overloaded function.

principal_angle_degrees(angle: float) -> float

C++: numeric::principal_angle_degrees(const double &) –> double

principal_angle_degrees(angle: int) -> int

C++: numeric::principal_angle_degrees(const int &) –> int

pyrosetta.rosetta.numeric.principal_components_and_eigenvalues_ndimensions(coords: pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, shift_center: bool) → Tuple[pyrosetta.rosetta.utility.vector1_utility_vector1_double_std_allocator_double_t, pyrosetta.rosetta.utility.vector1_double]¶

Return a pair containing a matrix (vector of vectors) of all of the

principal components and a vector of the corresponding eigenvalues of the given set of points in n-dimensional space.

Note that this does not assume that the input vectors are 3-dimensional. If shift_center=false, the mean vector is not subtracted by this function. (Failure to subtract mean vector prior to function call will produce odd results, however.)

Vikram K. Mulligan (vmullig.edu)

C++: numeric::principal_components_and_eigenvalues_ndimensions(const class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > > &, const bool) –> struct std::pair<class utility::vector1<class utility::vector1<double, class std::allocator<double> >, class std::allocator<class utility::vector1<double, class std::allocator<double> > > >, class utility::vector1<double, class std::allocator<double> > >

pyrosetta.rosetta.numeric.print_probabilities(probs: pyrosetta.rosetta.utility.vector1_double, out: pyrosetta.rosetta.std.ostream) → None¶

Writes probs to the specified ostream

C++: numeric::print_probabilities(const class utility::vector1<double, class std::allocator<double> > &, std::ostream &) –> void

pyrosetta.rosetta.numeric.product(*args, **kwargs)¶

Overloaded function.

product(m: numeric::xyzMatrix<float>, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::product(const class numeric::xyzMatrix<float> &, const class numeric::xyzVector<float> &) –> class numeric::xyzVector<float>

product(m: numeric::xyzMatrix<double>, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::product(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.numeric.projection_matrix(*args, **kwargs)¶

Overloaded function.

projection_matrix(v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> numeric::xyzMatrix<float>

C++: numeric::projection_matrix(const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float>

projection_matrix(v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> numeric::xyzMatrix<double>

C++: numeric::projection_matrix(const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double>

pyrosetta.rosetta.numeric.quat2R(Q: pyrosetta.rosetta.numeric.Quaternion_double_t, R: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → None¶: C++: numeric::quat2R(const class numeric::Quaternion<double> &, class numeric::xyzMatrix<double> &) –> void

pyrosetta.rosetta.numeric.read_probabilities_or_die(filename: str, probs: pyrosetta.rosetta.utility.vector1_double) → None¶

Loads normalized, per-residue probabilities from filename,: storing the result in probs. Assumes line i holds the probability of sampling residue i. There must be 1 line for each residue in the pose on which this data will be used.

C++: numeric::read_probabilities_or_die(const std::string &, class utility::vector1<double, class std::allocator<double> > *) –> void

pyrosetta.rosetta.numeric.remainder(*args, **kwargs)¶

Overloaded function.

remainder(x: float, y: float) -> float

C++: numeric::remainder(const double &, const double &) –> double

remainder(x: int, y: int) -> int

C++: numeric::remainder(const int &, const int &) –> int

pyrosetta.rosetta.numeric.rgb_to_hsv(*args, **kwargs)¶

Overloaded function.

rgb_to_hsv(r: float, b: float, g: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

convert an RGB color to HSV

C++: numeric::rgb_to_hsv(double, double, double) –> class numeric::xyzVector<double>

rgb_to_hsv(rgb_triplet: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

convert and RGB color to HSV

C++: numeric::rgb_to_hsv(class numeric::xyzVector<double>) –> class numeric::xyzVector<double>

pyrosetta.rosetta.numeric.rotation_axis(*args, **kwargs)¶

Overloaded function.

rotation_axis(R: pyrosetta.rosetta.numeric.xyzMatrix_float_t, theta: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::rotation_axis(const class numeric::xyzMatrix<float> &, float &) –> class numeric::xyzVector<float>

rotation_axis(R: pyrosetta.rosetta.numeric.xyzMatrix_double_t, theta: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::rotation_axis(const class numeric::xyzMatrix<double> &, double &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.numeric.rotation_axis_angle(R: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::rotation_axis_angle(const class numeric::xyzMatrix<double> &) –> class numeric::xyzVector<double>

pyrosetta.rosetta.numeric.rotation_matrix(*args, **kwargs)¶

Overloaded function.

rotation_matrix(axis: pyrosetta.rosetta.numeric.xyzVector_float_t, theta: float) -> numeric::xyzMatrix<float>

C++: numeric::rotation_matrix(const class numeric::xyzVector<float> &, const float &) –> class numeric::xyzMatrix<float>

rotation_matrix(axis: pyrosetta.rosetta.numeric.xyzVector_double_t, theta: float) -> numeric::xyzMatrix<double>

C++: numeric::rotation_matrix(const class numeric::xyzVector<double> &, const double &) –> class numeric::xyzMatrix<double>

pyrosetta.rosetta.numeric.sign(*args, **kwargs)¶

Overloaded function.

sign(x: float) -> int

C++: numeric::sign(const double &) –> int

sign(x: float) -> int

C++: numeric::sign(const long double &) –> int

pyrosetta.rosetta.numeric.sin_cos_range(*args, **kwargs)¶

Overloaded function.

sin_cos_range(x: float) -> float
sin_cos_range(x: float, tol: float) -> float

C++: numeric::sin_cos_range(const double &, const double &) –> double

pyrosetta.rosetta.numeric.transpose_product(*args, **kwargs)¶

Overloaded function.

transpose_product(m: numeric::xyzMatrix<float>, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::transpose_product(const class numeric::xyzMatrix<float> &, const class numeric::xyzVector<float> &) –> class numeric::xyzVector<float>

transpose_product(m: numeric::xyzMatrix<double>, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::transpose_product(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double>

class pyrosetta.rosetta.numeric.urs_Quat¶

Bases: pybind11_object

asR(self: pyrosetta.rosetta.numeric.urs_Quat) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::urs_Quat::asR() const –> class numeric::xyzMatrix<double>

assign(self: pyrosetta.rosetta.numeric.urs_Quat, : pyrosetta.rosetta.numeric.urs_Quat) → pyrosetta.rosetta.numeric.urs_Quat¶: C++: numeric::urs_Quat::operator=(const struct numeric::urs_Quat &) –> struct numeric::urs_Quat &

property w_¶

property x_¶

property y_¶

property z_¶

pyrosetta.rosetta.numeric.urs_R2ang(R: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → float¶: C++: numeric::urs_R2ang(class numeric::xyzMatrix<double>) –> double

pyrosetta.rosetta.numeric.urs_norm4(a: float, b: float, c: float, d: float) → float¶: C++: numeric::urs_norm4(double, double, double, double) –> double

class pyrosetta.rosetta.numeric.xyzMatrix_double_t¶

Bases: pybind11_object

static I() → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::I() –> const class numeric::xyzMatrix<double> &

add_diagonal(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::add_diagonal(const double &, const double &, const double &) –> class numeric::xyzMatrix<double> &

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, m: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::operator=(const class numeric::xyzMatrix<double> &) –> class numeric::xyzMatrix<double> &

assign(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, m: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::operator=(const class numeric::xyzMatrix<double> &) –> class numeric::xyzMatrix<double> &

assign(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, t: float) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::operator=(const double &) –> class numeric::xyzMatrix<double> &

clear(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::clear() –> class numeric::xyzMatrix<double> &

col(*args, **kwargs)¶

Overloaded function.

col(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, i: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzMatrix<double>::col(const int) const –> class numeric::xyzVector<double>

col(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, i: int, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::col(const int, const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double> &

col_x(*args, **kwargs)¶

Overloaded function.

col_x(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzMatrix<double>::col_x() const –> class numeric::xyzVector<double>

col_x(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::col_x(const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double> &

col_y(*args, **kwargs)¶

Overloaded function.

col_y(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzMatrix<double>::col_y() const –> class numeric::xyzVector<double>

col_y(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::col_y(const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double> &

col_z(*args, **kwargs)¶

Overloaded function.

col_z(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzMatrix<double>::col_z() const –> class numeric::xyzVector<double>

col_z(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::col_z(const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double> &

static cols(xx_a: float, yx_a: float, zx_a: float, xy_a: float, yy_a: float, zy_a: float, xz_a: float, yz_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::cols(const double &, const double &, const double &, const double &, const double &, const double &, const double &, const double &, const double &) –> class numeric::xyzMatrix<double>

det(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → float¶: C++: numeric::xyzMatrix<double>::det() const –> double

static diag(xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::diag(const double &, const double &, const double &) –> class numeric::xyzMatrix<double>

static identity() → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::identity() –> class numeric::xyzMatrix<double>

inverse(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::inverse() const –> class numeric::xyzMatrix<double>

is_finite(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → bool¶: C++: numeric::xyzMatrix<double>::is_finite() const –> bool

is_identity(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → bool¶: C++: numeric::xyzMatrix<double>::is_identity() const –> bool

is_zero(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → bool¶: C++: numeric::xyzMatrix<double>::is_zero() const –> bool

row(*args, **kwargs)¶

Overloaded function.

row(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, i: int) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzMatrix<double>::row(const int) const –> class numeric::xyzVector<double>

row(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, i: int, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::row(const int, const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double> &

row_x(*args, **kwargs)¶

Overloaded function.

row_x(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzMatrix<double>::row_x() const –> class numeric::xyzVector<double>

row_x(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::row_x(const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double> &

row_y(*args, **kwargs)¶

Overloaded function.

row_y(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzMatrix<double>::row_y() const –> class numeric::xyzVector<double>

row_y(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::row_y(const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double> &

row_z(*args, **kwargs)¶

Overloaded function.

row_z(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzMatrix<double>::row_z() const –> class numeric::xyzVector<double>

row_z(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzMatrix_double_t

C++: numeric::xyzMatrix<double>::row_z(const class numeric::xyzVector<double> &) –> class numeric::xyzMatrix<double> &

static rows(xx_a: float, xy_a: float, xz_a: float, yx_a: float, yy_a: float, yz_a: float, zx_a: float, zy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::rows(const double &, const double &, const double &, const double &, const double &, const double &, const double &, const double &, const double &) –> class numeric::xyzMatrix<double>

set_diagonal(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::set_diagonal(const double &, const double &, const double &) –> class numeric::xyzMatrix<double> &

subtract_diagonal(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::subtract_diagonal(const double &, const double &, const double &) –> class numeric::xyzMatrix<double> &

to_diag(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t, xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::to_diag(const double &, const double &, const double &) –> class numeric::xyzMatrix<double> &

to_identity(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::to_identity() –> class numeric::xyzMatrix<double> &

trace(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → float¶: C++: numeric::xyzMatrix<double>::trace() const –> double

transpose(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::transpose() –> class numeric::xyzMatrix<double> &

transposed(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::transposed() const –> class numeric::xyzMatrix<double>

property xx¶

property xy¶

property xz¶

property yx¶

property yy¶

property yz¶

zero(self: pyrosetta.rosetta.numeric.xyzMatrix_double_t) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::xyzMatrix<double>::zero() –> class numeric::xyzMatrix<double> &

property zx¶

property zy¶

property zz¶

class pyrosetta.rosetta.numeric.xyzMatrix_float_t¶

Bases: pybind11_object

static I() → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::I() –> const class numeric::xyzMatrix<float> &

add_diagonal(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::add_diagonal(const float &, const float &, const float &) –> class numeric::xyzMatrix<float> &

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, m: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::operator=(const class numeric::xyzMatrix<float> &) –> class numeric::xyzMatrix<float> &

assign(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, m: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::operator=(const class numeric::xyzMatrix<float> &) –> class numeric::xyzMatrix<float> &

assign(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, t: float) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::operator=(const float &) –> class numeric::xyzMatrix<float> &

clear(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::clear() –> class numeric::xyzMatrix<float> &

col(*args, **kwargs)¶

Overloaded function.

col(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, i: int) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzMatrix<float>::col(const int) const –> class numeric::xyzVector<float>

col(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, i: int, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::col(const int, const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float> &

col_x(*args, **kwargs)¶

Overloaded function.

col_x(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzMatrix<float>::col_x() const –> class numeric::xyzVector<float>

col_x(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::col_x(const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float> &

col_y(*args, **kwargs)¶

Overloaded function.

col_y(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzMatrix<float>::col_y() const –> class numeric::xyzVector<float>

col_y(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::col_y(const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float> &

col_z(*args, **kwargs)¶

Overloaded function.

col_z(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzMatrix<float>::col_z() const –> class numeric::xyzVector<float>

col_z(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::col_z(const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float> &

static cols(xx_a: float, yx_a: float, zx_a: float, xy_a: float, yy_a: float, zy_a: float, xz_a: float, yz_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::cols(const float &, const float &, const float &, const float &, const float &, const float &, const float &, const float &, const float &) –> class numeric::xyzMatrix<float>

det(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → float¶: C++: numeric::xyzMatrix<float>::det() const –> float

static diag(xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::diag(const float &, const float &, const float &) –> class numeric::xyzMatrix<float>

static identity() → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::identity() –> class numeric::xyzMatrix<float>

inverse(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::inverse() const –> class numeric::xyzMatrix<float>

is_finite(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → bool¶: C++: numeric::xyzMatrix<float>::is_finite() const –> bool

is_identity(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → bool¶: C++: numeric::xyzMatrix<float>::is_identity() const –> bool

is_zero(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → bool¶: C++: numeric::xyzMatrix<float>::is_zero() const –> bool

row(*args, **kwargs)¶

Overloaded function.

row(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, i: int) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzMatrix<float>::row(const int) const –> class numeric::xyzVector<float>

row(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, i: int, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::row(const int, const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float> &

row_x(*args, **kwargs)¶

Overloaded function.

row_x(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzMatrix<float>::row_x() const –> class numeric::xyzVector<float>

row_x(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::row_x(const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float> &

row_y(*args, **kwargs)¶

Overloaded function.

row_y(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzMatrix<float>::row_y() const –> class numeric::xyzVector<float>

row_y(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::row_y(const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float> &

row_z(*args, **kwargs)¶

Overloaded function.

row_z(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzMatrix<float>::row_z() const –> class numeric::xyzVector<float>

row_z(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzMatrix_float_t

C++: numeric::xyzMatrix<float>::row_z(const class numeric::xyzVector<float> &) –> class numeric::xyzMatrix<float> &

static rows(xx_a: float, xy_a: float, xz_a: float, yx_a: float, yy_a: float, yz_a: float, zx_a: float, zy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::rows(const float &, const float &, const float &, const float &, const float &, const float &, const float &, const float &, const float &) –> class numeric::xyzMatrix<float>

set_diagonal(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::set_diagonal(const float &, const float &, const float &) –> class numeric::xyzMatrix<float> &

subtract_diagonal(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::subtract_diagonal(const float &, const float &, const float &) –> class numeric::xyzMatrix<float> &

to_diag(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t, xx_a: float, yy_a: float, zz_a: float) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::to_diag(const float &, const float &, const float &) –> class numeric::xyzMatrix<float> &

to_identity(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::to_identity() –> class numeric::xyzMatrix<float> &

trace(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → float¶: C++: numeric::xyzMatrix<float>::trace() const –> float

transpose(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::transpose() –> class numeric::xyzMatrix<float> &

transposed(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::transposed() const –> class numeric::xyzMatrix<float>

property xx¶

property xy¶

property xz¶

property yx¶

property yy¶

property yz¶

zero(self: pyrosetta.rosetta.numeric.xyzMatrix_float_t) → pyrosetta.rosetta.numeric.xyzMatrix_float_t¶: C++: numeric::xyzMatrix<float>::zero() –> class numeric::xyzMatrix<float> &

property zx¶

property zy¶

property zz¶

class pyrosetta.rosetta.numeric.xyzTransform_double_t¶

Bases: pybind11_object

static BAD_RT6() → pyrosetta.rosetta.utility.fixedsizearray1_double_6_t¶: C++: numeric::xyzTransform<double>::BAD_RT6() –> class utility::fixedsizearray1<double, 6>

static BAD_XFORM() → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::BAD_XFORM() –> class numeric::xyzTransform<double>

property R¶

static align(*args, **kwargs)¶

Overloaded function.

align(to: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
align(to: pyrosetta.rosetta.numeric.xyzVector_double_t, from: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::align(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

static align_fast(*args, **kwargs)¶

Overloaded function.

align_fast(to: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
align_fast(to: pyrosetta.rosetta.numeric.xyzVector_double_t, from: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::align_fast(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

approx_lever_distance(*args, **kwargs)¶

Overloaded function.

approx_lever_distance(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, o: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> float
approx_lever_distance(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, o: pyrosetta.rosetta.numeric.xyzTransform_double_t, lever: float) -> float

C++: numeric::xyzTransform<double>::approx_lever_distance(const class numeric::xyzTransform<double> &, const double &) const –> double

assign(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, : pyrosetta.rosetta.numeric.xyzTransform_double_t) → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::operator=(const class numeric::xyzTransform<double> &) –> class numeric::xyzTransform<double> &

bad(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → bool¶: C++: numeric::xyzTransform<double>::bad() const –> bool

badfast(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → bool¶: C++: numeric::xyzTransform<double>::badfast() const –> bool

distance(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, b: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::distance(const class numeric::xyzTransform<double> &) const –> double

distance_squared(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, b: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::distance_squared(const class numeric::xyzTransform<double> &) const –> double

euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzTransform<double>::euler_angles_deg() const –> class numeric::xyzVector<double>

euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzTransform<double>::euler_angles_rad() const –> class numeric::xyzVector<double>

from_euler_angles_deg(*args, **kwargs)¶

Overloaded function.

from_euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, phi: float, psi: float, theta: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::from_euler_angles_deg(const double &, const double &, const double &) –> class numeric::xyzTransform<double> &

from_euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, euler: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::from_euler_angles_deg(const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double> &

from_euler_angles_rad(*args, **kwargs)¶

Overloaded function.

from_euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, phi: float, psi: float, theta: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::from_euler_angles_rad(const double &, const double &, const double &) –> class numeric::xyzTransform<double> &

from_euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, euler: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::from_euler_angles_rad(const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double> &

from_four_points(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, c: pyrosetta.rosetta.numeric.xyzVector_double_t, u: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t, w: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::from_four_points(const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double> &

from_quaternion(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, qw: float, qx: float, qy: float, qz: float) → None¶: C++: numeric::xyzTransform<double>::from_quaternion(const double &, const double &, const double &, const double &) –> void

hash64(*args, **kwargs)¶

Overloaded function.

hash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> int
hash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, cw: float) -> int
hash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, cw: float, aw: float) -> int

C++: numeric::xyzTransform<double>::hash64(const double &, const double &) const –> unsigned long

static identity() → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::identity() –> class numeric::xyzTransform<double>

inv_xform(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzTransform<double>::inv_xform(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

inverse(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → pyrosetta.rosetta.numeric.xyzTransform_double_t¶: C++: numeric::xyzTransform<double>::inverse() const –> class numeric::xyzTransform<double>

px(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::px() –> double &

py(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::py() –> double &

pz(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::pz() –> double &

static rot(*args, **kwargs)¶

Overloaded function.

rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_double_t, o_cen: pyrosetta.rosetta.numeric.xyzVector_double_t, cen: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rot(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_double_t, cen: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rot(const class numeric::xyzMatrix<double> &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

rot(axs: pyrosetta.rosetta.numeric.xyzVector_double_t, ang: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
rot(axs: pyrosetta.rosetta.numeric.xyzVector_double_t, ang: float, cen: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rot(const class numeric::xyzVector<double> &, const double &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

static rot_deg(*args, **kwargs)¶

Overloaded function.

rot_deg(axs: pyrosetta.rosetta.numeric.xyzVector_double_t, ang: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t
rot_deg(axs: pyrosetta.rosetta.numeric.xyzVector_double_t, ang: float, cen: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rot_deg(const class numeric::xyzVector<double> &, const double &, const class numeric::xyzVector<double> &) –> class numeric::xyzTransform<double>

rotation_angle(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::rotation_angle() const –> double

rotation_angle_degrees(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::rotation_angle_degrees() const –> double

rotation_axis(*args, **kwargs)¶

Overloaded function.

rotation_axis(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, axis: pyrosetta.rosetta.numeric.xyzVector_double_t, cen: pyrosetta.rosetta.numeric.xyzVector_double_t, angle: float) -> None

C++: numeric::xyzTransform<double>::rotation_axis(class numeric::xyzVector<double> &, class numeric::xyzVector<double> &, double &) const –> void

rotation_axis(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzTransform<double>::rotation_axis() const –> class numeric::xyzVector<double>

rotation_cosine(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::rotation_cosine() const –> double

rotation_sine(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::rotation_sine() const –> double

rt6(*args, **kwargs)¶

Overloaded function.

rt6(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> pyrosetta.rosetta.utility.fixedsizearray1_double_6_t

C++: numeric::xyzTransform<double>::rt6() const –> class utility::fixedsizearray1<double, 6>

rt6(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, rt6: pyrosetta.rosetta.utility.fixedsizearray1_double_6_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rt6(const class utility::fixedsizearray1<double, 6> &) –> class numeric::xyzTransform<double> &

rt6(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, i: float, j: float, k: float, l: float, m: float, n: float) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

C++: numeric::xyzTransform<double>::rt6(const double &, const double &, const double &, const double &, const double &, const double &) –> class numeric::xyzTransform<double> &

symhash64(*args, **kwargs)¶

Overloaded function.

symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> int
symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, cw: float) -> int
symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, cw: float, aw: float) -> int

C++: numeric::xyzTransform<double>::symhash64(const double &, const double &) const –> unsigned long

property t¶

to_quaternion(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, qw: float, qx: float, qy: float, qz: float) → None¶: C++: numeric::xyzTransform<double>::to_quaternion(double &, double &, double &, double &) const –> void

x(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::x() –> double &

xform(self: pyrosetta.rosetta.numeric.xyzTransform_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzTransform<double>::xform(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

xx(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::xx() –> double &

xy(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::xy() –> double &

xz(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::xz() –> double &

y(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::y() –> double &

yx(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::yx() –> double &

yy(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::yy() –> double &

yz(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::yz() –> double &

z(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::z() –> double &

zx(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::zx() –> double &

zy(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::zy() –> double &

zz(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) → float¶: C++: numeric::xyzTransform<double>::zz() –> double &

class pyrosetta.rosetta.numeric.xyzTransform_float_t¶

Bases: pybind11_object

static BAD_XFORM() → pyrosetta.rosetta.numeric.xyzTransform_float_t¶: C++: numeric::xyzTransform<float>::BAD_XFORM() –> class numeric::xyzTransform<float>

property R¶

static align(*args, **kwargs)¶

Overloaded function.

align(to: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t
align(to: pyrosetta.rosetta.numeric.xyzVector_float_t, from: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::align(const class numeric::xyzVector<float> &, const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float>

static align_fast(*args, **kwargs)¶

Overloaded function.

align_fast(to: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t
align_fast(to: pyrosetta.rosetta.numeric.xyzVector_float_t, from: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::align_fast(const class numeric::xyzVector<float> &, const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float>

approx_lever_distance(*args, **kwargs)¶

Overloaded function.

approx_lever_distance(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, o: pyrosetta.rosetta.numeric.xyzTransform_float_t) -> float
approx_lever_distance(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, o: pyrosetta.rosetta.numeric.xyzTransform_float_t, lever: float) -> float

C++: numeric::xyzTransform<float>::approx_lever_distance(const class numeric::xyzTransform<float> &, const float &) const –> float

bad(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → bool¶: C++: numeric::xyzTransform<float>::bad() const –> bool

badfast(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → bool¶: C++: numeric::xyzTransform<float>::badfast() const –> bool

distance(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, b: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::distance(const class numeric::xyzTransform<float> &) const –> float

distance_squared(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, b: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::distance_squared(const class numeric::xyzTransform<float> &) const –> float

euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzTransform<float>::euler_angles_deg() const –> class numeric::xyzVector<float>

euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzTransform<float>::euler_angles_rad() const –> class numeric::xyzVector<float>

from_euler_angles_deg(*args, **kwargs)¶

Overloaded function.

from_euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, phi: float, psi: float, theta: float) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::from_euler_angles_deg(const float &, const float &, const float &) –> class numeric::xyzTransform<float> &

from_euler_angles_deg(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, euler: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::from_euler_angles_deg(const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float> &

from_euler_angles_rad(*args, **kwargs)¶

Overloaded function.

from_euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, phi: float, psi: float, theta: float) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::from_euler_angles_rad(const float &, const float &, const float &) –> class numeric::xyzTransform<float> &

from_euler_angles_rad(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, euler: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::from_euler_angles_rad(const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float> &

from_four_points(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, c: pyrosetta.rosetta.numeric.xyzVector_float_t, u: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t, w: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzTransform_float_t¶: C++: numeric::xyzTransform<float>::from_four_points(const class numeric::xyzVector<float> &, const class numeric::xyzVector<float> &, const class numeric::xyzVector<float> &, const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float> &

from_quaternion(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, qw: float, qx: float, qy: float, qz: float) → None¶: C++: numeric::xyzTransform<float>::from_quaternion(const float &, const float &, const float &, const float &) –> void

hash64(*args, **kwargs)¶

Overloaded function.

hash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) -> int
hash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, cw: float) -> int
hash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, cw: float, aw: float) -> int

C++: numeric::xyzTransform<float>::hash64(const float &, const float &) const –> unsigned long

static identity() → pyrosetta.rosetta.numeric.xyzTransform_float_t¶: C++: numeric::xyzTransform<float>::identity() –> class numeric::xyzTransform<float>

inv_xform(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzTransform<float>::inv_xform(const class numeric::xyzVector<float> &) const –> class numeric::xyzVector<float>

inverse(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → pyrosetta.rosetta.numeric.xyzTransform_float_t¶: C++: numeric::xyzTransform<float>::inverse() const –> class numeric::xyzTransform<float>

px(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::px() –> float &

py(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::py() –> float &

pz(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::pz() –> float &

static rot(*args, **kwargs)¶

Overloaded function.

rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_float_t, o_cen: pyrosetta.rosetta.numeric.xyzVector_float_t, cen: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::rot(const class numeric::xyzMatrix<float> &, const class numeric::xyzVector<float> &, const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float>

rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t
rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_float_t, cen: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::rot(const class numeric::xyzMatrix<float> &, const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float>

rot(axs: pyrosetta.rosetta.numeric.xyzVector_float_t, ang: float) -> pyrosetta.rosetta.numeric.xyzTransform_float_t
rot(axs: pyrosetta.rosetta.numeric.xyzVector_float_t, ang: float, cen: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::rot(const class numeric::xyzVector<float> &, const float &, const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float>

static rot_deg(*args, **kwargs)¶

Overloaded function.

rot_deg(axs: pyrosetta.rosetta.numeric.xyzVector_float_t, ang: float) -> pyrosetta.rosetta.numeric.xyzTransform_float_t
rot_deg(axs: pyrosetta.rosetta.numeric.xyzVector_float_t, ang: float, cen: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

C++: numeric::xyzTransform<float>::rot_deg(const class numeric::xyzVector<float> &, const float &, const class numeric::xyzVector<float> &) –> class numeric::xyzTransform<float>

rotation_angle(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::rotation_angle() const –> float

rotation_angle_degrees(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::rotation_angle_degrees() const –> float

rotation_axis(*args, **kwargs)¶

Overloaded function.

rotation_axis(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, axis: pyrosetta.rosetta.numeric.xyzVector_float_t, cen: pyrosetta.rosetta.numeric.xyzVector_float_t, angle: float) -> None

C++: numeric::xyzTransform<float>::rotation_axis(class numeric::xyzVector<float> &, class numeric::xyzVector<float> &, float &) const –> void

rotation_axis(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzTransform<float>::rotation_axis() const –> class numeric::xyzVector<float>

rotation_cosine(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::rotation_cosine() const –> float

rotation_sine(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::rotation_sine() const –> float

rt6(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, i: float, j: float, k: float, l: float, m: float, n: float) → pyrosetta.rosetta.numeric.xyzTransform_float_t¶: C++: numeric::xyzTransform<float>::rt6(const float &, const float &, const float &, const float &, const float &, const float &) –> class numeric::xyzTransform<float> &

symhash64(*args, **kwargs)¶

Overloaded function.

symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) -> int
symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, cw: float) -> int
symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, cw: float, aw: float) -> int

C++: numeric::xyzTransform<float>::symhash64(const float &, const float &) const –> unsigned long

property t¶

to_quaternion(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, qw: float, qx: float, qy: float, qz: float) → None¶: C++: numeric::xyzTransform<float>::to_quaternion(float &, float &, float &, float &) const –> void

x(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::x() –> float &

xform(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzTransform<float>::xform(const class numeric::xyzVector<float> &) const –> class numeric::xyzVector<float>

xx(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::xx() –> float &

xy(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::xy() –> float &

xz(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::xz() –> float &

y(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::y() –> float &

yx(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::yx() –> float &

yy(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::yy() –> float &

yz(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::yz() –> float &

z(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::z() –> float &

zx(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::zx() –> float &

zy(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::zy() –> float &

zz(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) → float¶: C++: numeric::xyzTransform<float>::zz() –> float &

class pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶

Bases: pybind11_object

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::operator=(const class numeric::xyzTriple<unsigned long> &) –> class numeric::xyzTriple<unsigned long> &

assign(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::operator=(const class numeric::xyzTriple<unsigned long> &) –> class numeric::xyzTriple<unsigned long> &

assign(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, t: int) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::operator=(const unsigned long &) –> class numeric::xyzTriple<unsigned long> &

assign(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, x_a: int, y_a: int, z_a: int) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::assign(const unsigned long &, const unsigned long &, const unsigned long &) –> class numeric::xyzTriple<unsigned long> &

at(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, i: int) → int¶: C++: numeric::xyzTriple<unsigned long>::at(const int) –> unsigned long &

clear(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::clear() –> class numeric::xyzTriple<unsigned long> &

cross(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::cross(const class numeric::xyzTriple<unsigned long> &) const –> class numeric::xyzTriple<unsigned long>

cross_product(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::cross_product(const class numeric::xyzTriple<unsigned long> &) const –> class numeric::xyzTriple<unsigned long>

distance(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::distance(const class numeric::xyzTriple<unsigned long> &) const –> unsigned long

distance_squared(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::distance_squared(const class numeric::xyzTriple<unsigned long> &) const –> unsigned long

dot(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::dot(const class numeric::xyzTriple<unsigned long> &) const –> unsigned long

dot_product(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::dot_product(const class numeric::xyzTriple<unsigned long> &) const –> unsigned long

equal_length(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → bool¶: C++: numeric::xyzTriple<unsigned long>::equal_length(const class numeric::xyzTriple<unsigned long> &) –> bool

inner_product(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::inner_product(const class numeric::xyzTriple<unsigned long> &) const –> unsigned long

is_normalized(*args, **kwargs)¶

Overloaded function.

is_normalized(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> bool

C++: numeric::xyzTriple<unsigned long>::is_normalized() const –> bool

is_normalized(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, tol: int) -> bool

C++: numeric::xyzTriple<unsigned long>::is_normalized(const unsigned long &) const –> bool

is_unit(*args, **kwargs)¶

Overloaded function.

is_unit(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> bool

C++: numeric::xyzTriple<unsigned long>::is_unit() const –> bool

is_unit(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, tol: int) -> bool

C++: numeric::xyzTriple<unsigned long>::is_unit(const unsigned long &) const –> bool

is_zero(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → bool¶: C++: numeric::xyzTriple<unsigned long>::is_zero() const –> bool

length(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::length() const –> unsigned long

length_squared(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::length_squared() const –> unsigned long

longer(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → bool¶: C++: numeric::xyzTriple<unsigned long>::longer(const class numeric::xyzTriple<unsigned long> &) –> bool

longer_or_equal(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → bool¶: C++: numeric::xyzTriple<unsigned long>::longer_or_equal(const class numeric::xyzTriple<unsigned long> &) –> bool

magnitude(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::magnitude() const –> unsigned long

magnitude_squared(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::magnitude_squared() const –> unsigned long

max(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::max(const class numeric::xyzTriple<unsigned long> &) –> class numeric::xyzTriple<unsigned long> &

min(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::min(const class numeric::xyzTriple<unsigned long> &) –> class numeric::xyzTriple<unsigned long> &

negate(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::negate() –> class numeric::xyzTriple<unsigned long> &

negated(*args, **kwargs)¶

Overloaded function.

negated(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::negated() const –> class numeric::xyzTriple<unsigned long>

negated(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::negated(class numeric::xyzTriple<unsigned long> &) const –> void

norm(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::norm() const –> unsigned long

norm_squared(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → int¶: C++: numeric::xyzTriple<unsigned long>::norm_squared() const –> unsigned long

normalize(*args, **kwargs)¶

Overloaded function.

normalize(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalize() –> class numeric::xyzTriple<unsigned long> &

normalize(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalize(const unsigned long &) –> class numeric::xyzTriple<unsigned long> &

normalize_any(*args, **kwargs)¶

Overloaded function.

normalize_any(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalize_any() –> class numeric::xyzTriple<unsigned long> &

normalize_any(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalize_any(const unsigned long &) –> class numeric::xyzTriple<unsigned long> &

normalize_or_zero(*args, **kwargs)¶

Overloaded function.

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalize_or_zero() –> class numeric::xyzTriple<unsigned long> &

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalize_or_zero(const unsigned long &) –> class numeric::xyzTriple<unsigned long> &

normalized(*args, **kwargs)¶

Overloaded function.

normalized(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::normalized(class numeric::xyzTriple<unsigned long> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::normalized(const unsigned long &, class numeric::xyzTriple<unsigned long> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalized() const –> class numeric::xyzTriple<unsigned long>

normalized(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalized(const unsigned long &) const –> class numeric::xyzTriple<unsigned long>

normalized_any(*args, **kwargs)¶

Overloaded function.

normalized_any(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::normalized_any(class numeric::xyzTriple<unsigned long> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::normalized_any(const unsigned long &, class numeric::xyzTriple<unsigned long> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalized_any() const –> class numeric::xyzTriple<unsigned long>

normalized_any(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalized_any(const unsigned long &) const –> class numeric::xyzTriple<unsigned long>

normalized_or_zero(*args, **kwargs)¶

Overloaded function.

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::normalized_or_zero(class numeric::xyzTriple<unsigned long> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::normalized_or_zero(const unsigned long &, class numeric::xyzTriple<unsigned long> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalized_or_zero() const –> class numeric::xyzTriple<unsigned long>

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::normalized_or_zero(const unsigned long &) const –> class numeric::xyzTriple<unsigned long>

not_equal_length(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → bool¶: C++: numeric::xyzTriple<unsigned long>::not_equal_length(const class numeric::xyzTriple<unsigned long> &) –> bool

project_normal(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::project_normal(const class numeric::xyzTriple<unsigned long> &) –> class numeric::xyzTriple<unsigned long> &

project_parallel(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::project_parallel(const class numeric::xyzTriple<unsigned long> &) –> class numeric::xyzTriple<unsigned long> &

projected_normal(*args, **kwargs)¶

Overloaded function.

projected_normal(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::projected_normal(const class numeric::xyzTriple<unsigned long> &) const –> class numeric::xyzTriple<unsigned long>

projected_normal(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::projected_normal(const class numeric::xyzTriple<unsigned long> &, class numeric::xyzTriple<unsigned long> &) const –> void

projected_parallel(*args, **kwargs)¶

Overloaded function.

projected_parallel(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t

C++: numeric::xyzTriple<unsigned long>::projected_parallel(const class numeric::xyzTriple<unsigned long> &) const –> class numeric::xyzTriple<unsigned long>

projected_parallel(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> None

C++: numeric::xyzTriple<unsigned long>::projected_parallel(const class numeric::xyzTriple<unsigned long> &, class numeric::xyzTriple<unsigned long> &) –> void

shorter(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → bool¶: C++: numeric::xyzTriple<unsigned long>::shorter(const class numeric::xyzTriple<unsigned long> &) –> bool

shorter_or_equal(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → bool¶: C++: numeric::xyzTriple<unsigned long>::shorter_or_equal(const class numeric::xyzTriple<unsigned long> &) –> bool

x(*args, **kwargs)¶

Overloaded function.

x(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> int

C++: numeric::xyzTriple<unsigned long>::x() –> unsigned long &

x(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, x_a: int) -> None

C++: numeric::xyzTriple<unsigned long>::x(const unsigned long &) –> void

y(*args, **kwargs)¶

Overloaded function.

y(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> int

C++: numeric::xyzTriple<unsigned long>::y() –> unsigned long &

y(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, y_a: int) -> None

C++: numeric::xyzTriple<unsigned long>::y(const unsigned long &) –> void

z(*args, **kwargs)¶

Overloaded function.

z(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> int

C++: numeric::xyzTriple<unsigned long>::z() –> unsigned long &

z(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t, z_a: int) -> None

C++: numeric::xyzTriple<unsigned long>::z(const unsigned long &) –> void

zero(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t¶: C++: numeric::xyzTriple<unsigned long>::zero() –> class numeric::xyzTriple<unsigned long> &

class pyrosetta.rosetta.numeric.xyzVector_double_t¶

Bases: pybind11_object

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::operator=(const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::operator=(const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_double_t, t: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::operator=(const double &) –> class numeric::xyzVector<double> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_double_t, x_a: float, y_a: float, z_a: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::assign(const double &, const double &, const double &) –> class numeric::xyzVector<double> &

clear(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::clear() –> class numeric::xyzVector<double> &

cross(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::cross(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

cross_product(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::cross_product(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

distance(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::distance(const class numeric::xyzVector<double> &) const –> double

distance_squared(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::distance_squared(const class numeric::xyzVector<double> &) const –> double

dot(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::dot(const class numeric::xyzVector<double> &) const –> double

dot_product(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::dot_product(const class numeric::xyzVector<double> &) const –> double

equal_length(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool¶: C++: numeric::xyzVector<double>::equal_length(const class numeric::xyzVector<double> &) –> bool

inner_product(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::inner_product(const class numeric::xyzVector<double> &) const –> double

is_finite(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool¶: C++: numeric::xyzVector<double>::is_finite() const –> bool

is_normalized(*args, **kwargs)¶

Overloaded function.

is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> bool

C++: numeric::xyzVector<double>::is_normalized() const –> bool

is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_double_t, tol: float) -> bool

C++: numeric::xyzVector<double>::is_normalized(const double &) const –> bool

is_unit(*args, **kwargs)¶

Overloaded function.

is_unit(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> bool

C++: numeric::xyzVector<double>::is_unit() const –> bool

is_unit(self: pyrosetta.rosetta.numeric.xyzVector_double_t, tol: float) -> bool

C++: numeric::xyzVector<double>::is_unit(const double &) const –> bool

is_zero(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool¶: C++: numeric::xyzVector<double>::is_zero() const –> bool

length(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::length() const –> double

length_squared(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::length_squared() const –> double

longer(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool¶: C++: numeric::xyzVector<double>::longer(const class numeric::xyzVector<double> &) –> bool

longer_or_equal(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool¶: C++: numeric::xyzVector<double>::longer_or_equal(const class numeric::xyzVector<double> &) –> bool

magnitude(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::magnitude() const –> double

magnitude_squared(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::magnitude_squared() const –> double

max(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::max(const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double> &

maximum_value(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::maximum_value() const –> double

min(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::min(const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double> &

minimum_value(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::minimum_value() const –> double

negate(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::negate() –> class numeric::xyzVector<double> &

negated(*args, **kwargs)¶

Overloaded function.

negated(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::negated() const –> class numeric::xyzVector<double>

negated(self: pyrosetta.rosetta.numeric.xyzVector_double_t, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::negated(class numeric::xyzVector<double> &) const –> void

norm(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::norm() const –> double

norm_squared(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → float¶: C++: numeric::xyzVector<double>::norm_squared() const –> double

normalize(*args, **kwargs)¶

Overloaded function.

normalize(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalize() –> class numeric::xyzVector<double> &

normalize(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalize(const double &) –> class numeric::xyzVector<double> &

normalize_any(*args, **kwargs)¶

Overloaded function.

normalize_any(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalize_any() –> class numeric::xyzVector<double> &

normalize_any(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalize_any(const double &) –> class numeric::xyzVector<double> &

normalize_or_zero(*args, **kwargs)¶

Overloaded function.

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalize_or_zero() –> class numeric::xyzVector<double> &

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalize_or_zero(const double &) –> class numeric::xyzVector<double> &

normalized(*args, **kwargs)¶

Overloaded function.

normalized(self: pyrosetta.rosetta.numeric.xyzVector_double_t, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::normalized(class numeric::xyzVector<double> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::normalized(const double &, class numeric::xyzVector<double> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalized() const –> class numeric::xyzVector<double>

normalized(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalized(const double &) const –> class numeric::xyzVector<double>

normalized_any(*args, **kwargs)¶

Overloaded function.

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_double_t, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::normalized_any(class numeric::xyzVector<double> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::normalized_any(const double &, class numeric::xyzVector<double> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalized_any() const –> class numeric::xyzVector<double>

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalized_any(const double &) const –> class numeric::xyzVector<double>

normalized_or_zero(*args, **kwargs)¶

Overloaded function.

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_double_t, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::normalized_or_zero(class numeric::xyzVector<double> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::normalized_or_zero(const double &, class numeric::xyzVector<double> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalized_or_zero() const –> class numeric::xyzVector<double>

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_double_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::normalized_or_zero(const double &) const –> class numeric::xyzVector<double>

not_equal_length(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool¶: C++: numeric::xyzVector<double>::not_equal_length(const class numeric::xyzVector<double> &) –> bool

project_normal(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::project_normal(const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double> &

project_parallel(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::project_parallel(const class numeric::xyzVector<double> &) –> class numeric::xyzVector<double> &

projected_normal(*args, **kwargs)¶

Overloaded function.

projected_normal(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::projected_normal(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

projected_normal(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::projected_normal(const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) const –> void

projected_parallel(*args, **kwargs)¶

Overloaded function.

projected_parallel(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::xyzVector<double>::projected_parallel(const class numeric::xyzVector<double> &) const –> class numeric::xyzVector<double>

projected_parallel(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t, a: pyrosetta.rosetta.numeric.xyzVector_double_t) -> None

C++: numeric::xyzVector<double>::projected_parallel(const class numeric::xyzVector<double> &, class numeric::xyzVector<double> &) –> void

shorter(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool¶: C++: numeric::xyzVector<double>::shorter(const class numeric::xyzVector<double> &) –> bool

shorter_or_equal(self: pyrosetta.rosetta.numeric.xyzVector_double_t, v: pyrosetta.rosetta.numeric.xyzVector_double_t) → bool¶: C++: numeric::xyzVector<double>::shorter_or_equal(const class numeric::xyzVector<double> &) –> bool

to_string(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → str¶: C++: numeric::xyzVector<double>::to_string() const –> std::string

property x¶

property y¶

property z¶

zero(self: pyrosetta.rosetta.numeric.xyzVector_double_t) → pyrosetta.rosetta.numeric.xyzVector_double_t¶: C++: numeric::xyzVector<double>::zero() –> class numeric::xyzVector<double> &

class pyrosetta.rosetta.numeric.xyzVector_float_t¶

Bases: pybind11_object

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::operator=(const class numeric::xyzVector<float> &) –> class numeric::xyzVector<float> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: numeric::xyzVector<double>) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::operator=(const class numeric::xyzVector<double> &) –> class numeric::xyzVector<float> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::operator=(const class numeric::xyzVector<float> &) –> class numeric::xyzVector<float> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_float_t, t: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::operator=(const float &) –> class numeric::xyzVector<float> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_float_t, x_a: float, y_a: float, z_a: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::assign(const float &, const float &, const float &) –> class numeric::xyzVector<float> &

clear(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::clear() –> class numeric::xyzVector<float> &

cross(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::cross(const class numeric::xyzVector<float> &) const –> class numeric::xyzVector<float>

cross_product(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::cross_product(const class numeric::xyzVector<float> &) const –> class numeric::xyzVector<float>

distance(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::distance(const class numeric::xyzVector<float> &) const –> float

distance_squared(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::distance_squared(const class numeric::xyzVector<float> &) const –> float

dot(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::dot(const class numeric::xyzVector<float> &) const –> float

dot_product(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::dot_product(const class numeric::xyzVector<float> &) const –> float

equal_length(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::xyzVector<float>::equal_length(const class numeric::xyzVector<float> &) –> bool

inner_product(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::inner_product(const class numeric::xyzVector<float> &) const –> float

is_finite(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::xyzVector<float>::is_finite() const –> bool

is_normalized(*args, **kwargs)¶

Overloaded function.

is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> bool

C++: numeric::xyzVector<float>::is_normalized() const –> bool

is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_float_t, tol: float) -> bool

C++: numeric::xyzVector<float>::is_normalized(const float &) const –> bool

is_unit(*args, **kwargs)¶

Overloaded function.

is_unit(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> bool

C++: numeric::xyzVector<float>::is_unit() const –> bool

is_unit(self: pyrosetta.rosetta.numeric.xyzVector_float_t, tol: float) -> bool

C++: numeric::xyzVector<float>::is_unit(const float &) const –> bool

is_zero(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::xyzVector<float>::is_zero() const –> bool

length(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::length() const –> float

length_squared(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::length_squared() const –> float

longer(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::xyzVector<float>::longer(const class numeric::xyzVector<float> &) –> bool

longer_or_equal(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::xyzVector<float>::longer_or_equal(const class numeric::xyzVector<float> &) –> bool

magnitude(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::magnitude() const –> float

magnitude_squared(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::magnitude_squared() const –> float

max(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::max(const class numeric::xyzVector<float> &) –> class numeric::xyzVector<float> &

maximum_value(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::maximum_value() const –> float

min(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::min(const class numeric::xyzVector<float> &) –> class numeric::xyzVector<float> &

minimum_value(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::minimum_value() const –> float

negate(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::negate() –> class numeric::xyzVector<float> &

negated(*args, **kwargs)¶

Overloaded function.

negated(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::negated() const –> class numeric::xyzVector<float>

negated(self: pyrosetta.rosetta.numeric.xyzVector_float_t, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::negated(class numeric::xyzVector<float> &) const –> void

norm(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::norm() const –> float

norm_squared(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → float¶: C++: numeric::xyzVector<float>::norm_squared() const –> float

normalize(*args, **kwargs)¶

Overloaded function.

normalize(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalize() –> class numeric::xyzVector<float> &

normalize(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalize(const float &) –> class numeric::xyzVector<float> &

normalize_any(*args, **kwargs)¶

Overloaded function.

normalize_any(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalize_any() –> class numeric::xyzVector<float> &

normalize_any(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalize_any(const float &) –> class numeric::xyzVector<float> &

normalize_or_zero(*args, **kwargs)¶

Overloaded function.

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalize_or_zero() –> class numeric::xyzVector<float> &

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalize_or_zero(const float &) –> class numeric::xyzVector<float> &

normalized(*args, **kwargs)¶

Overloaded function.

normalized(self: pyrosetta.rosetta.numeric.xyzVector_float_t, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::normalized(class numeric::xyzVector<float> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::normalized(const float &, class numeric::xyzVector<float> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalized() const –> class numeric::xyzVector<float>

normalized(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalized(const float &) const –> class numeric::xyzVector<float>

normalized_any(*args, **kwargs)¶

Overloaded function.

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_float_t, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::normalized_any(class numeric::xyzVector<float> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::normalized_any(const float &, class numeric::xyzVector<float> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalized_any() const –> class numeric::xyzVector<float>

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalized_any(const float &) const –> class numeric::xyzVector<float>

normalized_or_zero(*args, **kwargs)¶

Overloaded function.

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_float_t, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::normalized_or_zero(class numeric::xyzVector<float> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::normalized_or_zero(const float &, class numeric::xyzVector<float> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalized_or_zero() const –> class numeric::xyzVector<float>

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_float_t, length_a: float) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::normalized_or_zero(const float &) const –> class numeric::xyzVector<float>

not_equal_length(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::xyzVector<float>::not_equal_length(const class numeric::xyzVector<float> &) –> bool

project_normal(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::project_normal(const class numeric::xyzVector<float> &) –> class numeric::xyzVector<float> &

project_parallel(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::project_parallel(const class numeric::xyzVector<float> &) –> class numeric::xyzVector<float> &

projected_normal(*args, **kwargs)¶

Overloaded function.

projected_normal(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::projected_normal(const class numeric::xyzVector<float> &) const –> class numeric::xyzVector<float>

projected_normal(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::projected_normal(const class numeric::xyzVector<float> &, class numeric::xyzVector<float> &) const –> void

projected_parallel(*args, **kwargs)¶

Overloaded function.

projected_parallel(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzVector_float_t

C++: numeric::xyzVector<float>::projected_parallel(const class numeric::xyzVector<float> &) const –> class numeric::xyzVector<float>

projected_parallel(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t, a: pyrosetta.rosetta.numeric.xyzVector_float_t) -> None

C++: numeric::xyzVector<float>::projected_parallel(const class numeric::xyzVector<float> &, class numeric::xyzVector<float> &) –> void

shorter(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::xyzVector<float>::shorter(const class numeric::xyzVector<float> &) –> bool

shorter_or_equal(self: pyrosetta.rosetta.numeric.xyzVector_float_t, v: pyrosetta.rosetta.numeric.xyzVector_float_t) → bool¶: C++: numeric::xyzVector<float>::shorter_or_equal(const class numeric::xyzVector<float> &) –> bool

to_string(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → str¶: C++: numeric::xyzVector<float>::to_string() const –> std::string

property x¶

property y¶

property z¶

zero(self: pyrosetta.rosetta.numeric.xyzVector_float_t) → pyrosetta.rosetta.numeric.xyzVector_float_t¶: C++: numeric::xyzVector<float>::zero() –> class numeric::xyzVector<float> &

class pyrosetta.rosetta.numeric.xyzVector_int_t¶

Bases: pybind11_object

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::operator=(const class numeric::xyzVector<int> &) –> class numeric::xyzVector<int> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::operator=(const class numeric::xyzVector<int> &) –> class numeric::xyzVector<int> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_int_t, t: int) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::operator=(const int &) –> class numeric::xyzVector<int> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_int_t, x_a: int, y_a: int, z_a: int) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::assign(const int &, const int &, const int &) –> class numeric::xyzVector<int> &

clear(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::clear() –> class numeric::xyzVector<int> &

cross(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::cross(const class numeric::xyzVector<int> &) const –> class numeric::xyzVector<int>

cross_product(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::cross_product(const class numeric::xyzVector<int> &) const –> class numeric::xyzVector<int>

distance(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::distance(const class numeric::xyzVector<int> &) const –> int

distance_squared(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::distance_squared(const class numeric::xyzVector<int> &) const –> int

dot(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::dot(const class numeric::xyzVector<int> &) const –> int

dot_product(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::dot_product(const class numeric::xyzVector<int> &) const –> int

equal_length(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → bool¶: C++: numeric::xyzVector<int>::equal_length(const class numeric::xyzVector<int> &) –> bool

inner_product(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::inner_product(const class numeric::xyzVector<int> &) const –> int

is_finite(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → bool¶: C++: numeric::xyzVector<int>::is_finite() const –> bool

is_normalized(*args, **kwargs)¶

Overloaded function.

is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> bool

C++: numeric::xyzVector<int>::is_normalized() const –> bool

is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_int_t, tol: int) -> bool

C++: numeric::xyzVector<int>::is_normalized(const int &) const –> bool

is_unit(*args, **kwargs)¶

Overloaded function.

is_unit(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> bool

C++: numeric::xyzVector<int>::is_unit() const –> bool

is_unit(self: pyrosetta.rosetta.numeric.xyzVector_int_t, tol: int) -> bool

C++: numeric::xyzVector<int>::is_unit(const int &) const –> bool

is_zero(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → bool¶: C++: numeric::xyzVector<int>::is_zero() const –> bool

length(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::length() const –> int

length_squared(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::length_squared() const –> int

longer(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → bool¶: C++: numeric::xyzVector<int>::longer(const class numeric::xyzVector<int> &) –> bool

longer_or_equal(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → bool¶: C++: numeric::xyzVector<int>::longer_or_equal(const class numeric::xyzVector<int> &) –> bool

magnitude(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::magnitude() const –> int

magnitude_squared(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::magnitude_squared() const –> int

max(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::max(const class numeric::xyzVector<int> &) –> class numeric::xyzVector<int> &

maximum_value(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::maximum_value() const –> int

min(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::min(const class numeric::xyzVector<int> &) –> class numeric::xyzVector<int> &

minimum_value(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::minimum_value() const –> int

negate(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::negate() –> class numeric::xyzVector<int> &

negated(*args, **kwargs)¶

Overloaded function.

negated(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::negated() const –> class numeric::xyzVector<int>

negated(self: pyrosetta.rosetta.numeric.xyzVector_int_t, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::negated(class numeric::xyzVector<int> &) const –> void

norm(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::norm() const –> int

norm_squared(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → int¶: C++: numeric::xyzVector<int>::norm_squared() const –> int

normalize(*args, **kwargs)¶

Overloaded function.

normalize(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalize() –> class numeric::xyzVector<int> &

normalize(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalize(const int &) –> class numeric::xyzVector<int> &

normalize_any(*args, **kwargs)¶

Overloaded function.

normalize_any(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalize_any() –> class numeric::xyzVector<int> &

normalize_any(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalize_any(const int &) –> class numeric::xyzVector<int> &

normalize_or_zero(*args, **kwargs)¶

Overloaded function.

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalize_or_zero() –> class numeric::xyzVector<int> &

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalize_or_zero(const int &) –> class numeric::xyzVector<int> &

normalized(*args, **kwargs)¶

Overloaded function.

normalized(self: pyrosetta.rosetta.numeric.xyzVector_int_t, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::normalized(class numeric::xyzVector<int> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::normalized(const int &, class numeric::xyzVector<int> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalized() const –> class numeric::xyzVector<int>

normalized(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalized(const int &) const –> class numeric::xyzVector<int>

normalized_any(*args, **kwargs)¶

Overloaded function.

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_int_t, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::normalized_any(class numeric::xyzVector<int> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::normalized_any(const int &, class numeric::xyzVector<int> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalized_any() const –> class numeric::xyzVector<int>

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalized_any(const int &) const –> class numeric::xyzVector<int>

normalized_or_zero(*args, **kwargs)¶

Overloaded function.

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_int_t, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::normalized_or_zero(class numeric::xyzVector<int> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::normalized_or_zero(const int &, class numeric::xyzVector<int> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalized_or_zero() const –> class numeric::xyzVector<int>

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_int_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::normalized_or_zero(const int &) const –> class numeric::xyzVector<int>

not_equal_length(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → bool¶: C++: numeric::xyzVector<int>::not_equal_length(const class numeric::xyzVector<int> &) –> bool

project_normal(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::project_normal(const class numeric::xyzVector<int> &) –> class numeric::xyzVector<int> &

project_parallel(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::project_parallel(const class numeric::xyzVector<int> &) –> class numeric::xyzVector<int> &

projected_normal(*args, **kwargs)¶

Overloaded function.

projected_normal(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::projected_normal(const class numeric::xyzVector<int> &) const –> class numeric::xyzVector<int>

projected_normal(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::projected_normal(const class numeric::xyzVector<int> &, class numeric::xyzVector<int> &) const –> void

projected_parallel(*args, **kwargs)¶

Overloaded function.

projected_parallel(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) -> pyrosetta.rosetta.numeric.xyzVector_int_t

C++: numeric::xyzVector<int>::projected_parallel(const class numeric::xyzVector<int> &) const –> class numeric::xyzVector<int>

projected_parallel(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t, a: pyrosetta.rosetta.numeric.xyzVector_int_t) -> None

C++: numeric::xyzVector<int>::projected_parallel(const class numeric::xyzVector<int> &, class numeric::xyzVector<int> &) –> void

shorter(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → bool¶: C++: numeric::xyzVector<int>::shorter(const class numeric::xyzVector<int> &) –> bool

shorter_or_equal(self: pyrosetta.rosetta.numeric.xyzVector_int_t, v: pyrosetta.rosetta.numeric.xyzVector_int_t) → bool¶: C++: numeric::xyzVector<int>::shorter_or_equal(const class numeric::xyzVector<int> &) –> bool

to_string(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → str¶: C++: numeric::xyzVector<int>::to_string() const –> std::string

property x¶

property y¶

property z¶

zero(self: pyrosetta.rosetta.numeric.xyzVector_int_t) → pyrosetta.rosetta.numeric.xyzVector_int_t¶: C++: numeric::xyzVector<int>::zero() –> class numeric::xyzVector<int> &

class pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶

Bases: pybind11_object

assign(*args, **kwargs)¶

Overloaded function.

assign(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::operator=(const class numeric::xyzVector<unsigned long> &) –> class numeric::xyzVector<unsigned long> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::operator=(const class numeric::xyzVector<unsigned long> &) –> class numeric::xyzVector<unsigned long> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, t: int) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::operator=(const unsigned long &) –> class numeric::xyzVector<unsigned long> &

assign(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, x_a: int, y_a: int, z_a: int) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::assign(const unsigned long &, const unsigned long &, const unsigned long &) –> class numeric::xyzVector<unsigned long> &

clear(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::clear() –> class numeric::xyzVector<unsigned long> &

cross(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::cross(const class numeric::xyzVector<unsigned long> &) const –> class numeric::xyzVector<unsigned long>

cross_product(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::cross_product(const class numeric::xyzVector<unsigned long> &) const –> class numeric::xyzVector<unsigned long>

distance(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::distance(const class numeric::xyzVector<unsigned long> &) const –> unsigned long

distance_squared(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::distance_squared(const class numeric::xyzVector<unsigned long> &) const –> unsigned long

dot(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::dot(const class numeric::xyzVector<unsigned long> &) const –> unsigned long

dot_product(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::dot_product(const class numeric::xyzVector<unsigned long> &) const –> unsigned long

equal_length(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → bool¶: C++: numeric::xyzVector<unsigned long>::equal_length(const class numeric::xyzVector<unsigned long> &) –> bool

inner_product(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::inner_product(const class numeric::xyzVector<unsigned long> &) const –> unsigned long

is_finite(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → bool¶: C++: numeric::xyzVector<unsigned long>::is_finite() const –> bool

is_normalized(*args, **kwargs)¶

Overloaded function.

is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> bool

C++: numeric::xyzVector<unsigned long>::is_normalized() const –> bool

is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, tol: int) -> bool

C++: numeric::xyzVector<unsigned long>::is_normalized(const unsigned long &) const –> bool

is_unit(*args, **kwargs)¶

Overloaded function.

is_unit(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> bool

C++: numeric::xyzVector<unsigned long>::is_unit() const –> bool

is_unit(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, tol: int) -> bool

C++: numeric::xyzVector<unsigned long>::is_unit(const unsigned long &) const –> bool

is_zero(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → bool¶: C++: numeric::xyzVector<unsigned long>::is_zero() const –> bool

length(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::length() const –> unsigned long

length_squared(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::length_squared() const –> unsigned long

longer(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → bool¶: C++: numeric::xyzVector<unsigned long>::longer(const class numeric::xyzVector<unsigned long> &) –> bool

longer_or_equal(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → bool¶: C++: numeric::xyzVector<unsigned long>::longer_or_equal(const class numeric::xyzVector<unsigned long> &) –> bool

magnitude(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::magnitude() const –> unsigned long

magnitude_squared(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::magnitude_squared() const –> unsigned long

max(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::max(const class numeric::xyzVector<unsigned long> &) –> class numeric::xyzVector<unsigned long> &

maximum_value(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::maximum_value() const –> unsigned long

min(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::min(const class numeric::xyzVector<unsigned long> &) –> class numeric::xyzVector<unsigned long> &

minimum_value(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::minimum_value() const –> unsigned long

negate(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::negate() –> class numeric::xyzVector<unsigned long> &

negated(*args, **kwargs)¶

Overloaded function.

negated(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::negated() const –> class numeric::xyzVector<unsigned long>

negated(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::negated(class numeric::xyzVector<unsigned long> &) const –> void

norm(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::norm() const –> unsigned long

norm_squared(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → int¶: C++: numeric::xyzVector<unsigned long>::norm_squared() const –> unsigned long

normalize(*args, **kwargs)¶

Overloaded function.

normalize(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalize() –> class numeric::xyzVector<unsigned long> &

normalize(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalize(const unsigned long &) –> class numeric::xyzVector<unsigned long> &

normalize_any(*args, **kwargs)¶

Overloaded function.

normalize_any(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalize_any() –> class numeric::xyzVector<unsigned long> &

normalize_any(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalize_any(const unsigned long &) –> class numeric::xyzVector<unsigned long> &

normalize_or_zero(*args, **kwargs)¶

Overloaded function.

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalize_or_zero() –> class numeric::xyzVector<unsigned long> &

normalize_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalize_or_zero(const unsigned long &) –> class numeric::xyzVector<unsigned long> &

normalized(*args, **kwargs)¶

Overloaded function.

normalized(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::normalized(class numeric::xyzVector<unsigned long> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::normalized(const unsigned long &, class numeric::xyzVector<unsigned long> &) const –> void

normalized(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalized() const –> class numeric::xyzVector<unsigned long>

normalized(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalized(const unsigned long &) const –> class numeric::xyzVector<unsigned long>

normalized_any(*args, **kwargs)¶

Overloaded function.

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::normalized_any(class numeric::xyzVector<unsigned long> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::normalized_any(const unsigned long &, class numeric::xyzVector<unsigned long> &) const –> void

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalized_any() const –> class numeric::xyzVector<unsigned long>

normalized_any(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalized_any(const unsigned long &) const –> class numeric::xyzVector<unsigned long>

normalized_or_zero(*args, **kwargs)¶

Overloaded function.

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::normalized_or_zero(class numeric::xyzVector<unsigned long> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::normalized_or_zero(const unsigned long &, class numeric::xyzVector<unsigned long> &) const –> void

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalized_or_zero() const –> class numeric::xyzVector<unsigned long>

normalized_or_zero(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, length_a: int) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::normalized_or_zero(const unsigned long &) const –> class numeric::xyzVector<unsigned long>

not_equal_length(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → bool¶: C++: numeric::xyzVector<unsigned long>::not_equal_length(const class numeric::xyzVector<unsigned long> &) –> bool

project_normal(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::project_normal(const class numeric::xyzVector<unsigned long> &) –> class numeric::xyzVector<unsigned long> &

project_parallel(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::project_parallel(const class numeric::xyzVector<unsigned long> &) –> class numeric::xyzVector<unsigned long> &

projected_normal(*args, **kwargs)¶

Overloaded function.

projected_normal(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::projected_normal(const class numeric::xyzVector<unsigned long> &) const –> class numeric::xyzVector<unsigned long>

projected_normal(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::projected_normal(const class numeric::xyzVector<unsigned long> &, class numeric::xyzVector<unsigned long> &) const –> void

projected_parallel(*args, **kwargs)¶

Overloaded function.

projected_parallel(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t

C++: numeric::xyzVector<unsigned long>::projected_parallel(const class numeric::xyzVector<unsigned long> &) const –> class numeric::xyzVector<unsigned long>

projected_parallel(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, a: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) -> None

C++: numeric::xyzVector<unsigned long>::projected_parallel(const class numeric::xyzVector<unsigned long> &, class numeric::xyzVector<unsigned long> &) –> void

shorter(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → bool¶: C++: numeric::xyzVector<unsigned long>::shorter(const class numeric::xyzVector<unsigned long> &) –> bool

shorter_or_equal(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t, v: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → bool¶: C++: numeric::xyzVector<unsigned long>::shorter_or_equal(const class numeric::xyzVector<unsigned long> &) –> bool

to_string(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → str¶: C++: numeric::xyzVector<unsigned long>::to_string() const –> std::string

property x¶

property y¶

property z¶

zero(self: pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t) → pyrosetta.rosetta.numeric.xyzVector_unsigned_long_t¶: C++: numeric::xyzVector<unsigned long>::zero() –> class numeric::xyzVector<unsigned long> &

pyrosetta.rosetta.numeric.z_rotation_matrix(theta: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::z_rotation_matrix(const double &) –> class numeric::xyzMatrix<double>

pyrosetta.rosetta.numeric.z_rotation_matrix_degrees(theta: float) → pyrosetta.rosetta.numeric.xyzMatrix_double_t¶: C++: numeric::z_rotation_matrix_degrees(const double &) –> class numeric::xyzMatrix<double>