numeric

Bindings for ::numeric namespace

class pyrosetta.rosetta.numeric.AgglomerativeHierarchicalClusterer

Bases: pybind11_builtins.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: pyrosetta.rosetta.numeric.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_builtins.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_builtins.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_builtins.pybind11_object

property min_
property min_i_
property min_j_
property node1_
property node2_
class pyrosetta.rosetta.numeric.ClusteringTreeNode

Bases: pybind11_builtins.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.

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

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

  1. 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.

  1. 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>

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

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

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

  2. 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.

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

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

  1. 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.

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

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

  1. 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: pyrosetta.rosetta.numeric.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_builtins.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_builtins.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_std_allocator_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: pyrosetta.rosetta.numeric.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.

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

  2. 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.

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

  2. 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_builtins.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.

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

  2. 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.

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

  2. 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.IntervalSet_Double

Bases: pyrosetta.rosetta.numeric.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.

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

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

  1. 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_builtins.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.

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

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

  1. 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_builtins.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.

  1. 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> &

  1. 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.

  1. 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>

  1. 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_builtins.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.

  1. 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> &

  1. 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.

  1. 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>

  1. 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_builtins.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_builtins.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: pyrosetta.rosetta.numeric.MathNTensorBase_bool_t

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  1. 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.

  1. 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> >

  1. 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.

  1. 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

  1. 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

  1. 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.

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

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

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

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

min(*args, **kwargs)

Overloaded function.

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

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

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

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

n_bins(*args, **kwargs)

Overloaded function.

  1. 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

  1. 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> &

  1. 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.

  1. 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

  1. 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.

  1. 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 &

  1. 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: pyrosetta.rosetta.numeric.MathNTensorBase_double_t

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  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.

  1. 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> >

  1. 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.

  1. 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

  1. 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

  1. 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.

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

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

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

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

min(*args, **kwargs)

Overloaded function.

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

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

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

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

n_bins(*args, **kwargs)

Overloaded function.

  1. 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

  1. 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> &

  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.

  1. 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

  1. 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.

  1. 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 &

  1. 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: pyrosetta.rosetta.numeric.MathNTensorBase_double_t

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  1. 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.

  1. 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> >

  1. 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.

  1. 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

  1. 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

  1. 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.

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

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

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

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

min(*args, **kwargs)

Overloaded function.

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

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

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

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

n_bins(*args, **kwargs)

Overloaded function.

  1. 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

  1. 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> &

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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 &

  1. 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: pyrosetta.rosetta.numeric.MathNTensorBase_double_t

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  1. 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.

  1. 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> >

  1. 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.

  1. 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

  1. 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

  1. 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.

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

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

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

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

min(*args, **kwargs)

Overloaded function.

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

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

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

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

n_bins(*args, **kwargs)

Overloaded function.

  1. 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

  1. 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> &

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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 &

  1. 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: pyrosetta.rosetta.numeric.MathNTensorBase_double_t

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  1. 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.

  1. 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> >

  1. 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.

  1. 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

  1. 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

  1. 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.

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

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

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

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

min(*args, **kwargs)

Overloaded function.

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

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

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

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

n_bins(*args, **kwargs)

Overloaded function.

  1. 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

  1. 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> &

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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 &

  1. 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: pyrosetta.rosetta.numeric.MathNTensorBase_double_t

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  1. 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.

  1. 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> >

  1. 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.

  1. 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

  1. 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

  1. 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.

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

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

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

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

min(*args, **kwargs)

Overloaded function.

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

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

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

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

n_bins(*args, **kwargs)

Overloaded function.

  1. 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

  1. 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> &

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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 &

  1. 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: pyrosetta.rosetta.numeric.MathNTensorBase_double_t

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  1. 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.

  1. 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> >

  1. 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.

  1. 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

  1. 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

  1. 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.

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

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

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

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

min(*args, **kwargs)

Overloaded function.

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

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

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

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

n_bins(*args, **kwargs)

