# Set the version information here

set(VERSION_INFO_MAJOR_VERSION 3)

set(VERSION_INFO_API_COMPAT 7)

include(GrVersion) #setup version info

# Append -O2 optimization flag for Debug builds

# are normally passed to the compiler using the -I flag.

STRIP_FROM_INC_PATH = @CMAKE_SOURCE_DIR@/gnuradio-runtime/include \

@CMAKE_SOURCE_DIR@/gr-analog/include \

@CMAKE_SOURCE_DIR@/gr-atsc/include \

@CMAKE_SOURCE_DIR@/gr-audio/include \

@CMAKE_SOURCE_DIR@/gr-blocks/include \

@CMAKE_SOURCE_DIR@/gr-channels/include \

@CMAKE_SOURCE_DIR@/gr-comedi/include \

@CMAKE_SOURCE_DIR@/gr-digital/include \

@CMAKE_SOURCE_DIR@/gr-fcd/include \

@CMAKE_SOURCE_DIR@/gr-fec/include \

@CMAKE_SOURCE_DIR@/gr-fft/include \

@CMAKE_SOURCE_DIR@/gr-filter/include \

@CMAKE_SOURCE_DIR@/gr-noaa/include \

@CMAKE_SOURCE_DIR@/gr-pager/include \

@CMAKE_SOURCE_DIR@/gr-qtgui/include \

@CMAKE_SOURCE_DIR@/gr-trellis/include \

@CMAKE_SOURCE_DIR@/gr-uhd/include \

@CMAKE_SOURCE_DIR@/gr-video-sdl/include \

@CMAKE_SOURCE_DIR@/gr-vocoder/include \

@CMAKE_SOURCE_DIR@/gr-wxgui/include \

# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter

# (but less readable) file names. This can be useful if your file system

\section stream_tags_api Stream Tags API

The stream tags API consists of four functions, two to add and two to

\li gr::block::add_item_tag: Adds an item tag to a particular output port using a

gr::tag_t data type.

void add_item_tag(unsigned int which_output, const tag_t &tag);

/*!

*

* \param which_input an integer of which input stream to remove the tag from

* \param abs_offset a uint64 number of the absolute item number

}

/*!

*

* \param which_input an integer of which input stream to remove the tag from

* \param tag the tag object to remove

#include <gnuradio/tags.h>

#include <boost/weak_ptr.hpp>

#include <gnuradio/thread/thread.h>

namespace gr {

*/

void prune_tags(uint64_t max_time);

// -------------------------------------------------------------------------

unsigned int d_write_index; // in items [0,d_bufsize)

uint64_t d_abs_write_offset; // num items written since the start

bool d_done;

uint64_t d_last_min_items_read;

unsigned index_add(unsigned a, unsigned b)

//! Return the pmt value that represents double \p x.

PMT_API pmt_t from_double(double x);

/*!

* \brief Convert pmt to double if possible.

*/

PMT_API double to_double(pmt_t x);

/*

* ------------------------------------------------------------------------

* Complex

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <gnuradio/buffer.h>

#include <gnuradio/math.h>

#include "vmcircbuf.h"

buffer::add_item_tag(const tag_t &tag)

{

gr::thread::scoped_lock guard(*mutex());

}

void

buffer::remove_item_tag(const tag_t &tag, long id)

{

gr::thread::scoped_lock guard(*mutex());

}

}

}

If this function is used elsewhere, remember to lock the

buffer's mutex al la the scoped_lock line below.

*/

}

long

buffer_reader::get_tags_in_range(std::vector<tag_t> &v,

uint64_t abs_start,

uint64_t abs_end,

{

gr::thread::scoped_lock guard(*mutex());

v.resize(0);

uint64_t item_time;

if((item_time >= abs_start) && (item_time < abs_end)) {

// If id is not in the vector of marked blocks

t.offset += d_attr_delay;

}

itr++;

}

}

return pmt_t(new pmt_real(x));

}

double

to_double(pmt_t x)

{

throw wrong_type("pmt_to_double", x);

}

////////////////////////////////////////////////////////////////////////////

// Complex

////////////////////////////////////////////////////////////////////////////

CPPUNIT_ASSERT_EQUAL(-1.0, pmt::to_double(m1));

CPPUNIT_ASSERT_EQUAL(1.0, pmt::to_double(p1));

