gnuradio.gr: Mathematics

gnuradio.gr.conjugate_cc() → gr_conjugate_cc_sptr

output = complex conjugate of input

gnuradio.gr.nlog10_ff(float n = 1.0, unsigned int vlen = 1, float k = 0) → gr_nlog10_ff_sptr

output = n*log10(input) + k

gnuradio.gr.rms_cf(double alpha = 0.0001) → gr_rms_cf_sptr

RMS average power.

gr_rms_cf_sptr.set_alpha(self, double alpha)

gr_rms_cf_sptr.unmuted(self) → bool

gnuradio.gr.rms_ff(double alpha = 0.0001) → gr_rms_ff_sptr

RMS average power.

gr_rms_ff_sptr.set_alpha(self, double alpha)

gr_rms_ff_sptr.unmuted(self) → bool

gnuradio.gr.add_cc(size_t vlen = 1) → gr_add_cc_sptr

output = sum (input_0, input_1, ...)

Add across all input streams.

gnuradio.gr.add_const_cc(gr_complex k) → gr_add_const_cc_sptr

output = input + constant

gr_add_const_cc_sptr.k(self) → gr_complex

gr_add_const_cc_sptr.set_k(self, gr_complex k)

gnuradio.gr.add_const_ff(float k) → gr_add_const_ff_sptr

output = input + constant

gr_add_const_ff_sptr.k(self) → float

gr_add_const_ff_sptr.set_k(self, float k)

gnuradio.gr.add_const_ii(int k) → gr_add_const_ii_sptr

output = input + constant

gr_add_const_ii_sptr.k(self) → int

gr_add_const_ii_sptr.set_k(self, int k)

gnuradio.gr.add_const_sf(short k) → gr_add_const_sf_sptr

output = input + constant

gr_add_const_sf_sptr.k(self) → short

gr_add_const_sf_sptr.set_k(self, short k)

gnuradio.gr.add_const_ss(short k) → gr_add_const_ss_sptr

output = input + constant

gr_add_const_ss_sptr.k(self) → short

gr_add_const_ss_sptr.set_k(self, short k)

gnuradio.gr.add_const_vcc(std::vector<(gr_complex, std::allocator<(gr_complex)>)> k) → gr_add_const_vcc_sptr

output vector = input vector + constant vector

gr_add_const_vcc_sptr.k(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>

gr_add_const_vcc_sptr.set_k(self, std::vector<(gr_complex, std::allocator<(gr_complex)>)> k)

gnuradio.gr.add_const_vff(__dummy_4__ k) → gr_add_const_vff_sptr

output vector = input vector + constant vector

gr_add_const_vff_sptr.k(self) → __dummy_4__

gr_add_const_vff_sptr.set_k(self, __dummy_4__ k)

gnuradio.gr.add_const_vii(__dummy_3__ k) → gr_add_const_vii_sptr

output vector = input vector + constant vector

gr_add_const_vii_sptr.k(self) → __dummy_3__

gr_add_const_vii_sptr.set_k(self, __dummy_3__ k)

gnuradio.gr.add_const_vss(__dummy_2__ k) → gr_add_const_vss_sptr

output vector = input vector + constant vector

gr_add_const_vss_sptr.k(self) → __dummy_2__

gr_add_const_vss_sptr.set_k(self, __dummy_2__ k)

gnuradio.gr.add_ff(size_t vlen = 1) → gr_add_ff_sptr

Add streams of complex values.

gnuradio.gr.add_ii(size_t vlen = 1) → gr_add_ii_sptr

output = sum (input_0, input_1, ...)

Add across all input streams.

gnuradio.gr.add_ss(size_t vlen = 1) → gr_add_ss_sptr

output = sum (input_0, input_1, ...)

Add across all input streams.

gnuradio.gr.and_bb() → gr_and_bb_sptr

output = input_0 & input_1 & , ... & input_N)

bitwise boolean and across all input streams.

gnuradio.gr.and_const_bb(unsigned char k) → gr_and_const_bb_sptr

output_N = input_N & value

bitwise boolean and of const to the data stream.

gr_and_const_bb_sptr.k(self) → unsigned char

gr_and_const_bb_sptr.set_k(self, unsigned char k)

gnuradio.gr.and_const_ii(int k) → gr_and_const_ii_sptr

output_N = input_N & value

bitwise boolean and of const to the data stream.

gr_and_const_ii_sptr.k(self) → int

gr_and_const_ii_sptr.set_k(self, int k)

gnuradio.gr.and_const_ss(short k) → gr_and_const_ss_sptr

output_N = input_N & value

bitwise boolean and of const to the data stream.

gr_and_const_ss_sptr.k(self) → short

gr_and_const_ss_sptr.set_k(self, short k)

gnuradio.gr.and_ii() → gr_and_ii_sptr

output = input_0 & input_1 & , ... & input_N)

bitwise boolean and across all input streams.

gnuradio.gr.and_ss() → gr_and_ss_sptr

output = input_0 & input_1 & , ... & input_N)

bitwise boolean and across all input streams.

gnuradio.gr.divide_cc(size_t vlen = 1) → gr_divide_cc_sptr

output = input_0 / input_1 / input_x ...)

Divide across all input streams.

gnuradio.gr.divide_ff(size_t vlen = 1) → gr_divide_ff_sptr

output = input_0 / input_1 / input_x ...)

Divide across all input streams.

gnuradio.gr.divide_ii(size_t vlen = 1) → gr_divide_ii_sptr

output = input_0 / input_1 / input_x ...)

Divide across all input streams.

gnuradio.gr.divide_ss(size_t vlen = 1) → gr_divide_ss_sptr

output = input_0 / input_1 / input_x ...)

Divide across all input streams.

gnuradio.gr.integrate_cc(int decim) → gr_integrate_cc_sptr