Overloaded function.

  1. 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

  1. 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> &

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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 &

  1. 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_builtins.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_builtins.pybind11_object

MakeVector(*args, **kwargs)

Overloaded function.

  1. 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>

  1. 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>

  1. 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.

  1. 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> &

  1. 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.MultiDimensionalHistogram

Bases: pybind11_builtins.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.

  1. 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 > >

  1. 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.

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

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

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

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

  1. 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

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

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

label(*args, **kwargs)

Overloaded function.

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

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

  1. 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.

  1. 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> >

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

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

  1. 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

  1. 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.

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

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

  1. 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.

  1. 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

  1. 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.

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

  2. 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.

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

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

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

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

  1. 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

  1. 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.Polynomial_1d

Bases: pybind11_builtins.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: pyrosetta.rosetta.numeric.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.

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

  2. 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.

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

  2. 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.

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

  2. 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.

  1. 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> &

  1. 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.

  1. 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> &

  1. 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.

  1. hash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> int

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

  3. 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.

  1. 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>

  1. rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

  2. 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>

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

  2. 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.

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

  2. 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.

  1. 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

  1. 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.

  1. 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>

  1. 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> &

  1. 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.

  1. symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> int

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

  3. 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_builtins.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.

  1. apply(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t

  2. 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.

  1. axis(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::Quaternion<double>::axis() const –> class numeric::xyzVector<double>

  1. 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.

  1. is_normalized(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> bool

  2. 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.

  1. left_multiply_by(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t

  2. 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.

  1. 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

  2. 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.

  1. normalize_if_needed(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t

  2. 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.

  1. not_normalized(self: pyrosetta.rosetta.numeric.Quaternion_double_t) -> bool

  2. 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.

  1. right_multiply_by(self: pyrosetta.rosetta.numeric.Quaternion_double_t, q: pyrosetta.rosetta.numeric.Quaternion_double_t) -> pyrosetta.rosetta.numeric.Quaternion_double_t

  2. 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.

  1. 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

  2. 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.

  1. w(self: pyrosetta.rosetta.numeric.Quaternion_double_t, newval: float) -> None

C++: numeric::Quaternion<double>::w(double) –> void

  1. 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.

  1. x(self: pyrosetta.rosetta.numeric.Quaternion_double_t, newval: float) -> None

C++: numeric::Quaternion<double>::x(double) –> void

  1. 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.

  1. y(self: pyrosetta.rosetta.numeric.Quaternion_double_t, newval: float) -> None

C++: numeric::Quaternion<double>::y(double) –> void

  1. 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.

  1. z(self: pyrosetta.rosetta.numeric.Quaternion_double_t, newval: float) -> None

C++: numeric::Quaternion<double>::z(double) –> void

  1. 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.RocCurve

Bases: pybind11_builtins.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.

  1. insert_point(self: pyrosetta.rosetta.numeric.RocCurve, roc_point: pyrosetta.rosetta.numeric.RocPoint) -> None

C++: numeric::RocCurve::insert_point(const class numeric::RocPoint &) –> void

  1. 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_builtins.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.

  1. score(self: pyrosetta.rosetta.numeric.RocPoint) -> float

C++: numeric::RocPoint::score() const –> double

  1. score(self: pyrosetta.rosetta.numeric.RocPoint, score: float) -> None

C++: numeric::RocPoint::score(const double &) –> void

status(*args, **kwargs)

Overloaded function.

  1. status(self: pyrosetta.rosetta.numeric.RocPoint) -> pyrosetta.rosetta.numeric.RocStatus

C++: numeric::RocPoint::status() const –> enum numeric::RocStatus

  1. 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.

  1. tag(self: pyrosetta.rosetta.numeric.RocPoint) -> str

C++: numeric::RocPoint::tag() const –> std::string

  1. tag(self: pyrosetta.rosetta.numeric.RocPoint, tag: str) -> None

C++: numeric::RocPoint::tag(const std::string &) –> void

class pyrosetta.rosetta.numeric.RocStatus

Bases: pybind11_builtins.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>
class pyrosetta.rosetta.numeric.SingleLinkClusterer

Bases: pyrosetta.rosetta.numeric.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_builtins.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_builtins.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.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t

Bases: pybind11_builtins.pybind11_object

Clear(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t) None

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::Clear() –> void

ExtractPosition(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, input: core::scoring::nmr::VoxelGridPoint) pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::ExtractPosition(const class core::scoring::nmr::VoxelGridPoint &) const –> const class numeric::xyzVector<double> *

GetBoundingBox(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t) pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::GetBoundingBox() const –> const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &

GetDimension(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t) int

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::GetDimension() const –> unsigned long

GetGridItems(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t) pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_const_core_scoring_nmr_VoxelGridPoint_*_const_numeric_xyzVector_double_*_std_allocator_std_pair_const_core_scoring_nmr_VoxelGridPoint_*_const_numeric_xyzVector_double_*_t

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::GetGridItems() const –> const class utility::vector1<class utility::vector1<struct std::pair<const class core::scoring::nmr::VoxelGridPoint *, const class numeric::xyzVector<double> *>, class std::allocator<struct std::pair<const class core::scoring::nmr::VoxelGridPoint *, const class numeric::xyzVector<double> *> > >, class std::allocator<class utility::vector1<struct std::pair<const class core::scoring::nmr::VoxelGridPoint *, const class numeric::xyzVector<double> *>, class std::allocator<struct std::pair<const class core::scoring::nmr::VoxelGridPoint *, const class numeric::xyzVector<double> *> > > > > &

GetNumberItems(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t) int

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::GetNumberItems() const –> unsigned long

GetResolution(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t) float

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::GetResolution() const –> double

HasNeighbors(*args, **kwargs)

Overloaded function.

  1. HasNeighbors(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, input: core::scoring::nmr::VoxelGridPoint, neighborhood: float) -> bool

  2. HasNeighbors(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, input: core::scoring::nmr::VoxelGridPoint, neighborhood: float, check_relevance: bool) -> bool

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::HasNeighbors(const class core::scoring::nmr::VoxelGridPoint &, const double &, bool) const –> bool

InsertObject(*args, **kwargs)

Overloaded function.

  1. InsertObject(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, new_item: core::scoring::nmr::VoxelGridPoint) -> None

  2. InsertObject(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, new_item: core::scoring::nmr::VoxelGridPoint, check_relevance: bool) -> None

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::InsertObject(const class core::scoring::nmr::VoxelGridPoint &, bool) –> void

IsRelevantItem(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, item: core::scoring::nmr::VoxelGridPoint) bool

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::IsRelevantItem(const class core::scoring::nmr::VoxelGridPoint &) const –> bool

IsSameItem(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, item1: core::scoring::nmr::VoxelGridPoint, item2: core::scoring::nmr::VoxelGridPoint) bool

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::IsSameItem(const class core::scoring::nmr::VoxelGridPoint &, const class core::scoring::nmr::VoxelGridPoint &) const –> bool

RemoveObject(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, item_to_remove: core::scoring::nmr::VoxelGridPoint) None

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::RemoveObject(const class core::scoring::nmr::VoxelGridPoint &) –> void

Translate(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, translation: pyrosetta.rosetta.numeric.xyzVector_double_t) None

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::Translate(const class numeric::xyzVector<double> &) –> void

assign(self: pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t, : pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t) pyrosetta.rosetta.numeric.VoxelGrid_core_scoring_nmr_VoxelGridPoint_t

C++: numeric::VoxelGrid<core::scoring::nmr::VoxelGridPoint>::operator=(const class numeric::VoxelGrid<class core::scoring::nmr::VoxelGridPoint> &) –> class numeric::VoxelGrid<class core::scoring::nmr::VoxelGridPoint> &

class pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t

Bases: pybind11_builtins.pybind11_object

Clear(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t) None

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::Clear() –> void

ExtractPosition(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, input: protocols::nmr::pcs::AtomGridPoint) pyrosetta.rosetta.numeric.xyzVector_double_t

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::ExtractPosition(const class protocols::nmr::pcs::AtomGridPoint &) const –> const class numeric::xyzVector<double> *

GetBoundingBox(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t) pyrosetta.rosetta.numeric.geometry.BoundingBox_numeric_xyzVector_double_t

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::GetBoundingBox() const –> const class numeric::geometry::BoundingBox<class numeric::xyzVector<double> > &

GetDimension(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t) int

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::GetDimension() const –> unsigned long

GetGridItems(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t) pyrosetta.rosetta.utility.vector1_utility_vector1_std_pair_const_protocols_nmr_pcs_AtomGridPoint_*_const_numeric_xyzVector_double_*_std_allocator_std_pair_const_protocols_nmr_pcs_AtomGridPoint_*_const_numeric_xyzVector_double_*_t

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::GetGridItems() const –> const class utility::vector1<class utility::vector1<struct std::pair<const class protocols::nmr::pcs::AtomGridPoint *, const class numeric::xyzVector<double> *>, class std::allocator<struct std::pair<const class protocols::nmr::pcs::AtomGridPoint *, const class numeric::xyzVector<double> *> > >, class std::allocator<class utility::vector1<struct std::pair<const class protocols::nmr::pcs::AtomGridPoint *, const class numeric::xyzVector<double> *>, class std::allocator<struct std::pair<const class protocols::nmr::pcs::AtomGridPoint *, const class numeric::xyzVector<double> *> > > > > &

GetNumberItems(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t) int

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::GetNumberItems() const –> unsigned long

GetResolution(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t) float

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::GetResolution() const –> double

HasNeighbors(*args, **kwargs)

Overloaded function.

  1. HasNeighbors(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, input: protocols::nmr::pcs::AtomGridPoint, neighborhood: float) -> bool

  2. HasNeighbors(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, input: protocols::nmr::pcs::AtomGridPoint, neighborhood: float, check_relevance: bool) -> bool

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::HasNeighbors(const class protocols::nmr::pcs::AtomGridPoint &, const double &, bool) const –> bool

InsertObject(*args, **kwargs)

Overloaded function.

  1. InsertObject(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, new_item: protocols::nmr::pcs::AtomGridPoint) -> None

  2. InsertObject(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, new_item: protocols::nmr::pcs::AtomGridPoint, check_relevance: bool) -> None

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::InsertObject(const class protocols::nmr::pcs::AtomGridPoint &, bool) –> void

IsRelevantItem(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, item: protocols::nmr::pcs::AtomGridPoint) bool

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::IsRelevantItem(const class protocols::nmr::pcs::AtomGridPoint &) const –> bool

IsSameItem(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, item1: protocols::nmr::pcs::AtomGridPoint, item2: protocols::nmr::pcs::AtomGridPoint) bool

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::IsSameItem(const class protocols::nmr::pcs::AtomGridPoint &, const class protocols::nmr::pcs::AtomGridPoint &) const –> bool

RemoveObject(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, item_to_remove: protocols::nmr::pcs::AtomGridPoint) None

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::RemoveObject(const class protocols::nmr::pcs::AtomGridPoint &) –> void

Translate(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, translation: pyrosetta.rosetta.numeric.xyzVector_double_t) None

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::Translate(const class numeric::xyzVector<double> &) –> void

assign(self: pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t, : pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t) pyrosetta.rosetta.numeric.VoxelGrid_protocols_nmr_pcs_AtomGridPoint_t

C++: numeric::VoxelGrid<protocols::nmr::pcs::AtomGridPoint>::operator=(const class numeric::VoxelGrid<class protocols::nmr::pcs::AtomGridPoint> &) –> class numeric::VoxelGrid<class protocols::nmr::pcs::AtomGridPoint> &

class pyrosetta.rosetta.numeric.XformHash32

Bases: pyrosetta.rosetta.std.unary_function_numeric_xyzTransform_float_unsigned_long_t

class pyrosetta.rosetta.numeric.XformHash64

Bases: pyrosetta.rosetta.std.unary_function_numeric_xyzTransform_double_unsigned_long_t

class pyrosetta.rosetta.numeric.Xforms

Bases: pyrosetta.rosetta.utility.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.

  1. pop(self: pyrosetta.rosetta.utility.vector1_numeric_xyzTransform_double_t) -> numeric::xyzTransform<double>

remove and return last item

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. calc_zscore(input_v: pyrosetta.rosetta.std.map_unsigned_long_double, zscore_v: pyrosetta.rosetta.std.map_unsigned_long_double) -> None

  2. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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> &

  1. 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.

  1. 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> &

  1. 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.

  1. 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>

  1. 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.

  1. max(a: int, b: int) -> int

max( short int, short int )

C++: numeric::max(const short, const short) –> short

  1. max(a: int, b: int) -> int

max( int, int )

C++: numeric::max(const int, const int) –> int

  1. max(a: int, b: int) -> int

max( long int, long int )

C++: numeric::max(const long, const long) –> long

  1. max(a: int, b: int) -> int

max( unsigned short int, unsigned short int )

C++: numeric::max(const unsigned short, const unsigned short) –> unsigned short

  1. max(a: int, b: int) -> int

max( unsigned int, unsigned int )

C++: numeric::max(const unsigned int, const unsigned int) –> unsigned int

  1. max(a: int, b: int) -> int

max( unsigned long int, unsigned long int )

C++: numeric::max(const unsigned long, const unsigned long) –> unsigned long

  1. max(a: float, b: float) -> float

max( float, float )

C++: numeric::max(const float, const float) –> float

  1. max(a: float, b: float) -> float

max( double, double )

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

  1. 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.

  1. min(a: int, b: int) -> int

min( short int, short int )

C++: numeric::min(const short, const short) –> short

  1. min(a: int, b: int) -> int

min( int, int )

C++: numeric::min(const int, const int) –> int

  1. min(a: int, b: int) -> int

min( long int, long int )

C++: numeric::min(const long, const long) –> long

  1. min(a: int, b: int) -> int

min( unsigned short int, unsigned short int )

C++: numeric::min(const unsigned short, const unsigned short) –> unsigned short

  1. min(a: int, b: int) -> int

min( unsigned int, unsigned int )

C++: numeric::min(const unsigned int, const unsigned int) –> unsigned int

  1. min(a: int, b: int) -> int

min( unsigned long int, unsigned long int )

C++: numeric::min(const unsigned long, const unsigned long) –> unsigned long

  1. min(a: float, b: float) -> float

min( float, float )

C++: numeric::min(const float, const float) –> float

  1. min(a: float, b: float) -> float

min( double, double )

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

  1. 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.

  1. mod(x: int, y: int) -> int

C++: numeric::mod(const long &, const long &) –> long

  1. 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.

  1. modulo(x: int, y: int) -> int

C++: numeric::modulo(const long &, const long &) –> long

  1. modulo(x: float, y: float) -> float

C++: numeric::modulo(const double &, const double &) –> double

  1. modulo(x: int, y: int) -> int

C++: numeric::modulo(const int &, const int &) –> int

pyrosetta.rosetta.numeric.nearest_ssize(*args, **kwargs)

Overloaded function.

  1. nearest_ssize(x: float) -> int

C++: numeric::nearest_ssize(const long double &) –> long

  1. nearest_ssize(x: float) -> int

C++: numeric::nearest_ssize(const double &) –> long

pyrosetta.rosetta.numeric.nonnegative_principal_angle_degrees(*args, **kwargs)

Overloaded function.

  1. nonnegative_principal_angle_degrees(angle: float) -> float

C++: numeric::nonnegative_principal_angle_degrees(const double &) –> double

  1. 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.

  1. 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>

  1. 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.

  1. principal_angle_degrees(angle: float) -> float

C++: numeric::principal_angle_degrees(const double &) –> double

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. remainder(x: float, y: float) -> float

C++: numeric::remainder(const double &, const double &) –> double

  1. remainder(x: int, y: int) -> int

C++: numeric::remainder(const int &, const int &) –> int

pyrosetta.rosetta.numeric.rgb_to_hsv(*args, **kwargs)

Overloaded function.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. sign(x: float) -> int

C++: numeric::sign(const double &) –> int

  1. sign(x: float) -> int

C++: numeric::sign(const long double &) –> int

pyrosetta.rosetta.numeric.sin_cos_range(*args, **kwargs)

Overloaded function.

  1. sin_cos_range(x: float) -> float

  2. 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.

  1. 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>

  1. 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_builtins.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_builtins.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.

  1. 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> &

  1. 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> &

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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_builtins.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.

  1. 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> &

  1. 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> &

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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_builtins.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.

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

  2. 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.

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

  2. 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.

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

  2. 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.

  1. 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> &

  1. 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.

  1. 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> &

  1. 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.

  1. hash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> int

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

  3. 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.

  1. 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>

  1. rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_double_t) -> pyrosetta.rosetta.numeric.xyzTransform_double_t

  2. 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>

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

  2. 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.

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

  2. 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.

  1. 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

  1. 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.

  1. 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>

  1. 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> &

  1. 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.

  1. symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_double_t) -> int

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

  3. 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_builtins.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.

  1. align(to: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

  2. 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.

  1. align_fast(to: pyrosetta.rosetta.numeric.xyzVector_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

  2. 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.

  1. approx_lever_distance(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, o: pyrosetta.rosetta.numeric.xyzTransform_float_t) -> float

  2. 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.

  1. 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> &

  1. 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.

  1. 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> &

  1. 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.

  1. hash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) -> int

  2. hash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, cw: float) -> int

  3. 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.

  1. 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>

  1. rot(rot: pyrosetta.rosetta.numeric.xyzMatrix_float_t) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

  2. 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>

  1. rot(axs: pyrosetta.rosetta.numeric.xyzVector_float_t, ang: float) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

  2. 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.

  1. rot_deg(axs: pyrosetta.rosetta.numeric.xyzVector_float_t, ang: float) -> pyrosetta.rosetta.numeric.xyzTransform_float_t

  2. 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.

  1. 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

  1. 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.

  1. symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t) -> int

  2. symhash64(self: pyrosetta.rosetta.numeric.xyzTransform_float_t, cw: float) -> int

  3. 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_builtins.pybind11_object

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  1. 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> &

  1. 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> &

  1. 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.

  1. is_normalized(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> bool

C++: numeric::xyzTriple<unsigned long>::is_normalized() const –> bool

  1. 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.

  1. is_unit(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> bool

C++: numeric::xyzTriple<unsigned long>::is_unit() const –> bool

  1. 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.

  1. 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>

  1. 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.

  1. 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> &

  1. 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.

  1. 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> &

  1. 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.

  1. 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> &

  1. 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.

  1. 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

  1. 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

  1. 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>

  1. 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.

  1. 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

  1. 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

  1. 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>

  1. 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.

  1. 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

  1. 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

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. 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>

  1. 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.

  1. x(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> int

C++: numeric::xyzTriple<unsigned long>::x() –> unsigned long &

  1. 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.

  1. y(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> int

C++: numeric::xyzTriple<unsigned long>::y() –> unsigned long &

  1. 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.

  1. z(self: pyrosetta.rosetta.numeric.xyzTriple_unsigned_long_t) -> int

C++: numeric::xyzTriple<unsigned long>::z() –> unsigned long &

  1. 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_builtins.pybind11_object

assign(*args, **kwargs)

Overloaded function.

  1. 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> &

  1. 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> &

  1. 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> &

  1. 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.

  1. is_normalized(self: pyrosetta.rosetta.numeric.xyzVector_double_t) -> bool

C++: numeric::xyzVector<double>::is_normalized() const –> bool

  1. 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)