CPPUNIT_ASSERT_EQUAL(1.0, pmt::to_double(pmt::from_long(1)));

}

void

tag.srcid = tag_struct[3]

good = True

if(good):

return tag

else:

return None

const = 123765

x_pmt = pmt.from_double(const)

x_int = pmt.to_double(x_pmt)

self.assertEqual(x_int, const)

def test03(self):

v = pmt.init_f32vector(3, [11, -22, 33])

bool is_real(pmt_t obj);

pmt_t from_double(double x);

double to_double(pmt_t x);

bool is_complex(pmt_t obj);

pmt_t make_rectangular(double re, double im);

# the Free Software Foundation, Inc., 51 Franklin Street,

# Boston, MA 02110-1301, USA.

add_subdirectory(metadata)

add_subdirectory(tags)

<name>Abs</name>

<key>blocks_abs_xx</key>

<import>from gnuradio import blocks</import>

<param>

<name>IO Type</name>

<key>type</key>

<opt>fcn:ff</opt>

</option>

</param>

<sink>

<name>in</name>

<type>$type</type>

</sink>

<source>

<name>out</name>

<type>$type</type>

</source>

</block>

<source>

<name>pdus</name>

<type>message</type>

</source>

</block>

/*!

* \brief Create an instance of @NAME@

*/

};

} /* namespace blocks */

