-
Notifications
You must be signed in to change notification settings - Fork 54
/
__init__.py
770 lines (592 loc) · 24.3 KB
/
__init__.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
# -*- coding: utf-8 -*-
# __init__.py
# python-deltasigma module init file
# Copyright 2013 Giuseppe Venturini
# This file is part of python-deltasigma.
#
# python-deltasigma is a 1:1 Python replacement of Richard Schreier's
# MATLAB delta sigma toolbox (aka "delsigma"), upon which it is heavily based.
# The delta sigma toolbox is (c) 2009, Richard Schreier.
#
# python-deltasigma is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# LICENSE file for the licensing terms.
"""
:Author: Giuseppe Venturini
:Release: |release|
:Date: |today|
**Homepage:** http://www.python-deltasigma.io
**Documentation:** http://docs.python-deltasigma.io
**Repository:** https://github.com/ggventurini/python-deltasigma
**Bug tracker:** https://github.com/ggventurini/python-deltasigma/issues
Introduction
------------
A port of the **MATLAB Delta Sigma Toolbox** based on free software and
very little sleep.
**Python-deltasigma** is a Python package to *synthesize, simulate,
scale and map to implementable structures* **delta sigma modulators**.
It aims to provide **a 1:1 Python port** of Richard Schreier's
***excellent*** `MATLAB Delta Sigma
Toolbox <http://www.mathworks.com/matlabcentral/fileexchange/19-delta-sigma-toolbox>`__,
the *de facto* standard tool for high-level delta sigma simulation, upon
which it is very heavily based.\ |githalytics.com alpha|
Status
------
|Build Status| |Coverage Status| |PyPi version| |PyPi downloads| |BSD 2 clause license|
This project is a *work in progress*, not all functionality has been
ported, yet. The next figure shows the relationship between the main functions
and the avaliable functionality at a glance.
.. image:: ../doc/_static/functionality.png
All the basic features are available since v. 0.1. A detailed changelog may be
found in `CHANGES.rst <https://github.com/ggventurini/python-deltasigma/blob/master/CHANGES.rst>`__.
Detailed information split by file and function status may be found in
`files.csv <https://github.com/ggventurini/python-deltasigma/blob/master/files.csv>`__.
The further functionality is expected to be ported and available in future releases
according to `the ROADMAP <https://github.com/ggventurini/python-deltasigma/blob/master/ROADMAP.md>`__.
Examples
--------
To see the currently implemented functionality in action, take a look
at the following ipython notebooks:
- `dsdemo1 <http://nbviewer.ipython.org/urls/raw.githubusercontent.com/ggventurini/python-deltasigma/master/examples/dsdemo1.ipynb>`__,
notebook port of the interactive ``dsdemo1.m``.
- `dsdemo2 <http://nbviewer.ipython.org/urls/raw.githubusercontent.com/ggventurini/python-deltasigma/master/examples/dsdemo2.ipynb>`__,
notebook port of the interactive ``dsdemo2.m``.
- `dsdemo3 <http://nbviewer.ipython.org/urls/raw.githubusercontent.com/ggventurini/python-deltasigma/master/examples/dsdemo3.ipynb>`__,
notebook port of the interactive ``dsdemo3.m``.
- `dsdemo4 <http://nbviewer.ipython.org/urls/raw.githubusercontent.com/ggventurini/python-deltasigma/master/examples/dsdemo4.ipynb>`__,
notebook port of ``dsdemo4.m``. `Audio
file <https://raw.githubusercontent.com/ggventurini/python-deltasigma/master/examples/sax.wav.b64>`__, right click to download.
- `dsexample1 <http://nbviewer.ipython.org/urls/raw.githubusercontent.com/ggventurini/python-deltasigma/master/examples/dsexample1.ipynb>`__, python
version of ``dsexample1.m``.
- `dsexample2 <http://nbviewer.ipython.org/urls/raw.githubusercontent.com/ggventurini/python-deltasigma/master/examples/dsexample2.ipynb>`__, python
version of ``dsexample2.m``.
- `dsexample3 <http://nbviewer.ipython.org/urls/raw.githubusercontent.com/ggventurini/python-deltasigma/master/examples/dsexample3.ipynb>`__, python
version of ``dsexample3.m``.
They are also a good means for getting started quickly.
If you have some examples you would like to share, `send me a
mail <http://tinymailto.com/5310>`__, and I will add them to the above
list.
Install
-------
Supported platforms
~~~~~~~~~~~~~~~~~~~
python-deltasigma runs on every platform and arch. supported by its
dependencies:
- *Platforms*: Linux, Mac OS X, Windows.
- *Archs*: x86, x86\_64 and armf (arm with floating point unit).
Dependencies
~~~~~~~~~~~~
Using ``python-deltasigma`` requires `Python 2 or 3 <http://www.python.org/>`__,
at your choice, `numpy <http://www.numpy.org/>`__,
`scipy <http://www.scipy.org>`__ (>= 0.11.0) and
`matplotlib <http://www.matplotlib.org>`__.
They are packaged by virtually all the major Linux distributions.
On a Debian Linux system, you may install them issuing:
::
aptitude install python python-numpy python-scipy python-matplotlib
Refer to your system documentation for more information.
On Windows, I hear good things about:
- `Enthought Canopy <https://www.enthought.com/store/>`__, a Python
distribution that carries both free and commercial versions, and
- `Anaconda <https://store.continuum.io/cshop/anaconda/>`__, which
offers its full version for free.
I do not run Windows, so I can't really provide more info (sorry),
except that people tell me they manage to have a working setup.
*Mac OS X* is also supported by `Enthought
Canopy <https://www.enthought.com/store/>`__ and
`Anaconda <https://store.continuum.io/cshop/anaconda/>`__, which likely
provide the easiest and fastest solution to have a scientific Python
stack up and running.
More information can be found on the `scipy install
page <http://www.scipy.org/install.html>`__ and on the `matplotlib
homepage <http://matplotlib.org/>`__.
I wrote in a different context some directions to `compile numpy and
scipy
yourself <https://github.com/ahkab/ahkab/wiki/Install:-numpy-and-scipy>`__,
which also apply here. Be warned, it can easily get complicated.
Optional dependencies
~~~~~~~~~~~~~~~~~~~~~
The required dependencies have been kept to a minimum to allow running
``python-deltasigma`` on workstations that are not managed by the user
but by a system administrator - where typically installing libraries is
not possible and software packages are disarmingly outdated.
If at all possible, installing `Cython <http://www.cython.org>`__ is
strongly recommended.
``python-deltasigma`` contains python extension to simulate delta sigma
modulators providing a near-native execution speed -- overall roughly a
70x speed-up compared to a plain Python implementation.
On Linux, installing Cython is just one: `aptitude install cython`
away.
On Mac OS X and Windows, Cython may be installed as part of one of the
frameworks above. Please notice a compiler is needed, this may require
installing XCode and its command-line utilities or gcc through homebrew,
on Mac OS X, or Mingw, on Windows.
If the BLAS headers are found on the machine, they will be used. In
case they cannot be found automatically, it is recommended to set
the environment variable ``BLAS_H`` to the BLAS headers directory.
On Mac OS X, consider linking the headers to their conventional location::
sudo ln -s /System/Library/Frameworks/Accelerate.framework/Versions/Current/Frameworks/vecLib.framework/Versions/Current/Headers/cblas.h /usr/include/cblas.h
The Cython extensions were written by Sergio Callegari, please see the
``deltasigma/`` for copyright notice and more information.
Install python-deltasigma
~~~~~~~~~~~~~~~~~~~~~~~~~
Once the dependencies set up, it is possible to install the latest stable
version directly from the `Python Package Index (PYPI)
<http://pypi.python.org>`__, running::
pip install deltasigma
The above command will also attempt to compile and install the dependencies
in case they are not found. Please notice this is not recommended and
for this to work you should already have the required C libraries in place.
If you are interested in a bleeding-edge version -- potentially less stable
-- or in contributing code (*that's awesome!*) you can head over to
`the Github repository <http://github.com/ggventurini/python-deltasigma>`__
and check out the code from there.
Then run::
python setup.py install
The flag ``--user`` may be an interesting option to install the package for
the current user only, and it doesn't require root privileges.
Extras for developers
~~~~~~~~~~~~~~~~~~~~~
The following may be installed at a later stage and are typically only
necessary for developers.
Building the documentation requires the
`sphinx <http://sphinx-doc.org/>`__ package. It is an optional step,
as the `the latest documentation is available
online <http://python-deltasigma.readthedocs.org/en/latest/>`__, without
need for you to build it.
If you plan to modify the code, `python-deltasigma` comes with a complete
unit tests suite, which is run against every commit and that any addition
should pass both for Python 2 and 3.
To run it locally, `setuptools <https://pypi.python.org/pypi/setuptools>`__
is needed, as it is used to access the reference function outputs.
Running the test suite may be conveniently automated installing
`nose <https://pypi.python.org/pypi/nose/>`__, and then issuing::
nosetests -v deltasigma/*.py
from the repository root.
Useful resources
----------------
The original MATLAB Toolbox provides in-depth documentation, which is
very useful to understand what the toolbox is capable of. See
`DSToolbox.pdf <https://github.com/ggventurini/python-deltasigma/blob/master/delsig/DSToolbox.pdf?raw=true>`__
and
`OnePageStory.pdf <https://github.com/ggventurini/python-deltasigma/blob/master/delsig/OnePageStory.pdf?raw=true>`__
(*PDF warning*).
The book:
Richard Schreier, Gabor C. Temes, *Understanding Delta-Sigma Data
Converters*, ISBN: 978-0-471-46585-0, November 2004, Wiley-IEEE Press
is probably *the most authoritative resource on the topic*. Chapter 8-9
show how to use the MATLAB toolkit and the observations apply also to
this Python port. Links on
`amazon <http://www.amazon.com/Understanding-Delta-Sigma-Converters-Richard-Schreier/dp/0471465852>`__,
on `the Wiley-IEEE
press <http://eu.wiley.com/WileyCDA/WileyTitle/productCd-0471465852,miniSiteCd-IEEE2.html>`__.
*I am not affiliated with neither the sellers nor the authors.*
How to contribute
-----------------
Pull requests are welcome!
~~~~~~~~~~~~~~~~~~~~~~~~~~
If you want to port some code, fix a bug, add a cool example or implement new
functionality (in this case it may be a good idea to get in touch early on),
*that's awesome!*
There are only a few *guidelines*, which can be overridden every time it
is reasonable to do so:
- Please try to follow ``PEP8``.
- Try to keep the functions signature identical. Parameters with
``NaN`` default values have their default value replaced with
``None``.
- If a function has a varible number of return values, its Python port
should implement the maximum number of return values.
No commit should ever fail the test suite.
Reporting bugs
~~~~~~~~~~~~~~
What bugs, *there are no bugs!*
Jokes aside, please report all bugs on `on the Github issue tracker <https://github.com/ggventurini/python-deltasigma/issues>`__.
Support python-deltasigma
~~~~~~~~~~~~~~~~~~~~~~~~~
*I do not want your money.* I develop this software because I enjoy it
and because I use it myself.
If you wish to support the development of ``python-deltasigma`` or you
find the package useful or you otherwise wish to contribute monetarily,
***please donate to cancer research instead:***
- `Association for International Cancer Research
(eng) <http://www.aicr.org.uk/donate.aspx>`__, or
- `Fond. IRCCS Istituto Nazionale dei Tumori
(it) <http://www.istitutotumori.mi.it/modules.php?name=Content&pa=showpage&pid=24>`__.
Consider `sending me a mail <http://tinymailto.com/5310>`__ afterwards,
***it makes for great motivation!***
License, copyright, rationale and credits
-----------------------------------------
Why this project was born
~~~~~~~~~~~~~~~~~~~~~~~~~
I like challenges, delta-sigma modulation and I don't have the money for
my own MATLAB license. After all, *which grad student or young researcher
has it?*
With this Python package you can simulate delta-sigma modulators for
free, on any PC.
I hope you find it useful.
Licensing and copyright notice
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
All original MATLAB code is Copyright (c) 2009, Richard Schreier. See
the LICENSE file for the licensing terms.
The Python code here provided is a derivative work from the above
toolkit and subject to the same license terms.
Credit goes to Richard Schreier for the original ideas, their MATLAB
implementation and the all the diagrams found in this documentation.
Little-to-no conceptual improvements are introduced here, just code
adaptation, refactoring, rewrites and fixing of a few minor issues.
This package contains some source code from ``pydsm``, also based on the
same MATLAB toolbox. The ``pydsm`` package is copyright (c) 2012, Sergio
Callegari.
When not otherwise specified, the Python code is Copyright 2013,
Giuseppe Venturini and the python-deltasigma contributors.
MATLAB is a registered trademark of The MathWorks, Inc.
.. |githalytics.com alpha| image:: https://cruel-carlota.pagodabox.com/36f25accf60f391456efe66910bf84f8
:target: http://githalytics.com/ggventurini/python-deltasigma
:width: 1
.. |Build Status| image:: https://travis-ci.org/ggventurini/python-deltasigma.png?branch=master
:target: https://travis-ci.org/ggventurini/python-deltasigma
.. |Coverage Status| image:: https://coveralls.io/repos/ggventurini/python-deltasigma/badge.png?branch=master
:target: https://coveralls.io/r/ggventurini/python-deltasigma?branch=master
.. |PyPi version| image:: http://img.shields.io/badge/version-0.1-brightgreen.png
:target: https://pypi.python.org/pypi/deltasigma/
.. |PyPi downloads| image:: https://pypip.in/download/deltasigma/badge.png
:target: https://pypi.python.org/pypi/deltasigma/
.. |BSD 2 clause license| image:: http://img.shields.io/badge/license-BSD%20%282%20clause%29-brightgreen.png
:target: https://raw.githubusercontent.com/ggventurini/python-deltasigma/master/LICENSE
Credits
~~~~~~~
The ``python-deltasigma`` package was written by
`Giuseppe Venturini <https://github.com/ggventurini>`__, as a derivative work
of Richard Schreier's MATLAB Delta Sigma toolbox. It contains code from
``pydsm``, also based on the same MATLAB toolbox and written by Sergio
Callegari.
Contributors: Shayne Hodge
Implementation model
--------------------
The internal implementation of delta sigma modulators follows closely the one in
Richard Schreier's `MATLAB Delta Sigma
Toolbox <http://www.mathworks.com/matlabcentral/fileexchange/19-delta-sigma-toolbox>`__,
upon which the following documentation is very heavily based.
Modulator model
~~~~~~~~~~~~~~~
A delta-sigma modulator with a single quantizer is assumed to consist of
quantizer connected to a loop filter as shown in the diagram below.
.. image:: ../doc/_static/modulator_model.png
:align: center
:alt: Modulator model
.. _loop-filter-label:
The loop filter
:::::::::::::::
The loop filter is described by an :math:`ABCD` matrix. For single-quantizer
systems, the loop filter is a two-input, one-output linear system and
:math:`ABCD` is an :math:`(n+1, n+2)` matrix, partitioned into
:math:`A` :math:`(n, n)`, :math:`B` :math:`(n, 2)`, :math:`C` :math:`(1, n)`
and :math:`D` :math:`(1, 2)` sub-matrices as shown below:
.. math::
ABCD =
\\left[
\\begin{array}{c|c}
A & B \\\\ \\hline
C & D
\\end{array}
\\right].
The equations for updating the state and computing the output of the loop filter are:
.. math::
x(n + 1) = Ax(n) + B
\\left[
\\begin{array}{c}
u(n) \\\\
v(n)
\\end{array}
\\right]
.. math::
y(n) = Cx(n) + D
\\left[
\\begin{array}{c}
u(n) \\\\
v(n)
\\end{array}
\\right].
Where :math:`u(n)` is the input sequence and :math:`v(n)` is the modulator output sequence.
This formulation is sufficiently general to encompass all single-quantizer modulators which
employ linear loop filters. The toolbox currently supports translation to/from an ABCD descrip-
tion and coefficients for the following topologies:
* CIFB : Cascade-of-integrators, feedback form.
* CIFF : Cascade-of-integrators, feedforward form.
* CRFB : Cascade-of-resonators, feedback form.
* CRFF : Cascade-of-resonators, feedforward form.
* CRFBD : Cascade-of-resonators, feedback form, delaying quantizer.
* CRFFD : Cascade-of-resonators, feedforward form, delaying quantizer
* PFF : Parallel feed-forward
* Stratos : A CIFF-like structure with non-delaying resonator feedbacks [*]_
.. [*] Contributed to the MATLAB delta sigma toolbox in 2007 by Jeff Gealow.
See :ref:`topologies-diagrams` for a block-level view of the different modulator structures.
Multi-input and multi-quantizer systems can also be described with an
ABCD matrix and the previous equation
will still apply. For an :math:`n_i`-input, :math:`n_o`-output modulator,
the dimensions of the sub-matrices are
:math:`A`: :math:`(n, n)`, :math:`B`: :math:`(n, n_i + n_o)`,
:math:`C`: :math:`(n_o, n)` and :math:`D`: :math:`(n_o, n_i+n_o)`.
Quantizer model
:::::::::::::::
The quantizer is ideal, producing integer outputs centered about zero. Quantizers with an even
number of levels are of the mid-rise type and produce outputs which are odd integers. Quantizers
with an odd number of levels are of the mid-tread type and produce outputs which are even inte-
gers.
.. image:: ../doc/_static/quantizer_model.png
:align: center
:alt: Quantizer model
.. seealso:: :func:`bquantize`, :func:`bunquantize`
.. _topologies-diagrams:
Topologies diagrams
~~~~~~~~~~~~~~~~~~~
All the following topology diagrams are reproduced from
`DSToolbox.pdf <https://github.com/ggventurini/python-deltasigma/blob/master/delsig/DSToolbox.pdf?raw=true>`__
in the `MATLAB Delta Sigma Toolbox <http://www.mathworks.com/matlabcentral/fileexchange/19-delta-sigma-toolbox>`__,
written by Richard Schreier. All credits belong to the original author.
CIFB
::::
.. image:: ../doc/_static/CIFB.png
:align: center
:alt: CIFB topology
CIFF
::::
.. image:: ../doc/_static/CIFF.png
:align: center
:alt: CIFF topology
CRFB
::::
.. image:: ../doc/_static/CRFB.png
:align: center
:alt: CRFB topology
CRFF
::::
.. image:: ../doc/_static/CRFF.png
:align: center
:alt: CRFF topology
CRFBD
:::::
.. image:: ../doc/_static/CRFBD.png
:align: center
:alt: CRFBD topology
CRFFD
:::::
.. image:: ../doc/_static/CRFFD.png
:align: center
:alt: CRFFD topology
Package contents
----------------
Key Functions
~~~~~~~~~~~~~
.. autosummary::
:nosignatures:
synthesizeNTF
clans
synthesizeChebyshevNTF
simulateDSM
simulateSNR
realizeNTF
stuffABCD
mapABCD
scaleABCD
calculateTF
realizeNTF_ct
mapCtoD
evalTFP
Functions for quadrature systems
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Notice the current version of ``python-deltasigma`` cannot synthesize
quadrature modulators. This feature is expected in v. 0.2.
Nontheless, the following functions are provided since if you already have
a synthesized modulator (or know its ABCD matrix), they allow you to simulate
the modulator with the standard tools for real ABCDs topologies.
.. autosummary::
:nosignatures:
mapQtoR
mapRtoQ
Other selected functions
~~~~~~~~~~~~~~~~~~~~~~~~
The following are auxiliary functions that complement the key functions above.
.. autosummary::
:nosignatures:
mod1
mod2
calculateSNR
predictSNR
partitionABCD
infnorm
impL1
l1norm
pulse
rmsGain
Utility functions for simulation of delta-sigma modulators
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Functions for low-level handling of delta-sigma modulator representations,
their evaluation and filtering.
.. autosummary::
:nosignatures:
bquantize
bunquantize
cancelPZ
circshift
delay
ds_f1f2
ds_freq
ds_hann
ds_optzeros
ds_quantize
ds_synNTFobj1
dsclansNTF
evalMixedTF
evalRPoly
evalTF
nabsH
peakSNR
sinc_decimate
zinc
General utilities for data processing
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
The following are generic functions, useful for misc. tasks, like
manipulating data, conversions or padding, for example.
They provide speciality functions which are not otherwise available
in the usual scientific Python stack.
.. autosummary::
:nosignatures:
db
dbm
dbp
dbv
undbm
undbp
undbv
rms
padb
padl
padr
padt
cplxpair
mfloor
mround
rat
gcd
lcm
Plotting and data display utilitites
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Graphic functions:
.. autosummary::
:nosignatures:
plotPZ
plotSpectrum
figureMagic
DocumentNTF
PlotExampleSpectrum
axisLabels
bilogplot
lollipop
changeFig
Textual and non-graphic display-related functions
.. autosummary::
:nosignatures:
circ_smooth
bplogsmooth
logsmooth
pretty_lti
SIunits
All functions in alphabetical order
-----------------------------------
"""
__author__ = "Giuseppe Venturini and the python-deltasigma contributors"
__copyright__ = "Copyright 2013, Giuseppe Venturini"
__credits__ = ["Giuseppe Venturini"]
__license__ = "BSD 2-Clause License"
__version__ = '0.1-5'
__maintainer__ = "Giuseppe Venturini"
__email__ = "ggventurini+github@gmail.com"
__status__ = "Stable"
# Package testing can be done remotely, without display. This would make
# matplotlib fail (and consequently, the test itself).
# We check for $DISPLAY, but this makes us probably lose in portability,
# does Windows have this environment variable defined?
# Then again, who runs the test suit on a head-less windows machine...
# ... for the time being the following should be OK. If in the future that
# feature is needed by somebody, we can switch to
# if not os.system('python -c "import matplotlib.pyplot as plt;plt.figure()"')
import matplotlib
import os
if not ('DISPLAY' in os.environ or os.environ.get('READTHEDOCS', None)):
matplotlib.use('Agg')
from ._DocumentNTF import DocumentNTF
from ._PlotExampleSpectrum import PlotExampleSpectrum
from ._SIunits import SIunits
from ._axisLabels import axisLabels
from ._bilogplot import bilogplot
from ._bplogsmooth import bplogsmooth
from ._bquantize import bquantize
from ._bunquantize import bunquantize
from ._calculateSNR import calculateSNR
from ._calculateTF import calculateTF
from ._cancelPZ import cancelPZ
from ._changeFig import changeFig
from ._circ_smooth import circ_smooth
from ._clans import clans
from ._constants import eps
from ._db import db
from ._dbm import dbm
from ._dbp import dbp
from ._dbv import dbv
from ._delay import delay
from ._ds_f1f2 import ds_f1f2
from ._ds_freq import ds_freq
from ._ds_hann import ds_hann
from ._ds_optzeros import ds_optzeros
from ._ds_quantize import ds_quantize
from ._ds_synNTFobj1 import ds_synNTFobj1
from ._dsclansNTF import dsclansNTF
from ._evalMixedTF import evalMixedTF
from ._evalRPoly import evalRPoly
from ._evalF0 import evalF0
from ._evalF1 import evalF1
from ._evalTF import evalTF
from ._evalTFP import evalTFP
from ._figureMagic import figureMagic
from ._frespF1 import frespF1
from ._impL1 import impL1
from ._infnorm import infnorm
from ._l1norm import l1norm
from ._logsmooth import logsmooth
from ._lollipop import lollipop
from ._mapABCD import mapABCD
from ._mapCtoD import mapCtoD
from ._mapQtoR import mapQtoR
from ._mapRtoQ import mapRtoQ
from ._mod1 import mod1
from ._mod2 import mod2
from ._nabsH import nabsH
from ._padb import padb
from ._padl import padl
from ._padr import padr
from ._padt import padt
from ._partitionABCD import partitionABCD
from ._peakSNR import peakSNR
from ._plotPZ import plotPZ
from ._plotSpectrum import plotSpectrum
from ._predictSNR import predictSNR
from ._pulse import pulse
from ._realizeNTF import realizeNTF
from ._realizeNTF_ct import realizeNTF_ct
from ._rms import rms
from ._rmsGain import rmsGain
from ._scaleABCD import scaleABCD
from ._simulateDSM import simulateDSM, simulation_backends
from ._simulateSNR import simulateSNR
from ._sinc_decimate import sinc_decimate
from ._stuffABCD import stuffABCD
from ._synthesizeChebyshevNTF import synthesizeChebyshevNTF
from ._synthesizeNTF import synthesizeNTF
from ._thermometer import thermometer
from ._undbm import undbm
from ._undbp import undbp
from ._undbv import undbv
from ._utils import circshift, cplxpair, mfloor, mround, pretty_lti, rat, gcd, lcm
from ._zinc import zinc