[Scipysvn] r6242  trunk/scipy/signal
scipysvn@scip...
scipysvn@scip...
Fri Feb 19 05:02:13 CST 2010
Author: stefan
Date: 20100219 05:02:12 0600 (Fri, 19 Feb 2010)
New Revision: 6242
Modified:
trunk/scipy/signal/waveforms.py
Log:
DOC: Waveforms: format math in monospace.
Modified: trunk/scipy/signal/waveforms.py
===================================================================
 trunk/scipy/signal/waveforms.py 20100219 11:01:31 UTC (rev 6241)
+++ trunk/scipy/signal/waveforms.py 20100219 11:02:12 UTC (rev 6242)
@@ 13,6 +13,7 @@
which rises from 1 to 1 on the interval 0 to width*2*pi
and drops from 1 to 1 on the interval width*2*pi to 2*pi
width must be in the interval [0,1]
+
"""
t,w = asarray(t), asarray(width)
w = asarray(w + (tt))
@@ 51,6 +52,7 @@
"""Returns a periodic squarewave waveform with period 2*pi
which is +1 from 0 to 2*pi*duty and 1 from 2*pi*duty to 2*pi
duty must be in the interval [0,1]
+
"""
t,w = asarray(t), asarray(duty)
w = asarray(w + (tt))
@@ 102,6 +104,7 @@
pulse amplitude falls below tpr (in dB).
retquad  Return the quadrature (imaginary) as well as the real part of the signal
retenv  Return the envelope of th signal.
+
"""
if fc < 0:
raise ValueError, "Center frequency (fc=%.2f) must be >=0." % fc
@@ 152,7 +155,7 @@
t : ndarray
Times at which to evaluate the waveform.
f0 : float
 Frequency (in Hz) at time t=0.
+ Frequency (in Hz) at time t=0.
t1 : float
Time at which `f1` is specified.
f1 : float
@@ 171,50 +174,55 @@

A numpy array containing the signal evaluated at 't' with the requested
timevarying frequency. More precisely, the function returns
 cos(phase + (pi/180)*phi)
 where `phase` is the integral (from 0 to t) of 2*pi*f(t). f(t) is defined below.
+ ``cos(phase + (pi/180)*phi)``
+ where `phase` is the integral (from 0 to t) of ``2*pi*f(t)``.
+ ``f(t)`` is defined below.
Notes

There are four options for the `method`. The following formulas give the
instantaneous frequency (in Hz) of the signal generated by `chirp()`.
For convenience, the shorter names shown below may also be used.

+
linear, lin, li:
 f(t) = f0 + (f1  f0) * t / t1

+ ``f(t) = f0 + (f1  f0) * t / t1``
+
quadratic, quad, q:
The graph of the frequency f(t) is a parabola through (0, f0) and (t1, f1).
By default, the vertex of the parabola is at (0, f0). If `vertex_zero`
is False, then the vertex is at (t1, f1). The formula is:
 if vertex_zero is True::
 f(t) = f0 + (f1  f0) * t**2 / t1**2
 else:
 f(t) = f1  (f1  f0) * (t1  t)**2 / t1**2
+ if vertex_zero is True:
+ ``f(t) = f0 + (f1  f0) * t**2 / t1**2``
+
+ else
+
+ ``f(t) = f1  (f1  f0) * (t1  t)**2 / t1**2``
+
To use a more general quadratic function, or an arbitrary polynomial,
use the function `scipy.signal.waveforms.sweep_poly`.
logarithmic, log, lo:
 f(t) = f0 * (f1/f0)**(t/t1)

+ ``f(t) = f0 * (f1/f0)**(t/t1)``
+
f0 and f1 must be nonzero and have the same sign.
This signal is also known as a geometric or exponential chirp.
hyperbolic, hyp:
 f(t) = f0*f1*t1 / ((f0  f1)*t + f1*t1)

+ ``f(t) = f0*f1*t1 / ((f0  f1)*t + f1*t1)``
+
f1 must be positive, and f0 must be greater than f1.
See Also

scipy.signal.waveforms.sweep_poly
+
"""
# 'phase' is computed in _chirp_phase, to make testing easier.
phase = _chirp_phase(t, f0, t1, f1, method, vertex_zero)
@@ 222,11 +230,12 @@
phi *= pi / 180
return cos(phase + phi)

+
def _chirp_phase(t, f0, t1, f1, method='linear', vertex_zero=True):
"""
Calculate the phase used by chirp_phase to generate its output. See
chirp_phase for a description of the arguments.
+
"""
if method in ['linear', 'lin', 'li']:
beta = (f1  f0) / t1
@@ 237,7 +246,7 @@
if vertex_zero:
phase = 2*pi * (f0*t + beta * t**3/3)
else:
 phase = 2*pi * (f1*t + beta * ((t1  t)**3  t1**3)/3)
+ phase = 2*pi * (f1*t + beta * ((t1  t)**3  t1**3)/3)
elif method in ['logarithmic', 'log', 'lo']:
if f0*f1 <= 0.0:
@@ 266,7 +275,7 @@
def sweep_poly(t, poly, phi=0):
"""Frequencyswept cosine generator, with a timedependent frequency specified
as a polynomial.

+
This function generates a sinusoidal function whose instantaneous frequency
varies with time. The frequency at time `t` is given by the polynomial `poly`.
@@ 275,12 +284,14 @@
t : ndarray
Times at which to evaluate the waveform.
poly : 1D ndarray (or arraylike), or instance of numpy.poly1d
 The desired frequency expressed as a polynomial. If `poly` is a list or
 ndarray of length n, then the elements of `poly` are the coefficients of the
 polynomial, and the instantaneous frequency is
 f(t) = poly[0]*t**(n1) + poly[1]*t**(n2) + ... + poly[n1]
 If `poly` is an instance of numpy.poly1d, then the instantaneous frequency is
 f(t) = poly(t)
+ The desired frequency expressed as a polynomial. If `poly` is
+ a list or ndarray of length n, then the elements of `poly` are
+ the coefficients of the polynomial, and the instantaneous
+ frequency is
+ ``f(t) = poly[0]*t**(n1) + poly[1]*t**(n2) + ... + poly[n1]``
+ If `poly` is an instance of numpy.poly1d, then the
+ instantaneous frequency is
+ ``f(t) = poly(t)``
phi : float, optional
Phase offset, in degrees. Default is 0.
@@ 288,12 +299,14 @@

A numpy array containing the signal evaluated at 't' with the requested
timevarying frequency. More precisely, the function returns
 cos(phase + (pi/180)*phi)
 where `phase` is the integral (from 0 to t) of 2*pi*f(t); f(t) is defined above.

+ ``cos(phase + (pi/180)*phi)``
+ where `phase` is the integral (from 0 to t) of ``2 * pi * f(t)``;
+ ``f(t)`` is defined above.
+
See Also

scipy.signal.waveforms.chirp
+
"""
# 'phase' is computed in _sweep_poly_phase, to make testing easier.
phase = _sweep_poly_phase(t, poly)
@@ 305,6 +318,7 @@
"""
Calculate the phase used by sweep_poly to generate its output. See
sweep_poly for a description of the arguments.
+
"""
# polyint handles lists, ndarrays and instances of poly1d automatically.
intpoly = polyint(poly)
More information about the Scipysvn
mailing list