namespace gr {

namespace blocks {

{

}

: sync_block ("@NAME@",

{

}

@I_TYPE@ *iptr = (@I_TYPE@ *) input_items[0];

@O_TYPE@ *optr = (@O_TYPE@ *) output_items[0];

@I_TYPE@ val = iptr[i];

optr[i] = ((val < ((@I_TYPE@)0)) ? -val : val);

}

class BLOCKS_API @NAME_IMPL@ : public @NAME@

{

public:

int work(int noutput_items,

gr_vector_const_void_star &input_items,

io_signature::make (1, io_signature::IO_INFINITE, itemsize)),

d_itemsize(itemsize), d_blocksize(blocksize), d_current_output(0)

{

set_output_multiple(blocksize);

}

bool

deinterleave_impl::check_topology(int ninputs, int noutputs)

{

d_noutputs = noutputs;

return true;

}

const char *in = (const char*)input_items[0];

char **out = (char**)&output_items[0];

return WORK_CALLED_PRODUCE;

}

unsigned int d_blocksize;

unsigned int d_current_output;

unsigned int d_noutputs;

public:

deinterleave_impl(size_t itemsize, unsigned int blocksize);

bool check_topology(int ninputs, int noutputs);

int general_work(int noutput_items,

message_strobe_impl::message_strobe_impl(pmt::pmt_t msg, float period_ms)

: block("message_strobe",

d_finished(false),

d_period_ms(period_ms),

d_msg(msg)

{

message_port_register_out(pmt::mp("strobe"));

message_port_register_in(pmt::mp("set_msg"));

set_msg_handler(pmt::mp("set_msg"),

class BLOCKS_API message_strobe_impl : public message_strobe

{

private:

bool d_finished;

float d_period_ms;

pmt::pmt_t d_msg;

// set up ports

message_port_register_out(pmt::mp("strobe"));

message_port_register_in(pmt::mp("set_msg"));

set_msg_handler(pmt::mp("set_msg"),

class BLOCKS_API message_strobe_random_impl : public message_strobe_random

{

private:

bool d_finished;

float d_mean_ms;

float d_std_ms;

#include <gnuradio/blocks/annotator_alltoall.h>

#include <gnuradio/blocks/annotator_1to1.h>

#include <gnuradio/blocks/keep_one_in_n.h>

// ----------------------------------------------------------------

// set to 1 to turn on debug output

// The debug output fully checks that the tags seen are what are expected. While

// that the tags will be coming in this specific order, so it's dangerous to

// rely on this as a test of the tag system working. We would really want to

// tags we know we should see and then test that they all occur once, but in no

// particular order.

#define QA_TAGS_DEBUG 0

void

qa_block_tags::t0()

{

tb->connect(src, 0, head, 0);

tb->connect(head, 0, snk, 0);

CPPUNIT_ASSERT_EQUAL(src->nitems_read(0), (uint64_t)0);

CPPUNIT_ASSERT_EQUAL(src->nitems_written(0), (uint64_t)0);

str1 << ann1->name() << ann1->unique_id();

str2 << ann2->name() << ann2->unique_id();

std::cout << std::endl << "qa_block_tags::t1" << std::endl;

// For annotator 3, we know it gets tags from ann0 and ann1, test this

for(size_t i = 0; i < tags3.size(); i++) {

std::cout << "tags3[" << i << "] = " << tags3[i] << "\t\t" << expected_tags3[i] << std::endl;

}

// For annotator 4, we know it gets tags from ann0 and ann2, test this

std::cout << std::endl;

for(size_t i = 0; i < tags4.size(); i++) {

std::cout << "tags4[" << i << "] = " << tags4[i] << "\t\t" << expected_tags4[i] << std::endl;

}

#endif

}

str0 << ann0->name() << ann0->unique_id();

str1 << ann1->name() << ann1->unique_id();

std::cout << std::endl << "qa_block_tags::t2" << std::endl;

// inconceivable for ann3 to have it wrong.

for(size_t i = 0; i < tags2.size(); i++) {

std::cout << "tags2[" << i << "] = " << tags2[i] << "\t\t" << expected_tags2[i] << std::endl;

}

std::cout << std::endl;

for(size_t i = 0; i < tags4.size(); i++) {

std::cout << "tags2[" << i << "] = " << tags4[i] << "\t\t" << expected_tags4[i] << std::endl;

}

#endif

}

str1 << ann1->name() << ann1->unique_id();

str2 << ann2->name() << ann2->unique_id();

std::cout << std::endl << "qa_block_tags::t3" << std::endl;

// For annotator 3, we know it gets tags from ann0 and ann1, test this

for(size_t i = 0; i < tags3.size(); i++) {

std::cout << "tags3[" << i << "] = " << tags3[i] << "\t\t" << expected_tags3[i] << std::endl;

}

// For annotator 4, we know it gets tags from ann0 and ann2, test this

std::cout << std::endl;

for(size_t i = 0; i < tags4.size(); i++) {

std::cout << "tags4[" << i << "] = " << tags4[i] << "\t\t" << expected_tags4[i] << std::endl;

}

#endif

}

str1 << ann1->name() << ann1->unique_id();

str2 << ann2->name() << ann2->unique_id();

std::cout << std::endl << "qa_block_tags::t5" << std::endl;

std::cout << "tags1.size(): " << tags1.size() << std::endl;

for(size_t i = 0; i < tags1.size(); i++) {

std::cout << "tags1[" << i << "] = " << tags1[i] << "\t\t" << expected_tags1[i] << std::endl;

}

// annotator 2 gets tags from annotators 0 and 1

std::cout << "tags2.size(): " << tags2.size() << std::endl;

for(size_t i = 0; i < tags2.size(); i++) {

std::cout << "tags2[" << i << "] = " << tags2[i] << "\t\t" << expected_tags2[i] << std::endl;

}

#endif

}

{

}

void

throttle_impl::set_sample_rate(double rate)

{

throttle_impl(size_t itemsize, double samples_per_sec, bool ignore_tags=true);

~throttle_impl();

void setup_rpc();

void set_sample_rate(double rate);

optr += size;

for(unsigned t = 0; t < d_tags.size(); t++) {

add_item_tag(0, nitems_written(0)+i+d_tags[t].offset,

}

}

}

/*!

* \param equalizer The equalizer object that will do the actual work

* \param cp_len Length of the cyclic prefix in samples (required to correct the frequency offset)

* \param propagate_channel_state If true, the channel state after the last symbol

* will be added to the first symbol as a tag

*/

static sptr make(

);

};

/* -*- c++ -*- */

*

* This file is part of GNU Radio

*

}

}

if (d_uses_trigger_tag) {

}

return -1;

} /* find_trigger_signal() */

// Copy tags

std::vector<tag_t> tags;

get_tags_in_range(

);

}

} /* copy_n_symbols() */

#define M_TWOPI (2*M_PI)

