← Back to branch summary

~ubuntu-branches/ubuntu/wily/python-pyo/wily-proposed

« back to all changes in this revision

Viewing changes to pyolib/filters.py

  • Committer: Package Import Robot
  • Author(s): Tiago Bortoletto Vaz
  • Date: 2015-07-28 17:02:57 UTC
  • mfrom: (1.1.12)
  • Revision ID: package-import@ubuntu.com-20150728170257-vndrh33h3o2p0ilc
Tags: 0.7.6-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
pyolib/filters.py
69
69
 
70
70
    """
71
71
    def __init__(self, input, freq=1000, q=1, type=0, mul=1, add=0):
 
72
        pyoArgsAssert(self, "oOOiOO", input, freq, q, type, mul, add)
72
73
        PyoObject.__init__(self, mul, add)
73
74
        self._input = input
74
75
        self._freq = freq
90
91
                Crossfade time between old and new input. Defaults to 0.05.
91
92
 
92
93
        """
 
94
        pyoArgsAssert(self, "oN", x, fadetime)
93
95
        self._input = x
94
96
        self._in_fader.setInput(x, fadetime)
95
97
 
103
105
                New `freq` attribute.
104
106
 
105
107
        """
 
108
        pyoArgsAssert(self, "O", x)
106
109
        self._freq = x
107
110
        x, lmax = convertArgsToLists(x)
108
111
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
117
120
                New `q` attribute.
118
121
 
119
122
        """
 
123
        pyoArgsAssert(self, "O", x)
120
124
        self._q = x
121
125
        x, lmax = convertArgsToLists(x)
122
126
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
136
140
                    4. allpass
137
141
 
138
142
        """
 
143
        pyoArgsAssert(self, "i", x)
139
144
        self._type = x
140
145
        x, lmax = convertArgsToLists(x)
141
146
        [obj.setType(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
212
217
 
213
218
    """
214
219
    def __init__(self, input, freq=1000, q=1, type=0, stages=4, mul=1, add=0):
 
220
        pyoArgsAssert(self, "oOOiiOO", input, freq, q, type, stages, mul, add)
215
221
        PyoObject.__init__(self, mul, add)
216
222
        self._input = input
217
223
        self._freq = freq
234
240
                Crossfade time between old and new input. Defaults to 0.05.
235
241
 
236
242
        """
 
243
        pyoArgsAssert(self, "oN", x, fadetime)
237
244
        self._input = x
238
245
        self._in_fader.setInput(x, fadetime)
239
246
 
247
254
                New `freq` attribute.
248
255
 
249
256
        """
 
257
        pyoArgsAssert(self, "O", x)
250
258
        self._freq = x
251
259
        x, lmax = convertArgsToLists(x)
252
260
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
261
269
                New `q` attribute.
262
270
 
263
271
        """
 
272
        pyoArgsAssert(self, "O", x)
264
273
        self._q = x
265
274
        x, lmax = convertArgsToLists(x)
266
275
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
280
289
                4. allpass
281
290
 
282
291
        """
 
292
        pyoArgsAssert(self, "i", x)
283
293
        self._type = x
284
294
        x, lmax = convertArgsToLists(x)
