_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q260800 | ContentDumper.temporary_path | validation | def temporary_path(self, extension=""):
"""Saves the dump in a temporary file and returns its path.
.. warning:: The user of this method is responsible for deleting this
file to save space on the hard drive.
If you only need a file object for a short period of time
| python | {
"resource": ""
} |
q260801 | AYABPNGBuilder._set_pixel_and_convert_color | validation | def _set_pixel_and_convert_color(self, x, y, color):
"""set the pixel but convert the color before."""
if color is None:
return
color = | python | {
"resource": ""
} |
q260802 | AYABPNGBuilder._set_pixel | validation | def _set_pixel(self, x, y, color):
"""set the color of the pixel.
:param color: must be a valid color in the form of "#RRGGBB".
If you need to convert color, use `_set_pixel_and_convert_color()`.
"""
if not self.is_in_bounds(x, y):
| python | {
"resource": ""
} |
q260803 | InstructionSVGCache.get_instruction_id | validation | def get_instruction_id(self, instruction_or_id):
"""The id that identifies the instruction in this cache.
:param instruction_or_id: an :class:`instruction
<knittingpattern.Instruction.Instruction>` or an instruction id
:return: a :func:`hashable <hash>` object
:rtype: tuple
""" | python | {
"resource": ""
} |
q260804 | InstructionSVGCache.to_svg | validation | def to_svg(self, instruction_or_id,
i_promise_not_to_change_the_result=False):
"""Return the SVG for an instruction.
:param instruction_or_id: either an
:class:`~knittingpattern.Instruction.Instruction` or an id
returned by :meth:`get_instruction_id`
:param bool i_promise_not_to_change_the_result:
| python | {
"resource": ""
} |
q260805 | InstructionSVGCache.instruction_to_svg_dict | validation | def instruction_to_svg_dict(self, instruction_or_id, copy_result=True):
"""Return the SVG dict for the SVGBuilder.
:param instruction_or_id: the instruction or id, see
:meth:`get_instruction_id`
:param bool copy_result: whether to copy the result
:rtype: dict | python | {
"resource": ""
} |
q260806 | Row._instructions_changed | validation | def _instructions_changed(self, change):
"""Call when there is a change in the instructions."""
if change.adds():
for index, instruction in change.items():
if isinstance(instruction, dict):
| python | {
"resource": ""
} |
q260807 | Row.last_produced_mesh | validation | def last_produced_mesh(self):
"""The last produced mesh.
:return: the last produced mesh
:rtype: knittingpattern.Mesh.Mesh
:raises IndexError: if no mesh is produced
.. seealso:: :attr:`number_of_produced_meshes`
"""
for instruction in reversed(self.instructions):
| python | {
"resource": ""
} |
q260808 | Row.last_consumed_mesh | validation | def last_consumed_mesh(self):
"""The last consumed mesh.
:return: the last consumed mesh
:rtype: knittingpattern.Mesh.Mesh
:raises IndexError: if no mesh is consumed
.. seealso:: :attr:`number_of_consumed_meshes`
"""
for instruction in reversed(self.instructions):
| python | {
"resource": ""
} |
q260809 | Row.first_produced_mesh | validation | def first_produced_mesh(self):
"""The first produced mesh.
:return: the first produced mesh
:rtype: knittingpattern.Mesh.Mesh
:raises IndexError: if no mesh is produced
.. seealso:: :attr:`number_of_produced_meshes`
"""
for instruction in self.instructions:
| python | {
"resource": ""
} |
q260810 | Row.first_consumed_mesh | validation | def first_consumed_mesh(self):
"""The first consumed mesh.
:return: the first consumed mesh
:rtype: knittingpattern.Mesh.Mesh
:raises IndexError: if no mesh is consumed
.. seealso:: :attr:`number_of_consumed_meshes`
"""
for instruction in self.instructions:
| python | {
"resource": ""
} |
q260811 | Row.rows_before | validation | def rows_before(self):
"""The rows that produce meshes for this row.
:rtype: list
:return: a list of rows that produce meshes for this row. Each row
occurs only once. They are sorted by the first occurrence in the
instructions.
"""
rows_before = [] | python | {
"resource": ""
} |
q260812 | Row.rows_after | validation | def rows_after(self):
"""The rows that consume meshes from this row.
:rtype: list
:return: a list of rows that consume meshes from this row. Each row
occurs only once. They are sorted by the first occurrence in the
instructions.
"""
rows_after = | python | {
"resource": ""
} |
q260813 | PathLoader.folder | validation | def folder(self, folder):
"""Load all files from a folder recursively.
Depending on :meth:`chooses_path` some paths may not be loaded.
Every loaded path is processed and returned part of the returned list.
:param str folder: the folder to load the files from
:rtype: list
:return: a list of the results of the processing steps of the loaded
files
"""
result = []
| python | {
"resource": ""
} |
q260814 | PathLoader.relative_folder | validation | def relative_folder(self, module, folder):
"""Load a folder located relative to a module and return the processed
result.
:param str module: can be
- a path to a folder
- a path to a file
- a module name
:param str folder: the path of a folder relative to :paramref:`module`
:return: a list of the results of the processing
:rtype: list
| python | {
"resource": ""
} |
q260815 | PathLoader.relative_file | validation | def relative_file(self, module, file):
"""Load a file relative to a module.
:param str module: can be
- a path to a folder
- a path to a file
- a module name
:param str folder: the path of a folder relative to :paramref:`module` | python | {
"resource": ""
} |
q260816 | PathLoader.example | validation | def example(self, relative_path):
"""Load an example from the knitting pattern examples.
:param str relative_path: the path to load
:return: the result of the processing
You can use :meth:`knittingpattern.Loader.PathLoader.examples`
| python | {
"resource": ""
} |
q260817 | ContentLoader.url | validation | def url(self, url, encoding="UTF-8"):
"""load and process the content behind a url
:return: the processed result of the :paramref:`url's <url>` content
:param str url: the url to retrieve the content from
:param str encoding: the encoding of the retrieved content.
The default encoding is UTF-8.
| python | {
"resource": ""
} |
q260818 | JSONLoader.string | validation | def string(self, string):
"""Load an object from a string and return the processed JSON content
:return: the result of the processing step
:param str string: the | python | {
"resource": ""
} |
q260819 | AYABPNGDumper._dump_knitting_pattern | validation | def _dump_knitting_pattern(self, file):
"""dump a knitting pattern to a file."""
knitting_pattern_set = self.__on_dump()
knitting_pattern = knitting_pattern_set.patterns.at(0)
layout = GridLayout(knitting_pattern)
| python | {
"resource": ""
} |
q260820 | unique | validation | def unique(iterables):
"""Create an iterable from the iterables that contains each element once.
:return: an iterable over the iterables. Each element of the result
appeared only once in the result. They are ordered by the first
occurrence in the iterables.
"""
included_elements = set()
def included(element):
| python | {
"resource": ""
} |
q260821 | KnittingPatternToSVG.build_SVG_dict | validation | def build_SVG_dict(self):
"""Go through the layout and build the SVG.
:return: an xml dict that can be exported using a
:class:`~knittingpattern.Dumper.XMLDumper`
:rtype: dict
"""
zoom = self._zoom
layout = self._layout
builder = self._builder
bbox = list(map(lambda f: f * zoom, layout.bounding_box))
builder.bounding_box = bbox
flip_x = bbox[2] + bbox[0] * 2
flip_y = bbox[3] + bbox[1] * 2
instructions = list(layout.walk_instructions(
lambda i: (flip_x - (i.x + i.width) * zoom,
flip_y - (i.y + i.height) * zoom,
i.instruction)))
instructions.sort(key=lambda x_y_i: x_y_i[2].render_z)
for x, y, instruction in instructions:
render_z = instruction.render_z
z_id = ("" if not render_z else "-{}".format(render_z))
layer_id = "row-{}{}".format(instruction.row.id, z_id)
def_id = self._register_instruction_in_defs(instruction)
| python | {
"resource": ""
} |
q260822 | KnittingPatternToSVG._register_instruction_in_defs | validation | def _register_instruction_in_defs(self, instruction):
"""Create a definition for the instruction.
:return: the id of a symbol in the defs for the specified
:paramref:`instruction`
:rtype: str
If no symbol yet exists in the defs for the :paramref:`instruction` a
symbol is created and saved using :meth:`_make_symbol`.
"""
type_ = instruction.type
color_ = instruction.color
instruction_to_svg_dict = \
self._instruction_to_svg.instruction_to_svg_dict
instruction_id = "{}:{}".format(type_, color_)
defs_id = instruction_id + ":defs"
if instruction_id not in self._instruction_type_color_to_symbol:
svg_dict = | python | {
"resource": ""
} |
q260823 | KnittingPatternToSVG._compute_scale | validation | def _compute_scale(self, instruction_id, svg_dict):
"""Compute the scale of an instruction svg.
Compute the scale using the bounding box stored in the
:paramref:`svg_dict`. The scale is saved in a dictionary using
:paramref:`instruction_id` as key.
:param str instruction_id: id identifying a symbol in the defs
:param dict svg_dict: dictionary containing the SVG | python | {
"resource": ""
} |
q260824 | KnittingPatternSet.to_svg | validation | def to_svg(self, zoom):
"""Create an SVG from the knitting pattern set.
:param float zoom: the height and width of a knit instruction
:return: a dumper to save the svg to
:rtype: knittingpattern.Dumper.XMLDumper
Example:
.. code:: python
>>> knitting_pattern_set.to_svg(25).temporary_path(".svg")
"/the/path/to/the/file.svg"
"""
def on_dump():
"""Dump the knitting pattern to the file.
:return: the SVG XML structure as dictionary.
"""
| python | {
"resource": ""
} |
q260825 | KnittingPatternSet.add_new_pattern | validation | def add_new_pattern(self, id_, name=None):
"""Add a new, empty knitting pattern to the set.
:param id_: the id of the pattern
:param name: the name of the pattern to add or if :obj:`None`, the
:paramref:`id_` is used
:return: a new, empty knitting pattern
:rtype: | python | {
"resource": ""
} |
q260826 | Instruction.to_svg | validation | def to_svg(self, converter=None):
"""Return a SVGDumper for this instruction.
:param converter: a :class:`
knittingpattern.convert.InstructionSVGCache.InstructionSVGCache` or
:obj:`None`. If :obj:`None` is given, the :func:`
knittingpattern.convert.InstructionSVGCache.default_svg_cache` is
used.
:rtype: knittingpattern.Dumper.SVGDumper
| python | {
"resource": ""
} |
q260827 | InstructionInRow.transfer_to_row | validation | def transfer_to_row(self, new_row):
"""Transfer this instruction to a new row.
:param knittingpattern.Row.Row new_row: the new row the instruction is
in.
"""
if new_row != self._row:
| python | {
"resource": ""
} |
q260828 | InstructionInRow.get_index_in_row | validation | def get_index_in_row(self):
"""Index of the instruction in the instructions of the row or None.
:return: index in the :attr:`row`'s instructions or None, if the
instruction is not in the row
:rtype: int
.. seealso:: :attr:`row_instructions`, :attr:`index_in_row`,
:meth:`is_in_row`
"""
expected_index = self._cached_index_in_row
instructions = self._row.instructions
if expected_index is not None and \
0 <= expected_index < len(instructions) and \
| python | {
"resource": ""
} |
q260829 | InstructionInRow.next_instruction_in_row | validation | def next_instruction_in_row(self):
"""The instruction after this one or None.
:return: the instruction in :attr:`row_instructions` after this or
:obj:`None` if this is the last
:rtype: knittingpattern.Instruction.InstructionInRow
| python | {
"resource": ""
} |
q260830 | InstructionInRow.index_of_first_produced_mesh_in_row | validation | def index_of_first_produced_mesh_in_row(self):
"""Index of the first produced mesh in the row that consumes it.
:return: an index of the first produced mesh of rows produced meshes
:rtype: int
.. note:: If the instruction :meth:`produces meshes
<Instruction.produces_meshes>`, this is the index of the first
mesh the instruction produces in all the meshes of the row.
If the instruction does not produce meshes, the index of the mesh is
returned as if the instruction had produced a mesh.
.. code::
| python | {
"resource": ""
} |
q260831 | InstructionInRow.index_of_first_consumed_mesh_in_row | validation | def index_of_first_consumed_mesh_in_row(self):
"""The index of the first consumed mesh of this instruction in its row.
Same as :attr:`index_of_first_produced_mesh_in_row`
but for consumed meshes.
"""
index = 0
for instruction in self.row_instructions:
| python | {
"resource": ""
} |
q260832 | Parser._start | validation | def _start(self):
"""Initialize the parsing process."""
self._instruction_library = self._spec.new_default_instructions()
self._as_instruction = self._instruction_library.as_instruction
| python | {
"resource": ""
} |
q260833 | Parser.knitting_pattern_set | validation | def knitting_pattern_set(self, values):
"""Parse a knitting pattern set.
:param dict value: the specification of the knitting pattern set
:rtype: knittingpattern.KnittingPatternSet.KnittingPatternSet
:raises knittingpattern.KnittingPatternSet.ParsingError: if
:paramref:`value` does not fulfill the :ref:`specification
<FileFormatSpecification>`.
| python | {
"resource": ""
} |
q260834 | Parser._fill_pattern_collection | validation | def _fill_pattern_collection(self, pattern_collection, values):
"""Fill a pattern collection."""
pattern = values.get(PATTERNS, [])
for pattern_to_parse in pattern:
| python | {
"resource": ""
} |
q260835 | Parser._row | validation | def _row(self, values):
"""Parse a row."""
row_id = self._to_id(values[ID])
row = self._spec.new_row(row_id, values, self)
if SAME_AS in values:
| python | {
"resource": ""
} |
q260836 | Parser.instruction_in_row | validation | def instruction_in_row(self, row, specification):
"""Parse an instruction.
:param row: the row of the instruction
:param specification: the specification of the instruction
:return: the instruction in the row
"""
| python | {
"resource": ""
} |
q260837 | Parser._pattern | validation | def _pattern(self, base):
"""Parse a pattern."""
rows = self._rows(base.get(ROWS, []))
self._finish_inheritance()
self._finish_instructions()
self._connect_rows(base.get(CONNECTIONS, | python | {
"resource": ""
} |
q260838 | Parser.new_pattern | validation | def new_pattern(self, id_, name, rows=None):
"""Create a new knitting pattern.
If rows is :obj:`None` it is replaced with the
:meth:`new_row_collection`.
"""
if rows is None:
| python | {
"resource": ""
} |
q260839 | Parser._rows | validation | def _rows(self, spec):
"""Parse a collection of rows."""
rows = | python | {
"resource": ""
} |
q260840 | Parser._connect_rows | validation | def _connect_rows(self, connections):
"""Connect the parsed rows."""
for connection in connections:
from_row_id = self._to_id(connection[FROM][ID])
from_row = self._id_cache[from_row_id]
from_row_start_index = connection[FROM].get(START, DEFAULT_START)
from_row_number_of_possible_meshes = \
from_row.number_of_produced_meshes - from_row_start_index
to_row_id = self._to_id(connection[TO][ID])
to_row = self._id_cache[to_row_id]
to_row_start_index = connection[TO].get(START, DEFAULT_START)
to_row_number_of_possible_meshes = \
to_row.number_of_consumed_meshes - to_row_start_index
| python | {
"resource": ""
} |
q260841 | Parser._create_pattern_set | validation | def _create_pattern_set(self, pattern, values):
"""Create a new pattern set."""
type_ = self._get_type(values)
version = self._get_version(values)
comment = values.get(COMMENT) | python | {
"resource": ""
} |
q260842 | KnittingPattern.add_row | validation | def add_row(self, id_):
"""Add a new row to the pattern.
:param id_: the id of the row
"""
| python | {
"resource": ""
} |
q260843 | BytesWrapper.write | validation | def write(self, bytes_):
"""Write bytes to the file."""
string | python | {
"resource": ""
} |
q260844 | TextWrapper.write | validation | def write(self, string):
"""Write a string to the file."""
bytes_ | python | {
"resource": ""
} |
q260845 | SVGDumper.kivy_svg | validation | def kivy_svg(self):
"""An SVG object.
:return: an SVG object
:rtype: kivy.graphics.svg.Svg
:raises ImportError: if the module was not found
"""
from kivy.graphics.svg import Svg
path | python | {
"resource": ""
} |
q260846 | SVGBuilder.insert_defs | validation | def insert_defs(self, defs):
"""Adds the defs to the SVG structure.
:param defs: a list of SVG dictionaries, which contain the defs,
which should be added to the SVG structure.
"""
if self._svg["defs"] is None:
self._svg["defs"] = {}
for def_ in defs:
for key, value in def_.items():
if key.startswith("@"):
continue
| python | {
"resource": ""
} |
q260847 | InstructionInGrid._width | validation | def _width(self):
"""For ``self.width``."""
layout = self._instruction.get(GRID_LAYOUT)
if layout is not | python | {
"resource": ""
} |
q260848 | RowInGrid.instructions | validation | def instructions(self):
"""The instructions in a grid.
:return: the :class:`instructions in a grid <InstructionInGrid>` of
this row
:rtype: list
"""
x = self.x
y = self.y
result = []
| python | {
"resource": ""
} |
q260849 | _RecursiveWalk._step | validation | def _step(self, row, position, passed):
"""Walk through the knitting pattern by expanding an row."""
if row in passed or not self._row_should_be_placed(row, position):
return
self._place_row(row, position)
passed = [row] + passed
# print("{}{} at\t{} {}".format(" " * len(passed), row, position,
# passed))
for i, produced_mesh in enumerate(row.produced_meshes):
| python | {
"resource": ""
} |
q260850 | _RecursiveWalk._expand_consumed_mesh | validation | def _expand_consumed_mesh(self, mesh, mesh_index, row_position, passed):
"""expand the consumed meshes"""
if not mesh.is_produced():
return
row = mesh.producing_row
position = Point(
| python | {
"resource": ""
} |
q260851 | _RecursiveWalk._expand_produced_mesh | validation | def _expand_produced_mesh(self, mesh, mesh_index, row_position, passed):
"""expand the produced meshes"""
if not mesh.is_consumed():
return
row = mesh.consuming_row
position = Point(
| python | {
"resource": ""
} |
q260852 | _RecursiveWalk._place_row | validation | def _place_row(self, row, position):
"""place the instruction on a grid"""
| python | {
"resource": ""
} |
q260853 | _RecursiveWalk._walk | validation | def _walk(self):
"""Loop through all the instructions that are `_todo`."""
while self._todo:
| python | {
"resource": ""
} |
q260854 | _RecursiveWalk.instruction_in_grid | validation | def instruction_in_grid(self, instruction):
"""Returns an `InstructionInGrid` object for the `instruction`"""
row_position = self._rows_in_grid[instruction.row].xy
x = instruction.index_of_first_consumed_mesh_in_row
| python | {
"resource": ""
} |
q260855 | GridLayout.walk_instructions | validation | def walk_instructions(self, mapping=identity):
"""Iterate over instructions.
:return: an iterator over :class:`instructions in grid
<InstructionInGrid>`
:param mapping: funcion to map the result
.. code:: python
for pos, c in layout.walk_instructions(lambda i: (i.xy, | python | {
"resource": ""
} |
q260856 | GridLayout.walk_rows | validation | def walk_rows(self, mapping=identity):
"""Iterate over rows.
:return: an iterator over :class:`rows <RowsInGrid>`
:param mapping: funcion to | python | {
"resource": ""
} |
q260857 | GridLayout.walk_connections | validation | def walk_connections(self, mapping=identity):
"""Iterate over connections between instructions.
:return: an iterator over :class:`connections <Connection>` between
:class:`instructions in grid <InstructionInGrid>`
:param mapping: funcion to map the result, see
:meth:`walk_instructions` for an example usage
"""
for start in self.walk_instructions():
for stop_instruction in start.instruction.consuming_instructions:
if stop_instruction is None:
continue
| python | {
"resource": ""
} |
q260858 | GridLayout.bounding_box | validation | def bounding_box(self):
"""The minimum and maximum bounds of this layout.
:return: ``(min_x, min_y, max_x, max_y)`` the bounding box
of this layout
:rtype: tuple
"""
| python | {
"resource": ""
} |
q260859 | XMLDumper._dump_to_file | validation | def _dump_to_file(self, file):
"""dump to the file"""
| python | {
"resource": ""
} |
q260860 | InstructionLibrary.add_instruction | validation | def add_instruction(self, specification):
"""Add an instruction specification
:param specification: a specification with a key
| python | {
"resource": ""
} |
q260861 | InstructionLibrary.as_instruction | validation | def as_instruction(self, specification):
"""Convert the specification into an instruction
:param specification: a specification with a key
:data:`knittingpattern.Instruction.TYPE`
The instruction is not added.
.. seealso:: :meth:`add_instruction`
"""
instruction = self._instruction_class(specification) | python | {
"resource": ""
} |
q260862 | FreeFormCov.eigh | validation | def eigh(self):
"""
Eigen decomposition of K.
Returns
-------
S : ndarray
The eigenvalues in ascending order, each repeated according to its
multiplicity.
| python | {
"resource": ""
} |
q260863 | FreeFormCov.gradient | validation | def gradient(self):
"""
Derivative of the covariance matrix over the parameters of L.
Returns
-------
Lu : ndarray
Derivative of K over the lower triangular part of L.
"""
L = self.L
self._grad_Lu[:] = 0
for i in range(len(self._tril1[0])):
row = self._tril1[0][i]
col = self._tril1[1][i]
self._grad_Lu[row, :, i] = L[:, col]
self._grad_Lu[:, row, i] += L[:, col]
| python | {
"resource": ""
} |
q260864 | Kron2SumCov.listen | validation | def listen(self, func):
"""
Listen to parameters change.
Parameters
----------
func : callable
| python | {
"resource": ""
} |
q260865 | Kron2SumCov.gradient | validation | def gradient(self):
"""
Gradient of K.
Returns
-------
C0 : ndarray
Derivative of C₀ over its parameters.
C1 : ndarray
Derivative of C₁ over its parameters.
"""
self._init_svd() | python | {
"resource": ""
} |
q260866 | rsolve | validation | def rsolve(A, y):
"""
Robust solve Ax=y.
"""
from numpy_sugar.linalg import rsolve as _rsolve
try:
beta = _rsolve(A, y)
| python | {
"resource": ""
} |
q260867 | multivariate_normal | validation | def multivariate_normal(random, mean, cov):
"""
Draw random samples from a multivariate normal distribution.
Parameters
----------
random : np.random.RandomState instance
Random state.
mean : array_like
Mean of the n-dimensional distribution.
cov : array_like
Covariance matrix of the distribution. It must be symmetric and
| python | {
"resource": ""
} |
q260868 | SumCov.gradient | validation | def gradient(self):
"""
Sum of covariance function derivatives.
Returns
-------
dict
∂K₀ + ∂K₁ + ⋯
"""
grad = {}
for i, f in enumerate(self._covariances):
| python | {
"resource": ""
} |
q260869 | KronMean.B | validation | def B(self):
"""
Effect-sizes parameter, B.
"""
return | python | {
"resource": ""
} |
q260870 | bernoulli_sample | validation | def bernoulli_sample(
offset,
G,
heritability=0.5,
causal_variants=None,
causal_variance=0,
random_state=None,
):
r"""Bernoulli likelihood sampling.
Sample according to
.. math::
\mathbf y \sim \prod_{i=1}^n
\text{Bernoulli}(\mu_i = \text{logit}(z_i))
\mathcal N(~ o \mathbf 1 + \mathbf a^\intercal \boldsymbol\alpha;
~ (h^2 - v_c)\mathrm G^\intercal\mathrm G +
(1-h^2-v_c)\mathrm I ~)
using the canonical Logit link function to define the conditional Bernoulli
mean :math:`\mu_i`.
The causal :math:`\mathbf a` covariates and the corresponding effect-sizes
are randomly draw according to the following idea. The ``causal_variants``,
if given, are first mean-zero and std-one normalized and then having
its elements divided by the squared-root the the number of variances::
causal_variants = _stdnorm(causal_variants, axis=0)
causal_variants /= sqrt(causal_variants.shape[1])
The causal effect-sizes :math:`\boldsymbol\alpha` are draw from
:math:`\{-1, +1\}` and | python | {
"resource": ""
} |
q260871 | poisson_sample | validation | def poisson_sample(
offset,
G,
heritability=0.5,
causal_variants=None,
causal_variance=0,
random_state=None,
):
"""Poisson likelihood sampling.
Parameters
----------
random_state : random_state
Set the initial random state.
Example
-------
.. doctest::
>>> from glimix_core.random import poisson_sample
| python | {
"resource": ""
} |
q260872 | GLMM.covariance | validation | def covariance(self):
r"""Covariance of the prior.
Returns
-------
:class:`numpy.ndarray`
:math:`v_0 \mathrm K + v_1 \mathrm I`.
"""
from numpy_sugar.linalg import ddot, sum2diag
| python | {
"resource": ""
} |
q260873 | GLMM.posteriori_mean | validation | def posteriori_mean(self):
r""" Mean of the estimated posteriori.
This is also the maximum a posteriori estimation of the latent variable.
| python | {
"resource": ""
} |
q260874 | GLMM.posteriori_covariance | validation | def posteriori_covariance(self):
r""" Covariance of the estimated posteriori."""
K = GLMM.covariance(self)
| python | {
"resource": ""
} |
q260875 | FastScanner.fast_scan | validation | def fast_scan(self, M, verbose=True):
"""
LMLs, fixed-effect sizes, and scales for single-marker scan.
Parameters
----------
M : array_like
Matrix of fixed-effects across columns.
verbose : bool, optional
``True`` for progress information; ``False`` otherwise.
Defaults to ``True``.
Returns
-------
lmls : ndarray
Log of the marginal likelihoods.
effsizes0 : ndarray
Covariate fixed-effect sizes.
effsizes1 : ndarray
Candidate set fixed-effect sizes.
scales : ndarray
Scales.
"""
from tqdm import tqdm
if M.ndim != 2:
raise ValueError("`M` array must be bidimensional.")
p = M.shape[1]
lmls = empty(p)
effsizes0 = empty((p, self._XTQ[0].shape[0]))
effsizes0_se = empty((p, self._XTQ[0].shape[0]))
effsizes1 = empty(p)
effsizes1_se = empty(p)
scales = empty(p)
if verbose:
nchunks = min(p, 30)
else:
nchunks = min(p, 1)
chunk_size = (p + nchunks | python | {
"resource": ""
} |
q260876 | GGPSampler.sample | validation | def sample(self, random_state=None):
r"""Sample from the specified distribution.
Parameters
----------
random_state : random_state
Set the initial random state.
Returns
-------
numpy.ndarray
Sample.
"""
| python | {
"resource": ""
} |
q260877 | economic_qs_zeros | validation | def economic_qs_zeros(n):
"""Eigen decomposition of a zero matrix."""
| python | {
"resource": ""
} |
q260878 | GLMMExpFam.gradient | validation | def gradient(self):
r"""Gradient of the log of the marginal likelihood.
Returns
-------
dict
Map between variables to their gradient values.
"""
self._update_approx()
g = self._ep.lml_derivatives(self._X)
ed = exp(-self.logitdelta)
es = exp(self.logscale)
| python | {
"resource": ""
} |
q260879 | LRFreeFormCov.gradient | validation | def gradient(self):
"""
Derivative of the covariance matrix over the lower triangular, flat part of L.
It is equal to
∂K/∂Lᵢⱼ = ALᵀ + LAᵀ,
where Aᵢⱼ is an n×m matrix of zeros except at [Aᵢⱼ]ᵢⱼ=1.
Returns
-------
Lu : ndarray
Derivative of K over the lower-triangular, flat part of L.
"""
L = self.L
n = self.L.shape[0]
grad = {"Lu": zeros((n, n, n * self._L.shape[1]))}
| python | {
"resource": ""
} |
q260880 | LMM.beta | validation | def beta(self):
"""
Fixed-effect sizes.
Returns
-------
effect-sizes : numpy.ndarray
Optimal fixed-effect sizes.
Notes
-----
Setting the derivative of log(p(𝐲)) over effect sizes equal
to zero leads to solutions 𝜷 from equation ::
| python | {
"resource": ""
} |
q260881 | LMM.beta_covariance | validation | def beta_covariance(self):
"""
Estimates the covariance-matrix of the optimal beta.
Returns
-------
beta-covariance : ndarray
(Xᵀ(s((1-𝛿)K + 𝛿I))⁻¹X)⁻¹.
References
----------
.. Rencher, A. C., & Schaalje, G. B. (2008). Linear models in statistics. John
Wiley & Sons.
"""
from numpy_sugar.linalg import ddot
tX = self._X["tX"]
Q = concatenate(self._QS[0], axis=1)
S0 = self._QS[1]
| python | {
"resource": ""
} |
q260882 | LMM.fix | validation | def fix(self, param):
"""
Disable parameter optimization.
Parameters
----------
param : str
Possible values are ``"delta"``, ``"beta"``, and ``"scale"``.
"""
if | python | {
"resource": ""
} |
q260883 | LMM.unfix | validation | def unfix(self, param):
"""
Enable parameter optimization.
Parameters
----------
param : str
Possible values are ``"delta"``, ``"beta"``, and ``"scale"``.
"""
if | python | {
"resource": ""
} |
q260884 | LMM.fit | validation | def fit(self, verbose=True):
"""
Maximise the marginal likelihood.
Parameters
----------
verbose : bool, optional
``True`` for progress output; ``False`` otherwise.
Defaults to ``True``.
"""
if not self._isfixed("logistic"):
| python | {
"resource": ""
} |
q260885 | LMM.value | validation | def value(self):
"""
Internal use only.
"""
if not self._fix["beta"]:
self._update_beta()
| python | {
"resource": ""
} |
q260886 | LMM.delta | validation | def delta(self):
"""
Variance ratio between ``K`` and ``I``.
"""
v = float(self._logistic.value)
if v > 0.0:
v = 1 / (1 + exp(-v))
| python | {
"resource": ""
} |
q260887 | LMM._lml_optimal_scale | validation | def _lml_optimal_scale(self):
"""
Log of the marginal likelihood for optimal scale.
Implementation for unrestricted LML::
Returns
-------
lml : float
Log of the marginal likelihood.
"""
| python | {
"resource": ""
} |
q260888 | LMM._lml_arbitrary_scale | validation | def _lml_arbitrary_scale(self):
"""
Log of the marginal likelihood for arbitrary scale.
Returns
-------
lml : float
Log of the marginal likelihood.
"""
| python | {
"resource": ""
} |
q260889 | LMM._df | validation | def _df(self):
"""
Degrees of freedom.
"""
if | python | {
"resource": ""
} |
q260890 | GLMMNormal.value | validation | def value(self):
r"""Log of the marginal likelihood.
Formally,
.. math::
- \frac{n}{2}\log{2\pi} - \frac{1}{2} \log{\left|
v_0 \mathrm K + v_1 \mathrm I + \tilde{\Sigma} \right|}
- \frac{1}{2}
\left(\tilde{\boldsymbol\mu} -
\mathrm X\boldsymbol\beta\right)^{\intercal}
\left( v_0 \mathrm K + v_1 \mathrm I +
\tilde{\Sigma} \right)^{-1}
\left(\tilde{\boldsymbol\mu} -
\mathrm X\boldsymbol\beta\right)
Returns
-------
float
:math:`\log{p(\tilde{\boldsymbol\mu})}`
"""
from numpy_sugar.linalg import ddot, sum2diag
if self._cache["value"] is not None:
return self._cache["value"]
scale = exp(self.logscale)
delta = 1 / (1 + exp(-self.logitdelta))
v0 = scale * (1 - delta)
v1 = scale * | python | {
"resource": ""
} |
q260891 | Posterior._initialize | validation | def _initialize(self):
r"""Initialize the mean and covariance of the posterior.
Given that :math:`\tilde{\mathrm T}` is a matrix of zeros right before
the first EP iteration, we have
.. math::
\boldsymbol\mu = \mathrm K^{-1} \mathbf m ~\text{ and }~
\Sigma = \mathrm K
as the initial posterior mean and covariance.
"""
if self._mean is None or self._cov is None:
return
| python | {
"resource": ""
} |
q260892 | build_engine_session | validation | def build_engine_session(connection, echo=False, autoflush=None, autocommit=None, expire_on_commit=None,
scopefunc=None):
"""Build an engine and a session.
:param str connection: An RFC-1738 database connection string
:param bool echo: Turn on echoing SQL
:param Optional[bool] autoflush: Defaults to True if not specified in kwargs or configuration.
:param Optional[bool] autocommit: Defaults to False if not specified in kwargs or configuration.
:param Optional[bool] expire_on_commit: Defaults to False if not specified in kwargs or configuration.
:param scopefunc: Scoped function to pass to :func:`sqlalchemy.orm.scoped_session`
:rtype: tuple[Engine,Session]
From the Flask-SQLAlchemy documentation:
An extra key | python | {
"resource": ""
} |
q260893 | ConnectionManager._get_connection | validation | def _get_connection(cls, connection: Optional[str] = None) -> str:
"""Get a default connection string.
| python | {
"resource": ""
} |
q260894 | setup_smtp_factory | validation | def setup_smtp_factory(**settings):
""" expects a dictionary with 'mail.' keys to create an appropriate smtplib.SMTP instance"""
return CustomSMTP(
host=settings.get('mail.host', 'localhost'),
port=int(settings.get('mail.port', 25)),
| python | {
"resource": ""
} |
q260895 | sendMultiPart | validation | def sendMultiPart(smtp, gpg_context, sender, recipients, subject, text, attachments):
""" a helper method that composes and sends an email with attachments
requires a pre-configured smtplib.SMTP instance"""
sent = 0
for to in recipients:
if not to.startswith('<'):
uid = '<%s>' % to
else:
uid = to
if not checkRecipient(gpg_context, uid):
continue
msg = MIMEMultipart()
msg['From'] = sender
msg['To'] = to
msg['Subject'] = subject
msg["Date"] = formatdate(localtime=True)
msg.preamble = u'This is an email in encrypted multipart format.'
attach = MIMEText(str(gpg_context.encrypt(text.encode('utf-8'), uid, always_trust=True)))
attach.set_charset('UTF-8')
msg.attach(attach)
for attachment in attachments:
| python | {
"resource": ""
} |
q260896 | CustomSMTP.begin | validation | def begin(self):
""" connects and optionally authenticates a connection."""
self.connect(self.host, self.port)
if self.user:
| python | {
"resource": ""
} |
q260897 | make_downloader | validation | def make_downloader(url: str, path: str) -> Callable[[bool], str]: # noqa: D202
"""Make a function that downloads the data for you, or uses a cached version at the given path.
:param url: The URL of some data
:param path: The path of the cached data, or where data is cached if it does not already exist
:return: A function that downloads the data and returns the path of the data
"""
def download_data(force_download: bool = False) -> str:
"""Download the data.
:param force_download: If true, overwrites a previously cached file
"""
| python | {
"resource": ""
} |
q260898 | make_df_getter | validation | def make_df_getter(data_url: str, data_path: str, **kwargs) -> Callable[[Optional[str], bool, bool], pd.DataFrame]:
"""Build a function that handles downloading tabular data and parsing it into a pandas DataFrame.
:param data_url: The URL of the data
:param data_path: The path where the data should get stored
:param kwargs: Any other arguments to pass to :func:`pandas.read_csv`
"""
download_function = make_downloader(data_url, data_path)
def get_df(url: Optional[str] = None, cache: bool = True, force_download: bool = False) -> pd.DataFrame:
"""Get the data as a pandas DataFrame.
:param url: The URL (or file path) to download.
:param cache: If true, the data is downloaded to the file | python | {
"resource": ""
} |
q260899 | decode_timestamp | validation | def decode_timestamp(data: str) -> datetime.datetime:
"""
Decode timestamp using bespoke decoder.
Cannot use simple strptime since the ness panel contains a bug
that P199E zone and state updates emitted on the hour cause a minute
value of `60` to be sent, causing strptime to fail. This decoder handles
this edge case.
"""
year = 2000 + int(data[0:2])
month = int(data[2:4])
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.