namespace gr {

namespace digital {

ofdm_frame_equalizer_vcvc::make(

ofdm_equalizer_base::sptr equalizer,

int cp_len,

bool propagate_channel_state,

int fixed_frame_len

)

{

return gnuradio::get_initial_sptr (

new ofdm_frame_equalizer_vcvc_impl(

)

);

}

ofdm_frame_equalizer_vcvc_impl::ofdm_frame_equalizer_vcvc_impl(

ofdm_equalizer_base::sptr equalizer,

int cp_len,

bool propagate_channel_state,

int fixed_frame_len

) : tagged_stream_block("ofdm_frame_equalizer_vcvc",

io_signature::make(1, 1, sizeof (gr_complex) * equalizer->fft_len()),

io_signature::make(1, 1, sizeof (gr_complex) * equalizer->fft_len()),

d_fft_len(equalizer->fft_len()),

d_cp_len(cp_len),

d_eq(equalizer),

d_fixed_frame_len(fixed_frame_len),

d_channel_state(equalizer->fft_len(), gr_complex(1, 0))

{

}

if (d_fixed_frame_len < 0) {

}

if (d_fixed_frame_len) {

}

set_relative_rate(1.0);

}

ofdm_frame_equalizer_vcvc_impl::~ofdm_frame_equalizer_vcvc_impl()

void

ofdm_frame_equalizer_vcvc_impl::parse_length_tags(

if (d_fixed_frame_len) {

} else {

}

}

}

std::vector<tag_t> tags;

for (unsigned i = 0; i < tags.size(); i++) {

}

// Copy the frame and the channel state vector such that the symbols are shifted to the correct position

// Update the channel state regarding the frequency offset

phase_correction = gr_expj(M_TWOPI * carrier_offset * d_cp_len / d_fft_len * frame_len);

for (int k = 0; k < d_fft_len; k++) {

}

// Housekeeping

/* -*- c++ -*- */

*

* This file is part of GNU Radio

*

std::vector<tag_t> tags;

// Packet mode

if (!d_length_tag_key_str.empty()) {

} else {

}

// Copy symbols

int n_out_symbols = 0;

for (int i = 0; i < frame_length; i++) {

}

// Housekeeping

if (d_length_tag_key_str.empty()) {

} else {

}

return n_out_symbols;

]

self.assertEqual(expected_tags_payload, ptags_payload)

def test_002_symbols (self):

"""

Same as before, but operate on symbols

ptag = gr.tag_to_python(tag)

tag_dict[ptag.key] = ptag.value

expected_dict = {

}

self.assertEqual(tag_dict, expected_dict)

noutput_items/(output_multiple() - d_decoder->get_history()) :

innum;

for(int i = 0; i < items; ++i) {

d_decoder->generic_work((void*)(in+(i*d_decoder->get_input_size()*d_input_item_size)),

int consumed = static_cast<int>(items/relative_rate()*(output_multiple() - d_decoder->get_history()) + 0.5);

int returned = items*(output_multiple() - d_decoder->get_history());

consume_each(consumed);

return returned;

char *inbuffer = (char*)input_items[0];

char *outbuffer = (char*)output_items[0];

for(int i = 0; i < noutput_items/output_multiple(); i++) {

(void*)(outbuffer+(i*d_output_size)));

}

consume_each(fixed_rate_noutput_to_ninput(noutput_items));

return noutput_items;

{

bool clocks_locked = true;

for (size_t mboard_index = 0; mboard_index < _dev->get_num_mboards(); mboard_index++) {

std::string sensor_name = "ref_locked";

if (_dev->get_clock_source(mboard_index) == "internal") {

}

}

return clocks_locked;

}

{

bool clocks_locked = true;

for (size_t mboard_index = 0; mboard_index < _dev->get_num_mboards(); mboard_index++) {

std::string sensor_name = "ref_locked";

if (_dev->get_clock_source(mboard_index) == "internal") {

}

}

return clocks_locked;

}

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA

"""

from . import odict

from Element import Element

from .. gui import Messages

from . Constants import FLOW_GRAPH_FILE_FORMAT_VERSION

class FlowGraph(Element):

def __init__(self, platform):

"""

#initialize

Element.__init__(self, platform)

#inital blank import

self.import_data()

"""

index = 0

while True:

#make sure that the id is not used by another block

if not filter(lambda b: b.get_id() == id, self.get_blocks()): return id

def rewrite(self):

def refactor_bus_structure():

Returns:

a nested data odict

"""

n = odict()

n['block'] = [block.export_data() for block in self.get_blocks()]

n['connection'] = [connection.export_data() for connection in self.get_connections()]

instructions = odict({

file_format = 0

#use blank data if none provided

fg_n = n and n.find('flow_graph') or odict()

blocks_n = fg_n.findall('block')

connections_n = fg_n.findall('connection')

#create option block

"""