285
295
        [obj.setType(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
294
304
                New `stages` attribute.
295
305
 
296
306
        """
 
307
        pyoArgsAssert(self, "i", x)
297
308
        self._stages = x
298
309
        x, lmax = convertArgsToLists(x)
299
310
        [obj.setStages(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
383
394
 
384
395
    """
385
396
    def __init__(self, input, b0=0.005066, b1=0.010132, b2=0.005066, a0=1.070997, a1=-1.979735, a2=0.929003, mul=1, add=0):
 
397
        pyoArgsAssert(self, "oOOOOOOOO", input, b0, b1, b2, a0, a1, a2, mul, add)
386
398
        PyoObject.__init__(self, mul, add)
387
399
        self._input = input
388
400
        self._b0 = Sig(b0)
407
419
                Crossfade time between old and new input. Defaults to 0.05.
408
420
 
409
421
        """
 
422
        pyoArgsAssert(self, "oN", x, fadetime)
410
423
        self._input = x
411
424
        self._in_fader.setInput(x, fadetime)
412
425
 
420
433
                New `b0` attribute.
421
434
 
422
435
        """
 
436
        pyoArgsAssert(self, "O", x)
423
437
        self._b0.value = x
424
438
 
425
439
    def setB1(self, x):
432
446
                New `b1` attribute.
433
447
 
434
448
        """
 
449
        pyoArgsAssert(self, "O", x)
435
450
        self._b1.value = x
436
451
 
437
452
    def setB2(self, x):
444
459
                New `b2` attribute.
445
460
 
446
461
        """
 
462
        pyoArgsAssert(self, "O", x)
447
463
        self._b2.value = x
448
464
 
449
465
    def setA0(self, x):
456
472
                New `a0` attribute.
457
473
 
458
474
        """
 
475
        pyoArgsAssert(self, "O", x)
459
476
        self._a0.value = x
460
477
 
461
478
    def setA1(self, x):
468
485
                New `a1` attribute.
469
486
 
470
487
        """
 
488
        pyoArgsAssert(self, "O", x)
471
489
        self._a1.value = x
472
490
 
473
491
    def setA2(self, x):
480
498
                New `a2` attribute.
481
499
 
482
500
        """
 
501
        pyoArgsAssert(self, "O", x)
483
502
        self._a2.value = x
484
503
 
485
504
    def setCoeffs(self, *args, **kwds):
601
620
 
602
621
    """
603
622
    def __init__(self, input, freq=1000, q=1, boost=-3.0, type=0, mul=1, add=0):
 
623
        pyoArgsAssert(self, "oOOOiOO", input, freq, q, boost, type, mul, add)
604
624
        PyoObject.__init__(self, mul, add)
605
625
        self._input = input
606
626
        self._freq = freq
623
643
                Crossfade time between old and new input. Defaults to 0.05.
624
644
 
625
645
        """
 
646
        pyoArgsAssert(self, "oN", x, fadetime)
626
647
        self._input = x
627
648
        self._in_fader.setInput(x, fadetime)
628
649
 
636
657
                New `freq` attribute.
637
658
 
638
659
        """
 
660
        pyoArgsAssert(self, "O", x)
639
661
        self._freq = x
640
662
        x, lmax = convertArgsToLists(x)
641
663
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
650
672
                New `q` attribute.
651
673
 
652
674
        """
 
675
        pyoArgsAssert(self, "O", x)
653
676
        self._q = x
654
677
        x, lmax = convertArgsToLists(x)
655
678
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
664
687
                New `boost` attribute.
665
688
 
666
689
        """
 
690
        pyoArgsAssert(self, "O", x)
667
691
        self._boost = x
668
692
        x, lmax = convertArgsToLists(x)
669
693
        [obj.setBoost(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
681
705
                2. highshelf
682
706
 
683
707
        """
 
708
        pyoArgsAssert(self, "i", x)
684
709
        self._type = x
685
710
        x, lmax = convertArgsToLists(x)
686
711
        [obj.setType(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
748
773
 
749
774
    """
750
775
    def __init__(self, input, freq=1000, mul=1, add=0):
 
776
        pyoArgsAssert(self, "oOOO", input, freq, mul, add)
751
777
        PyoObject.__init__(self, mul, add)
752
778
        self._input = input
753
779
        self._freq = freq
767
793
                Crossfade time between old and new input. Default to 0.05.
768
794
 
769
795
        """
 
796
        pyoArgsAssert(self, "oN", x, fadetime)
770
797
        self._input = x
771
798
        self._in_fader.setInput(x, fadetime)
772
799
 
780
807
                New `freq` attribute.
781
808
 
782
809
        """
 
810
        pyoArgsAssert(self, "O", x)
783
811
        self._freq = x
784
812
        x, lmax = convertArgsToLists(x)
785
813
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
823
851
 
824
852
    """
825
853
    def __init__(self, input, freq=1000, mul=1, add=0):
 
854
        pyoArgsAssert(self, "oOOO", input, freq, mul, add)
826
855
        PyoObject.__init__(self, mul, add)
827
856
        self._input = input
828
857
        self._freq = freq
842
871
                Crossfade time between old and new input. Default to 0.05.
843
872
 
844
873
        """
 
874
        pyoArgsAssert(self, "oN", x, fadetime)
845
875
        self._input = x
846
876
        self._in_fader.setInput(x, fadetime)
847
877
 
855
885
                New `freq` attribute.
856
886
 
857
887
        """
 
888
        pyoArgsAssert(self, "O", x)
858
889
        self._freq = x
859
890
        x, lmax = convertArgsToLists(x)
860
891
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
910
941
 
911
942
    """
912
943
    def __init__(self, input, risetime=0.05, falltime=0.05, init=0, mul=1, add=0):
 
944
        pyoArgsAssert(self, "oOOnOO", input, risetime, falltime, init, mul, add)
913
945
        PyoObject.__init__(self, mul, add)
914
946
        self._input = input
915
947
        self._risetime = risetime
930
962
                Crossfade time between old and new input. Defaults to 0.05.
931
963
 
932
964
        """
 
965
        pyoArgsAssert(self, "oN", x, fadetime)
933
966
        self._input = x
934
967
        self._in_fader.setInput(x, fadetime)
935
968
 
943
976
                New `risetime` attribute.
944
977
 
945
978
        """
 
979
        pyoArgsAssert(self, "O", x)
946
980
        self._risetime = x
947
981
        x, lmax = convertArgsToLists(x)
948
982
        [obj.setRiseTime(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
957
991
                New `falltime` attribute.
958
992
 
959
993
        """
 
994
        pyoArgsAssert(self, "O", x)
960
995
        self._falltime = x
961
996
        x, lmax = convertArgsToLists(x)
962
997
        [obj.setFallTime(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1006
1041
 
1007
1042
    """
1008
1043
    def __init__(self, input, mul=1, add=0):
 
1044
        pyoArgsAssert(self, "oOO", input, mul, add)
1009
1045
        PyoObject.__init__(self, mul, add)
1010
1046
        self._input = input
1011
1047
        self._in_fader = InputFader(input)
1024
1060
                Crossfade time between old and new input. Default to 0.05.
1025
1061
 
1026
1062
        """
 
1063
        pyoArgsAssert(self, "oN", x, fadetime)
1027
1064
        self._input = x
1028
1065
        self._in_fader.setInput(x, fadetime)
1029
1066
 
1070
1107
 
1071
1108
    """
1072
1109
    def __init__(self, input, num=6, min=20, max=20000, q=1, mul=1, add=0):
 
1110
        pyoArgsAssert(self, "oINNOOO", input, num, min, max, q, mul, add)
1073
1111
        PyoObject.__init__(self, mul, add)
1074
1112
        self._input = input
1075
1113
        self._num = num
1098
1136
                Crossfade time between old and new input. Defaults to 0.05.
1099
1137
 
1100
1138
        """
 
1139
        pyoArgsAssert(self, "oN", x, fadetime)
1101
1140
        self._input = x
1102
1141
        self._in_fader.setInput(x, fadetime)
1103
1142
 
1111
1150
                new `q` attribute.
1112
1151
 
1113
1152
        """
 
1153
        pyoArgsAssert(self, "O", x)
1114
1154
        self._q = x
1115
1155
        x, lmax = convertArgsToLists(x)
1116
1156
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1169
1209
 
1170
1210
    """
1171
1211
    def __init__(self, input, freq1=150, freq2=500, freq3=2000, mul=1, add=0):
 
1212
        pyoArgsAssert(self, "oOOOOO", input, freq1, freq2, freq3, mul, add)
1172
1213
        PyoObject.__init__(self, mul, add)
1173
1214
        self._input = input
1174
1215
        self._freq1 = freq1
1196
1237
                Crossfade time between old and new input. Defaults to 0.05.
1197
1238
 
1198
1239
        """
 
1240
        pyoArgsAssert(self, "oN", x, fadetime)
1199
1241
        self._input = x
1200
1242
        self._in_fader.setInput(x, fadetime)
1201
1243
 
1209
1251
                new `freq1` attribute.
1210
1252
 
1211
1253
        """
 
1254
        pyoArgsAssert(self, "O", x)
1212
1255
        self._freq1 = x
1213
1256
        x, lmax = convertArgsToLists(x)
1214
1257
        [obj.setFreq1(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1223
1266
                new `freq2` attribute.
1224
1267
 
1225
1268
        """
 
1269
        pyoArgsAssert(self, "O", x)
1226
1270
        self._freq2 = x
1227
1271
        x, lmax = convertArgsToLists(x)
1228
1272
        [obj.setFreq2(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1237
1281
                new `freq3` attribute.
1238
1282
 
1239
1283
        """
 
1284
        pyoArgsAssert(self, "O", x)
1240
1285
        self._freq3 = x
1241
1286
        x, lmax = convertArgsToLists(x)
1242
1287
        [obj.setFreq3(wrap(x,i)) for i, obj in enumerate(self._base_players)]
1321
1366
 
1322
1367
    """
1323
1368
    def __init__(self, input, mul=1, add=0):
 
1369
        pyoArgsAssert(self, "oOO", input, mul, add)
1324
1370
        PyoObject.__init__(self, mul, add)
1325
1371
        self._real_dummy = []
1326
1372
        self._imag_dummy = []
1381
1427
                Crossfade time between old and new input. Default to 0.05.
1382
1428
 
1383
1429
        """
 
1430
        pyoArgsAssert(self, "oN", x, fadetime)
1384
1431
        self._input = x
1385
1432
        self._in_fader.setInput(x, fadetime)
1386
1433
 
1429
1476
 
1430
1477
    """
1431
1478
    def __init__(self, input, delay=0.01, feedback=0, maxdelay=1, mul=1, add=0):
 
1479
        pyoArgsAssert(self, "oOOnOO", input, delay, feedback, maxdelay, mul, add)
1432
1480
        PyoObject.__init__(self, mul, add)
1433
1481
        self._input = input
1434
1482
        self._delay = delay
1450
1498
                Crossfade time between old and new input. Defaults to 0.05.
1451
1499
 
1452
1500
        """
 
1501
        pyoArgsAssert(self, "oN", x, fadetime)
1453
1502
        self._input = x
1454
1503
        self._in_fader.setInput(x, fadetime)
1455
1504
 
1463
1512
                New `delay` attribute.
1464
1513
 
1465
1514
        """
 
1515
        pyoArgsAssert(self, "O", x)
1466
1516
        self._delay = x
1467
1517
        x, lmax = convertArgsToLists(x)
1468
1518
        [obj.setDelay(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1477
1527
                New `feedback` attribute.
1478
1528
 
1479
1529
        """
 
1530
        pyoArgsAssert(self, "O", x)
1480
1531
        self._feedback = x
1481
1532
        x, lmax = convertArgsToLists(x)
1482
1533
        [obj.setFeedback(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1540
1591
 
1541
1592
    """
1542
1593
    def __init__(self, input, freq=1000, bw=100, mul=1, add=0):
 
1594
        pyoArgsAssert(self, "oOOOO", input, freq, bw, mul, add)
1543
1595
        PyoObject.__init__(self, mul, add)
1544
1596
        self._input = input
1545
1597
        self._freq = freq
1560
1612
                Crossfade time between old and new input. Defaults to 0.05.
1561
1613
 
1562
1614
        """
 
1615
        pyoArgsAssert(self, "oN", x, fadetime)
1563
1616
        self._input = x
1564
1617
        self._in_fader.setInput(x, fadetime)
1565
1618
 
1573
1626
                New `freq` attribute.
1574
1627
 
1575
1628
        """
 
1629
        pyoArgsAssert(self, "O", x)
1576
1630
        self._freq = x
1577
1631
        x, lmax = convertArgsToLists(x)
1578
1632
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1587
1641
                New `bw` attribute.
1588
1642
 
1589
1643
        """
 
1644
        pyoArgsAssert(self, "O", x)
1590
1645
        self._bw = x
1591
1646
        x, lmax = convertArgsToLists(x)
1592
1647
        [obj.setBw(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1654
1709
 
1655
1710
    """
1656
1711
    def __init__(self, input, freq=1000, spread=1.1, q=10, feedback=0, num=8, mul=1, add=0):
 
1712
        pyoArgsAssert(self, "oOOOOiOO", input, freq, spread, q, feedback, num, mul, add)
1657
1713
        PyoObject.__init__(self, mul, add)
1658
1714
        self._input = input
1659
1715
        self._freq = freq
1677
1733
                Crossfade time between old and new input. Defaults to 0.05.
1678
1734
 
1679
1735
        """
 
1736
        pyoArgsAssert(self, "oN", x, fadetime)
1680
1737
        self._input = x
1681
1738
        self._in_fader.setInput(x, fadetime)
1682
1739
 
1690
1747
                New `freq` attribute.
1691
1748
 
1692
1749
        """
 
1750
        pyoArgsAssert(self, "O", x)
1693
1751
        self._freq = x
1694
1752
        x, lmax = convertArgsToLists(x)
1695
1753
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1704
1762
                New `spread` attribute.
1705
1763
 
1706
1764
        """
 
1765
        pyoArgsAssert(self, "O", x)
1707
1766
        self._spread = x
1708
1767
        x, lmax = convertArgsToLists(x)
1709
1768
        [obj.setSpread(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1718
1777
                New `q` attribute.
1719
1778
 
1720
1779
        """
 
1780
        pyoArgsAssert(self, "O", x)
1721
1781
        self._q = x
1722
1782
        x, lmax = convertArgsToLists(x)
1723
1783
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1732
1792
                New `feedback` attribute.
1733
1793
 
1734
1794
        """
 
1795
        pyoArgsAssert(self, "O", x)
1735
1796
        self._feedback = x
1736
1797
        x, lmax = convertArgsToLists(x)
1737
1798
        [obj.setFeedback(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1833
1894
 
1834
1895
    """
1835
1896
    def __init__(self, input, input2, freq=60, spread=1.25, q=20, slope=0.5, stages=24, mul=1, add=0):
 
1897
        pyoArgsAssert(self, "ooOOOOiOO", input, input2, freq, spread, q, slope, stages, mul, add)
1836
1898
        PyoObject.__init__(self, mul, add)
1837
1899
        self._input = input
1838
1900
        self._input2 = input2
1858
1920
                Crossfade time between old and new input. Defaults to 0.05.
1859
1921
 
1860
1922
        """
 
1923
        pyoArgsAssert(self, "oN", x, fadetime)
1861
1924
        self._input = x
1862
1925
        self._in_fader.setInput(x, fadetime)
1863
1926
 
1873
1936
                Crossfade time between old and new input. Defaults to 0.05.
1874
1937
 
1875
1938
        """
 
1939
        pyoArgsAssert(self, "oN", x, fadetime)
1876
1940
        self._input2 = x
1877
1941
        self._in_fader2.setInput(x, fadetime)
1878
1942
 
1886
1950
                New `freq` attribute.
1887
1951
 
1888
1952
        """
 
1953
        pyoArgsAssert(self, "O", x)
1889
1954
        self._freq = x
1890
1955
        x, lmax = convertArgsToLists(x)
1891
1956
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1900
1965
                New `spread` attribute.
1901
1966
 
1902
1967
        """
 
1968
        pyoArgsAssert(self, "O", x)
1903
1969
        self._spread = x
1904
1970
        x, lmax = convertArgsToLists(x)
1905
1971
        [obj.setSpread(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1914
1980
                New `q` attribute.
1915
1981
 
1916
1982
        """
 
1983
        pyoArgsAssert(self, "O", x)
1917
1984
        self._q = x
1918
1985
        x, lmax = convertArgsToLists(x)
1919
1986
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1928
1995
                New `slope` attribute.
1929
1996
 
1930
1997
        """
 
1998
        pyoArgsAssert(self, "O", x)
1931
1999
        self._slope = x
1932
2000
        x, lmax = convertArgsToLists(x)
1933
2001
        [obj.setSlope(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
1942
2010
                New `stages` attribute.
1943
2011
 
1944
2012
        """
 
2013
        pyoArgsAssert(self, "i", x)
1945
2014
        self._stages = x
1946
2015
        x, lmax = convertArgsToLists(x)
1947
2016
        [obj.setStages(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2055
2124
 
2056
2125
    """
2057
2126
    def __init__(self, input, freq=1000, bw=500, type=0, order=256, mul=1, add=0):
 
2127
        pyoArgsAssert(self, "oOOiiOO", input, freq, bw, type, order, mul, add)
2058
2128
        PyoObject.__init__(self, mul, add)
2059
2129
        self._input = input
2060
2130
        self._freq = freq
2080
2150
                Crossfade time between old and new input. Default to 0.05.
2081
2151
 
2082
2152
        """
 
2153
        pyoArgsAssert(self, "oN", x, fadetime)
2083
2154
        self._input = x
2084
2155
        self._in_fader.setInput(x, fadetime)
2085
2156
 
2093
2164
                New `freq` attribute.
2094
2165
 
2095
2166
        """
 
2167
        pyoArgsAssert(self, "O", x)
2096
2168
        self._freq = x
2097
2169
        x, lmax = convertArgsToLists(x)
2098
2170
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2107
2179
                New `bw` attribute.
2108
2180
 
2109
2181
        """
 
2182
        pyoArgsAssert(self, "O", x)
2110
2183
        self._bw = x
2111
2184
        x, lmax = convertArgsToLists(x)
2112
2185
        [obj.setBandwidth(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2125
2198
                3. bandpass
2126
2199
 
2127
2200
        """
 
2201
        pyoArgsAssert(self, "i", x)
2128
2202
        self._type = x
2129
2203
        x, lmax = convertArgsToLists(x)
2130
2204
        [obj.setType(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2201
2275
 
2202
2276
    """
2203
2277
    def __init__(self, input, order=256, mul=1, add=0):
 
2278
        pyoArgsAssert(self, "oiOO", input, order, mul, add)
2204
2279
        PyoObject.__init__(self, mul, add)
2205
2280
        self._input = input
2206
2281
        if (order % 2) != 0:
2223
2298
                Crossfade time between old and new input. Default to 0.05.
2224
2299
 
2225
2300
        """
 
2301
        pyoArgsAssert(self, "oN", x, fadetime)
2226
2302
        self._input = x
2227
2303
        self._in_fader.setInput(x, fadetime)
2228
2304
 
2283
2359
 
2284
2360
    """
2285
2361
    def __init__(self, input, freq=500, bw=2500, type=0, order=256, mul=1, add=0):
 
2362
        pyoArgsAssert(self, "oOOiiOO", input, freq, bw, type, order, mul, add)
2286
2363
        PyoObject.__init__(self, mul, add)
2287
2364
        self._input = input
2288
2365
        self._freq = freq
2308
2385
                Crossfade time between old and new input. Default to 0.05.
2309
2386
 
2310
2387
        """
 
2388
        pyoArgsAssert(self, "oN", x, fadetime)
2311
2389
        self._input = x
2312
2390
        self._in_fader.setInput(x, fadetime)
2313
2391
 
2321
2399
                New `freq` attribute.
2322
2400
 
2323
2401
        """
 
2402
        pyoArgsAssert(self, "O", x)
2324
2403
        self._freq = x
2325
2404
        x, lmax = convertArgsToLists(x)
2326
2405
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2335
2414
                New `bw` attribute.
2336
2415
 
2337
2416
        """
 
2417
        pyoArgsAssert(self, "O", x)
2338
2418
        self._bw = x
2339
2419
        x, lmax = convertArgsToLists(x)
2340
2420
        [obj.setBandwidth(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2353
2433
                    3. Pulse (odd harmonics) & comb & lowpass
2354
2434
 
2355
2435
        """
 
2436
        pyoArgsAssert(self, "i", x)
2356
2437
        self._type = x
2357
2438
        x, lmax = convertArgsToLists(x)
2358
2439
        [obj.setType(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2437
2518
 
2438
2519
    """
2439
2520
    def __init__(self, input, carrier=1000, ratio=0.5, index=3, order=256, mul=1, add=0):
 
2521
        pyoArgsAssert(self, "oOOOiOO", input, carrier, ratio, index, order, mul, add)
2440
2522
        PyoObject.__init__(self, mul, add)
2441
2523
        self._input = input
2442
2524
        self._carrier = carrier
2462
2544
                Crossfade time between old and new input. Default to 0.05.
2463
2545
 
2464
2546
        """
 
2547
        pyoArgsAssert(self, "oN", x, fadetime)
2465
2548
        self._input = x
2466
2549
        self._in_fader.setInput(x, fadetime)
2467
2550
 
2475
2558
                New `carrier` attribute.
2476
2559
 
2477
2560
        """
 
2561
        pyoArgsAssert(self, "O", x)
2478
2562
        self._carrier = x
2479
2563
        x, lmax = convertArgsToLists(x)
2480
2564
        [obj.setCarrier(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2489
2573
                New `ratio` attribute.
2490
2574
 
2491
2575
        """
 
2576
        pyoArgsAssert(self, "O", x)
2492
2577
        self._ratio = x
2493
2578
        x, lmax = convertArgsToLists(x)
2494
2579
        [obj.setRatio(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2503
2588
                New `index` attribute.
2504
2589
 
2505
2590
        """
 
2591
        pyoArgsAssert(self, "O", x)
2506
2592
        self._index = x
2507
2593
        x, lmax = convertArgsToLists(x)
2508
2594
        [obj.setIndex(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2577
2663
 
2578
2664
    """
2579
2665
    def __init__(self, input, freq=1000, q=1, type=0, mul=1, add=0):
 
2666
        pyoArgsAssert(self, "oOOOOO", input, freq, q, type, mul, add)
2580
2667
        PyoObject.__init__(self, mul, add)
2581
2668
        self._input = input
2582
2669
        self._freq = freq
2598
2685
                Crossfade time between old and new input. Defaults to 0.05.
2599
2686
 
2600
2687
        """
 
2688
        pyoArgsAssert(self, "oN", x, fadetime)
2601
2689
        self._input = x
2602
2690
        self._in_fader.setInput(x, fadetime)
2603
2691
 
2612
2700
                New `freq` attribute.
2613
2701
 
2614
2702
        """
 
2703
        pyoArgsAssert(self, "O", x)
2615
2704
        self._freq = x
2616
2705
        x, lmax = convertArgsToLists(x)
2617
2706
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2626
2715
                New `q` attribute.
2627
2716
 
2628
2717
        """
 
2718
        pyoArgsAssert(self, "O", x)
2629
2719
        self._q = x
2630
2720
        x, lmax = convertArgsToLists(x)
2631
2721
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2643
2733
                New `type` attribute.
2644
2734
 
2645
2735
        """
 
2736
        pyoArgsAssert(self, "O", x)
2646
2737
        self._type = x
2647
2738
        x, lmax = convertArgsToLists(x)
2648
2739
        [obj.setType(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2709
2800
 
2710
2801
    """
2711
2802
    def __init__(self, input, size=10, mul=1, add=0):
 
2803
        pyoArgsAssert(self, "oiOO", input, size, mul, add)
2712
2804
        PyoObject.__init__(self, mul, add)
2713
2805
        self._input = input
2714
2806
        self._size = size
2728
2820
                Crossfade time between old and new input. Default to 0.05.
2729
2821
 
2730
2822
        """
 
2823
        pyoArgsAssert(self, "oN", x, fadetime)
2731
2824
        self._input = x
2732
2825
        self._in_fader.setInput(x, fadetime)
2733
2826
 
2741
2834
                New `size` attribute.
2742
2835
 
2743
2836
        """
 
2837
        pyoArgsAssert(self, "i", x)
2744
2838
        self._size = x
2745
2839
        x, lmax = convertArgsToLists(x)
2746
2840
        [obj.setSize(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2794
2888
 
2795
2889
    """
2796
2890
    def __init__(self, input, freq=1000, q=1, mul=1, add=0):
 
2891
        pyoArgsAssert(self, "oOOOO", input, freq, q, mul, add)
2797
2892
        PyoObject.__init__(self, mul, add)
2798
2893
        self._input = input
2799
2894
        self._freq = freq
2814
2909
                Crossfade time between old and new input. Defaults to 0.05.
2815
2910
 
2816
2911
        """
 
2912
        pyoArgsAssert(self, "oN", x, fadetime)
2817
2913
        self._input = x
2818
2914
        self._in_fader.setInput(x, fadetime)
2819
2915
 
2827
2923
                New `freq` attribute.
2828
2924
 
2829
2925
        """
 
2926
        pyoArgsAssert(self, "O", x)
2830
2927
        self._freq = x
2831
2928
        x, lmax = convertArgsToLists(x)
2832
2929
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2841
2938
                New `q` attribute.
2842
2939
 
2843
2940
        """
 
2941
        pyoArgsAssert(self, "O", x)
2844
2942
        self._q = x
2845
2943
        x, lmax = convertArgsToLists(x)
2846
2944
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2905
3003
 
2906
3004
    """
2907
3005
    def __init__(self, input, freq=1000, q=1, stages=4, mul=1, add=0):
 
3006
        pyoArgsAssert(self, "oOOiOO", input, freq, q, stages, mul, add)
2908
3007
        PyoObject.__init__(self, mul, add)
2909
3008
        self._input = input
2910
3009
        self._freq = freq
2926
3025
                Crossfade time between old and new input. Defaults to 0.05.
2927
3026
 
2928
3027
        """
 
3028
        pyoArgsAssert(self, "oN", x, fadetime)
2929
3029
        self._input = x
2930
3030
        self._in_fader.setInput(x, fadetime)
2931
3031
 
2939
3039
                New `freq` attribute.
2940
3040
 
2941
3041
        """
 
3042
        pyoArgsAssert(self, "O", x)
2942
3043
        self._freq = x
2943
3044
        x, lmax = convertArgsToLists(x)
2944
3045
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2953
3054
                New `q` attribute.
2954
3055
 
2955
3056
        """
 
3057
        pyoArgsAssert(self, "O", x)
2956
3058
        self._q = x
2957
3059
        x, lmax = convertArgsToLists(x)
2958
3060
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
2967
3069
                New `stages` attribute.
2968
3070
 
2969
3071
        """
 
3072
        pyoArgsAssert(self, "i", x)
2970
3073
        self._stages = x
2971
3074
        x, lmax = convertArgsToLists(x)
2972
3075
        [obj.setStages(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
3028
3131
 
3029
3132
    """
3030
3133
    def __init__(self, input, freq=1000, mul=1, add=0):
 
3134
        pyoArgsAssert(self, "oOOO", input, freq, mul, add)
3031
3135
        PyoObject.__init__(self, mul, add)
3032
3136
        self._input = input
3033
3137
        self._freq = freq
3047
3151
                Crossfade time between old and new input. Default to 0.05.
3048
3152
 
3049
3153
        """
 
3154
        pyoArgsAssert(self, "oN", x, fadetime)
3050
3155
        self._input = x
3051
3156
        self._in_fader.setInput(x, fadetime)
3052
3157
 
3060
3165
                New `freq` attribute.
3061
3166
 
3062
3167
        """
 
3168
        pyoArgsAssert(self, "O", x)
3063
3169
        self._freq = x
3064
3170
        x, lmax = convertArgsToLists(x)
3065
3171
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
3107
3213
 
3108
3214
    """
3109
3215
    def __init__(self, input, freq=1000, mul=1, add=0):
 
3216
        pyoArgsAssert(self, "oOOO", input, freq, mul, add)
3110
3217
        PyoObject.__init__(self, mul, add)
3111
3218
        self._input = input
3112
3219
        self._freq = freq
3126
3233
                Crossfade time between old and new input. Default to 0.05.
3127
3234
 
3128
3235
        """
 
3236
        pyoArgsAssert(self, "oN", x, fadetime)
3129
3237
        self._input = x
3130
3238
        self._in_fader.setInput(x, fadetime)
3131
3239
 
3139
3247
                New `freq` attribute.
3140
3248
 
3141
3249
        """
 
3250
        pyoArgsAssert(self, "O", x)
3142
3251
        self._freq = x
3143
3252
        x, lmax = convertArgsToLists(x)
3144
3253
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
3189
3298
 
3190
3299
    """
3191
3300
    def __init__(self, input, freq=1000, q=1, mul=1, add=0):
 
3301
        pyoArgsAssert(self, "oOOOO", input, freq, q, mul, add)
3192
3302
        PyoObject.__init__(self, mul, add)
3193
3303
        self._input = input
3194
3304
        self._freq = freq
3209
3319
                Crossfade time between old and new input. Defaults to 0.05.
3210
3320
 
3211
3321
        """
 
3322
        pyoArgsAssert(self, "oN", x, fadetime)
3212
3323
        self._input = x
3213
3324
        self._in_fader.setInput(x, fadetime)
3214
3325
 
3222
3333
                New `freq` attribute.
3223
3334
 
3224
3335
        """
 
3336
        pyoArgsAssert(self, "O", x)
3225
3337
        self._freq = x
3226
3338
        x, lmax = convertArgsToLists(x)
3227
3339
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
3236
3348
                New `q` attribute.
3237
3349
 
3238
3350
        """
 
3351
        pyoArgsAssert(self, "O", x)
3239
3352
        self._q = x
3240
3353
        x, lmax = convertArgsToLists(x)
3241
3354
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
3294
3407
 
3295
3408
    """
3296
3409
    def __init__(self, input, freq=1000, q=1, mul=1, add=0):
 
3410
        pyoArgsAssert(self, "oOOOO", input, freq, q, mul, add)
3297
3411
        PyoObject.__init__(self, mul, add)
3298
3412
        self._input = input
3299
3413
        self._freq = freq
3314
3428
                Crossfade time between old and new input. Defaults to 0.05.
3315
3429
 
3316
3430
        """
 
3431
        pyoArgsAssert(self, "oN", x, fadetime)
3317
3432
        self._input = x
3318
3433
        self._in_fader.setInput(x, fadetime)
3319
3434
 
3327
3442
                New `freq` attribute.
3328
3443
 
3329
3444
        """
 
3445
        pyoArgsAssert(self, "O", x)
3330
3446
        self._freq = x
3331
3447
        x, lmax = convertArgsToLists(x)
3332
3448
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
3341
3457
                New `q` attribute.
3342
3458
 
3343
3459
        """
 
3460
        pyoArgsAssert(self, "O", x)
3344
3461
        self._q = x
3345
3462
        x, lmax = convertArgsToLists(x)
3346
3463
        [obj.setQ(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
3400
3517
 
3401
3518
    """
3402
3519
    def __init__(self, input, freq=1000, decay=.25, mul=1, add=0):
 
3520
        pyoArgsAssert(self, "oOOOO", input, freq, decay, mul, add)
3403
3521
        PyoObject.__init__(self, mul, add)
3404
3522
        self._input = input
3405
3523
        self._freq = freq
3420
3538
                Crossfade time between old and new input. Defaults to 0.05.
3421
3539
 
3422
3540
        """
 
3541
        pyoArgsAssert(self, "oN", x, fadetime)
3423
3542
        self._input = x
3424
3543
        self._in_fader.setInput(x, fadetime)
3425
3544
 
3433
3552
                New `freq` attribute.
3434
3553
 
3435
3554
        """
 
3555
        pyoArgsAssert(self, "O", x)
3436
3556
        self._freq = x
3437
3557
        x, lmax = convertArgsToLists(x)
3438
3558
        [obj.setFreq(wrap(x,i)) for i, obj in enumerate(self._base_objs)]
3447
3567
                New `decay` attribute.
3448
3568
 
3449
3569
        """
 
3570
        pyoArgsAssert(self, "O", x)
3450
3571
        self._decay = x
3451
3572
        x, lmax = convertArgsToLists(x)
3452
3573
        [obj.setDecay(wrap(x,i)) for i, obj in enumerate(self._base_objs)]