From 238ce84fd4680c5a1402dac1a83b26e3685f1da0 Mon Sep 17 00:00:00 2001
From: Marco Selig
Date: Mon, 21 Jan 2013 13:49:54 +0100
Subject: [PATCH] docstring corrections.
---
README.rst | 2 +-
nifty_cmaps.py | 4 +--
nifty_core.py | 80 +++++++++++++++++++++++++-------------------------
nifty_power.py | 6 ++--
4 files changed, 46 insertions(+), 46 deletions(-)
diff --git a/README.rst b/README.rst
index 6270eff7..a6548249 100644
--- a/README.rst
+++ b/README.rst
@@ -67,7 +67,7 @@ apply to fields.
* (and more)
-*Parts of this summary are taken* [1]_ *without marking them explicitly as
+*Parts of this summary are taken from* [1]_ *without marking them explicitly as
quotations.*
Installation
diff --git a/nifty_cmaps.py b/nifty_cmaps.py
index bed1577a..34fce2a0 100644
--- a/nifty_cmaps.py
+++ b/nifty_cmaps.py
@@ -33,7 +33,7 @@
The visualization of fields is useful for obvious reasons, and therefore
some nice color maps are here to be found. Those are segmented color maps
- that can be used in many settings, including the native ploting method for
+ that can be used in many settings, including the native plotting method for
fields. (Some of the color maps offered here are results from IFT
publications, cf. references below.)
@@ -237,4 +237,4 @@ class ncmap(object):
return cm("Plus Minus", segmentdata, N=int(ncolors), gamma=1.0)
-##-----------------------------------------------------------------------------
\ No newline at end of file
+##-----------------------------------------------------------------------------
diff --git a/nifty_core.py b/nifty_core.py
index 8163eb00..f7af834a 100644
--- a/nifty_core.py
+++ b/nifty_core.py
@@ -42,7 +42,7 @@
taken care of automatically without concerning the user. This allows for an
abstract formulation and programming of inference algorithms, including
those derived within information field theory. Thus, NIFTY permits its user
- to rapidly prototype algorithms in 1D, and then apply the developed code in
+ to rapidly prototype algorithms in 1D and then apply the developed code in
higher-dimensional settings of real world problems. The set of spaces on
which NIFTY operates comprises point sets, n-dimensional regular grids,
spherical spaces, their harmonic counterparts, and product spaces
@@ -5579,7 +5579,7 @@ class field(object):
controlled by kwargs.
target : space, *optional*
- The space wherein the operator output lives (default: domain)
+ The space wherein the operator output lives (default: domain).
Other Parameters
@@ -5629,7 +5629,7 @@ class field(object):
controlled by the keyword arguments.
target : space, *optional*
- The space wherein the operator output lives (default: domain)
+ The space wherein the operator output lives (default: domain).
"""
def __init__(self,domain,val=None,target=None,**kwargs):
@@ -7482,10 +7482,10 @@ class operator(object):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -7559,10 +7559,10 @@ class operator(object):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -7657,10 +7657,10 @@ class operator(object):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -7721,10 +7721,10 @@ class operator(object):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -7784,10 +7784,10 @@ class operator(object):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -7848,10 +7848,10 @@ class operator(object):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -7902,10 +7902,10 @@ class diagonal_operator(operator):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -7953,10 +7953,10 @@ class diagonal_operator(operator):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -8240,10 +8240,10 @@ class diagonal_operator(operator):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -8327,10 +8327,10 @@ class diagonal_operator(operator):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -8408,7 +8408,7 @@ def identity(domain):
Returns an identity operator.
The identity operator is represented by a `diagonal_operator` instance,
- which is applicable to a field-like object; i.e., a scalars, list,
+ which is applicable to a field-like object; i.e., a scalar, list,
array or field. (The identity operator is unrelated to PYTHON's
built-in function :py:func:`id`.)
@@ -8492,10 +8492,10 @@ class power_operator(diagonal_operator):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
@@ -9229,10 +9229,10 @@ class vecvec_operator(operator):
Notes
-----
The ambiguity of `bare` or non-bare diagonal entries is based
- on the choise of a matrix representation of the operator in
- question. The naive choise of absorbing the volume weights
+ on the choice of a matrix representation of the operator in
+ question. The naive choice of absorbing the volume weights
into the matrix leads to a matrix-vector calculus with the
- non-bare entries which seems intuitive, though. The choise of
+ non-bare entries which seems intuitive, though. The choice of
keeping matrix entries and volume weights separate deals with the
bare entries that allow for correct interpretation of the matrix
entries; e.g., as variance in case of an covariance operator.
diff --git a/nifty_power.py b/nifty_power.py
index df4b3467..ea4126d3 100644
--- a/nifty_power.py
+++ b/nifty_power.py
@@ -36,11 +36,11 @@
homogeneity and isotropy. Fields which are only statistically homogeneous
can also be created using the diagonal operator routine.
- In the moment, NIFTy offers one additional routine for power spectrum
+ At the moment, NIFTy offers one additional routine for power spectrum
manipulation, the smooth_power function to smooth a power spectrum with a
Gaussian convolution kernel. This can be necessary in cases where power
- spectra are reconstructed and reused in an interative algorithm, where
- too much statistical variation might effect severely the results.
+ spectra are reconstructed and reused in an iterative algorithm, where
+ too much statistical variation might severely effect the results.
"""
--
GitLab