block._key = block_n.find('key')

block.is_dummy_block = lambda: True

block.get_enabled = lambda: False

for param_n in block_n.findall('param'):

if param_n['key'] not in block.get_param_keys():

def _dummy_block_add_port(block, key, dir):

port_n = odict({'name': '?', 'key': key, 'type': ''})

port = block.get_parent().get_parent().Port(block=block, n=port_n, dir=dir)

if port.is_source():

<param>

<name>Generate Options</name>

<key>generate_options</key>

<type>enum</type>

<option>

<name>QT GUI</name>

<key>qt_gui</key>

</option>

<option>

<name>No GUI</name>

<key>no_gui</key>

</option>

ExecFlowGraphThread(self)

elif action == Actions.FLOW_GRAPH_KILL:

if self.get_page().get_proc():

pass

elif action == Actions.RELOAD_BLOCKS:

self.platform.load_blocks()

sensitive = self.get_flow_graph().is_valid() and not self.get_page().get_proc()

Actions.FLOW_GRAPH_GEN.set_sensitive(sensitive)

Actions.FLOW_GRAPH_EXEC.set_sensitive(sensitive)

class ExecFlowGraphThread(Thread):

"""Execute the flow graph as a new process and wait on it to finish."""

"""

#handle completion

r = "\n"

gobject.idle_add(Messages.send_verbose_exec, r)

r = os.read(self.p.stdout.fileno(), 1024)

gobject.idle_add(self.done)

def done(self):

"""Perform end of execution tasks."""

self.page.set_proc(None)

self.update_exec_stop()

from Constants import \

BLOCK_LABEL_PADDING, \

PORT_SEPARATION, LABEL_SEPARATION, \

import Actions

import pygtk

pygtk.require('2.0')

BLOCK_MARKUP_TMPL="""\

#set $foreground = $block.is_valid() and 'black' or 'red'

class Block(Element):

"""The graphical signal block."""

#create the main layout

layout = gtk.DrawingArea().create_pango_layout('')

layouts.append(layout)

self.label_width, self.label_height = layout.get_pixel_size()

#display the params

if self.is_dummy_block():

else:

markups = [param.get_markup() for param in self.get_params() if param.get_hide() not in ('all', 'part')]

if markups:

##default sizes

DEFAULT_BLOCKS_WINDOW_WIDTH = 100

DEFAULT_REPORTS_WINDOW_WIDTH = 100

##The size of the state saving cache in the flow graph (for undo/redo functionality)

STATE_CACHE_SIZE = 42

## A list of functions that can receive a message.

MESSENGERS_LIST = list()

def register_messenger(messenger):

"""

Append the given messenger to the list of messengers.

Args:

"""

MESSENGERS_LIST.append(messenger)

def send(message):

"""

Give the message to each of the messengers.

def send_verbose_exec(verbose):

send(verbose)

################# functions for saving flow graphs ########################################

def send_fail_save(file_path):

import Utils

from Element import Element

import pygtk

pygtk.require('2.0')

import gtk

PARAM_MARKUP_TMPL="""\

#set $foreground = $param.is_valid() and 'black' or 'red'

PARAM_LABEL_MARKUP_TMPL="""\

#set $foreground = $modified and 'blue' or $param.is_valid() and 'black' or 'red'

Returns:

a pango markup string

"""

from Constants import \

PORT_SEPARATION, CONNECTOR_EXTENSION_MINIMAL, \

CONNECTOR_EXTENSION_INCREMENT, \

import Utils

import Actions

import Colors

pygtk.require('2.0')

import gtk