output = sum(input[0]...input[n])

Integrate successive samples in input stream and decimate

gnuradio.gr.integrate_ff(int decim) → gr_integrate_ff_sptr

output = sum(input[0]...input[n])

Integrate successive samples in input stream and decimate

gnuradio.gr.integrate_ii(int decim) → gr_integrate_ii_sptr

output = sum(input[0]...input[n])

Integrate successive samples in input stream and decimate

gnuradio.gr.integrate_ss(int decim) → gr_integrate_ss_sptr

output = sum(input[0]...input[n])

Integrate successive samples in input stream and decimate

gnuradio.gr.multiply_cc(size_t vlen = 1) → gr_multiply_cc_sptr

Multiply streams of complex values.

gnuradio.gr.multiply_const_cc(gr_complex k, size_t vlen = 1) → gr_multiply_const_cc_sptr

Multiply stream of complex values with a constant .

gr_multiply_const_cc_sptr.k(self) → gr_complex

gr_multiply_const_cc_sptr.set_k(self, gr_complex k)

gnuradio.gr.multiply_const_ff(float k, size_t vlen = 1) → gr_multiply_const_ff_sptr

Multiply stream of float values with a constant .

gr_multiply_const_ff_sptr.k(self) → float

gr_multiply_const_ff_sptr.set_k(self, float k)

gnuradio.gr.multiply_const_ii(int k) → gr_multiply_const_ii_sptr

output = input * constant

gr_multiply_const_ii_sptr.k(self) → int

gr_multiply_const_ii_sptr.set_k(self, int k)

gnuradio.gr.multiply_const_ss(short k) → gr_multiply_const_ss_sptr

output = input * constant

gr_multiply_const_ss_sptr.k(self) → short

gr_multiply_const_ss_sptr.set_k(self, short k)

gnuradio.gr.multiply_const_vcc(std::vector<(gr_complex, std::allocator<(gr_complex)>)> k) → gr_multiply_const_vcc_sptr

output vector = input vector * constant vector (element-wise)

gr_multiply_const_vcc_sptr.k(self) → std::vector<(gr_complex,std::allocator<(gr_complex)>)>

gr_multiply_const_vcc_sptr.set_k(self, std::vector<(gr_complex, std::allocator<(gr_complex)>)> k)

gnuradio.gr.multiply_const_vff(__dummy_4__ k) → gr_multiply_const_vff_sptr

output vector = input vector * constant vector (element-wise)

gr_multiply_const_vff_sptr.k(self) → __dummy_4__

gr_multiply_const_vff_sptr.set_k(self, __dummy_4__ k)

gnuradio.gr.multiply_const_vii(__dummy_3__ k) → gr_multiply_const_vii_sptr

output vector = input vector * constant vector (element-wise)

gr_multiply_const_vii_sptr.k(self) → __dummy_3__

gr_multiply_const_vii_sptr.set_k(self, __dummy_3__ k)

gnuradio.gr.multiply_const_vss(__dummy_2__ k) → gr_multiply_const_vss_sptr

output vector = input vector * constant vector (element-wise)

gr_multiply_const_vss_sptr.k(self) → __dummy_2__

gr_multiply_const_vss_sptr.set_k(self, __dummy_2__ k)

gnuradio.gr.multiply_ff(size_t vlen = 1) → gr_multiply_ff_sptr

Multiply streams of complex values.

gnuradio.gr.multiply_ii(size_t vlen = 1) → gr_multiply_ii_sptr

output = prod (input_0, input_1, ...)

Multiply across all input streams.

gnuradio.gr.multiply_ss(size_t vlen = 1) → gr_multiply_ss_sptr

output = prod (input_0, input_1, ...)

Multiply across all input streams.

gnuradio.gr.not_bb() → gr_not_bb_sptr

output = ~input_0

bitwise boolean not across input stream.

gnuradio.gr.not_ii() → gr_not_ii_sptr

output = ~input_0

bitwise boolean not across input stream.

gnuradio.gr.not_ss() → gr_not_ss_sptr

output = ~input_0

bitwise boolean not across input stream.

gnuradio.gr.or_bb() → gr_or_bb_sptr

output = input_0 | input_1 | , ... | input_N)

bitwise boolean or across all input streams.

gnuradio.gr.or_ii() → gr_or_ii_sptr

output = input_0 | input_1 | , ... | input_N)

bitwise boolean or across all input streams.

gnuradio.gr.or_ss() → gr_or_ss_sptr

output = input_0 | input_1 | , ... | input_N)

bitwise boolean or across all input streams.

gnuradio.gr.sub_cc(size_t vlen = 1) → gr_sub_cc_sptr

output = input_0 - input_1 - ...)

Subtract across all input streams.

gnuradio.gr.sub_ff(size_t vlen = 1) → gr_sub_ff_sptr

output = input_0 - input_1 - ...)

Subtract across all input streams.

gnuradio.gr.sub_ii(size_t vlen = 1) → gr_sub_ii_sptr

output = input_0 - input_1 - ...)

Subtract across all input streams.

gnuradio.gr.sub_ss(size_t vlen = 1) → gr_sub_ss_sptr

output = input_0 - input_1 - ...)

Subtract across all input streams.

gnuradio.gr.xor_bb() → gr_xor_bb_sptr

output = input_0 ^ input_1 ^ , ... ^ input_N)

bitwise boolean xor across all input streams.

gnuradio.gr.xor_ii() → gr_xor_ii_sptr

output = input_0 ^ input_1 ^ , ... ^ input_N)

bitwise boolean xor across all input streams.

gnuradio.gr.xor_ss() → gr_xor_ss_sptr

output = input_0 ^ input_1 ^ , ... ^ input_N)

bitwise boolean xor across all input streams.