PORT_MARKUP_TMPL="""\

class Port(Element):

self._bg_color = Colors.get_color(self.get_color())

#create the layout

layout = gtk.DrawingArea().create_pango_layout('')

self.w, self.h = layout.get_pixel_size()

self.W, self.H = 2*PORT_LABEL_PADDING + self.w, 2*PORT_LABEL_PADDING+self.h

self.H = self.modify_height(self.H)

namespace fs = boost::filesystem;

int main(int argc, char *argv[]) {

// Adding program options

boost::program_options::options_description desc("Options");

("tests-regex,R",

boost::program_options::value<std::string>(),

"Run tests matching regular expression.")

;

// Handle the options that were given

bool benchmark_mode;

std::string kernel_regex;

bool store_results = true;

try {

boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc), vm);

boost::program_options::notify(vm);

return 0;

}

// Run tests

//VOLK_PROFILE(volk_16i_x5_add_quad_16i_x4, 1e-4, 2046, 10000, &results, benchmark_mode, kernel_regex);

//VOLK_PROFILE(volk_16i_branch_4_state_8, 1e-4, 2046, 10000, &results, benchmark_mode, kernel_regex);

VOLK_PROFILE(volk_32f_s32f_multiply_32f, 1e-4, 1.0, 204602, 10000, &results, benchmark_mode, kernel_regex);

VOLK_PROFILE(volk_32f_binary_slicer_32i, 0, 1.0, 204602, 10000, &results, benchmark_mode, kernel_regex);

VOLK_PROFILE(volk_32f_binary_slicer_8i, 0, 1.0, 204602, 10000, &results, benchmark_mode, kernel_regex);

// Until we can update the config on a kernel by kernel basis

// do not overwrite volk_config when using a regex.

#the function name is followed by the preferred architecture.\n\

";

}

config.close();

}

# if we find one that matches our current system architecture

# set up the assembler flags and include the source files

foreach(ARCH ${ASM_ARCHS_AVAILABLE})

string(REGEX MATCH "${ARCH}" ASM_ARCH "${FULL_C_FLAGS}")

if( ASM_ARCH STREQUAL "armv7" )

message(STATUS "---- Adding ASM files") # we always use ATT syntax

message(STATUS "-- Detected armv7 architecture; enabling ASM")

# setup architecture specific assembler flags

message(STATUS "Adding source file: ${asm_file}")

endforeach(asm_file)

endif()

endforeach(ARCH)

else(${CMAKE_VERSION} VERSION_GREATER "2.8.9")

message(STATUS "Not enabling ASM support. CMake >= 2.8.10 required.")

endif(${CMAKE_VERSION} VERSION_GREATER "2.8.9")

########################################################################

#include <boost/tokenizer.hpp>

#include <boost/xpressive/xpressive.hpp>

#include <iostream>

#include <vector>

#include <list>

#include <ctime>

#include <cmath>

lv_32fc_t scalar,

int vlen,

int iter,

std::string kernel_regex

) {

boost::xpressive::sregex kernel_expression = boost::xpressive::sregex::compile(kernel_regex);

// in this case we have a regex and are only looking to test one kernel

return false;

}

std::cout << "RUN_VOLK_TESTS: " << name << "(" << vlen << "," << iter << ")" << std::endl;

// The multiply and lv_force_cast_hf are work arounds for GNU Radio bugs 582 and 583

end = clock();

double arch_time = 1000.0 * (double)(end-start)/(double)CLOCKS_PER_SEC;

std::cout << arch_list[i] << " completed in " << arch_time << "ms" << std::endl;

profile_times.push_back(arch_time);

}

std::cout << "Best aligned arch: " << best_arch_a << std::endl;

std::cout << "Best unaligned arch: " << best_arch_u << std::endl;

if(puppet_master_name == "NULL") {

}

}

return fail_global;

#include <cstdlib>

#include <string>

#include <vector>

#include <volk/volk.h>

#include <volk/volk_common.h>

float uniform(void);

void random_floats(float *buf, unsigned n);

#define VOLK_PROFILE(func, tol, scalar, len, iter, results, bnmode, kernel_regex) run_volk_tests(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), tol, scalar, len, iter, results, "NULL", bnmode, kernel_regex)

#define VOLK_PUPPET_PROFILE(func, puppet_master_func, tol, scalar, len, iter, results, bnmode, kernel_regex) run_volk_tests(func##_get_func_desc(), (void (*)())func##_manual, std::string(#func), tol, scalar, len, iter, results, std::string(#puppet_master_func), bnmode, kernel_regex)

typedef void (*volk_fn_1arg)(void *, unsigned int, const char*); //one input, operate in place

VOLK_RUN_TESTS(volk_32f_invsqrt_32f, 1e-2, 0, 20462, 1);

VOLK_RUN_TESTS(volk_32f_binary_slicer_32i, 0, 0, 20462, 1);

VOLK_RUN_TESTS(volk_32f_binary_slicer_8i, 0, 0, 20462, 1);