dataesr/scientific-paragraphs-categorization huggingface dataset:
e. , DSLs), which purpose is to simplify the prototyping process of an SDR waveform, that is to say the physical layer (PHY). Most of these languages proposed in the literature essentially target DSP-centric architectures through specific design flows  [8] [9] [10]. The waveform description language (WDL)  [8]  enables implementing the overall PHY from a hierarchical decomposition. It is mixing graphical and state machine concepts to provide the user with facilities to specify a complete SDR-PHY. Processing elements are blocks within which a state machine locally handles both scheduling, thanks to handshake protocols, as well as the communication with the other blocks. SPEX  [9]  is another language developed to specify SDR PHYs on single instruction multiple data (SIMD) processor using vector data type such as Matlab and also data type borrowed from SystemC.
The Software Communication Architecture (SCA)  [11] , initiated by the Joint Tactical Radio System (JTRS), is a major contribution in the software radio domain. It is defined as both a framework and a common standard for software radio specifications, and it is based on three major elements. The Core Framework handles via a hardware abstraction the installation, the configuration, the control, and the management of the waveforms. The ORB middleware serves to ensure the communication between the entities through client/server-like architecture. Both the Core Framework and the ORB leverage a real-time operating system to get access to the hardware resources. The Prismtech Spectra Core Framework (PrismTech Group Ltd. , Stirlingshire, UK)  [14]  is a SCA-compliant framework that supports the deployment of waveform components on any mix of http://asp.
eurasipjournals. com/content/2014/1/164 general purpose processor (GPP), DSP microprocessors, and FPGAs. FPGA functions are essentially programmed in VHDL-RTL. In the same way, the Platform and Hardware Abstraction Layer (P-HAL)  [12]  aims at designing specific radio applications independently of the hardware context. The underlying approach consists in abstracting the hardware platform by software functional units. Thus, it manages radio process real-time constraints, processing elements and communication issues, and enables the software functional units to be configured. The P-HAL defines four services, namely the BRIDGE that handles real-time constraints, the SYNC that synchronizes the concurrent processes, the KERNEL that schedules the software functional units, and the STATS that analyses the statistics of the functional units.
The majority of HLLs are academic research works, but commercial examples of such languages/tools have also been released, namely Catapult from Calypto (Calypto Design Systems, Inc. , San Jose, CA, USA) and Vivado HLS from Xilinx (Xilinx Inc. , San Jose, CA, USA). Figure  1  illustrates the Catapult design flow that we have experienced within the work presented in  [16]. The first stage requires specifying the waveform from an algorithmic point of view. This specification allows a functional simulation of the application and it is more about deciding what the system does and how the computation is done. At this stage, some relevant aspects such as data sizing and communication protocols can also be explored. Then, those realistic specifications are fed to the synthesis tool together with a set of architectural and resource constraints.
The compiler parses the specifications and the constraints to decide both a scheduling and resource allocation for the final design. In a successful case, it generates the RTL description of the specification which can be tested and synthesized for a specific FPGA target or ASIC fabric. Recently, OpenCL (Khronos Group, Beaverton, OR, USA)  [17] [18] [19]  has also been proposed as an abstraction to program FPGAs. It is argued that OpenCL has a native approach to express application parallelism; hence, it is a good candidate for designing parallel signal processing applications for FPGA fabrics. These high-level languages and their compilers give an emphasis to the timing, area, or throughput constraints while making it easier to explore a set of solutions throughout design space exploration (DSE).
Compiling framework The proposed DSL enables to capture, for a given waveform, several extra information like the PHY data frame structure or the adaptive nature of some of the FBs. This description is parsed and synthesized into the actual waveform intended to run on FPGA fabrics. The main interface language that is employed in this flow is the. tcl scripting language. Indeed, the. tcl language is proposed by most of the electronic design automation (EDA) tools as entry point. This scripting language is leveraged in the proposed design methodology to automate several steps throughout the synthesis process. HLS tools, for instance,  are interfaced with. tcl scripts that are generated by the DSL compiler. Indeed, for each FB instantiated in the DSL, a. tcl script will be generated by the compiler.
Afterwards, those scripts are used to synthesize the desired RTL description of the block. In addition, after generating the appropriate. tcl scripts, the DSL compiler collects the FB RTL descriptions and implements the datapath of the desired SDR waveform as a top level design. A controller is also inferred from the DSL-based description. It is implemented as a hierarchical finite state machine (HFSM) that is automatically generated after parsing the source code. The structure and the working modes of the finite state machine (FSM) are deduced from both an algorithm and the description provided by the DSL. Tcl scripting is also used to interface the Xilinx synthesis tools when it comes to synthesize the bitstream of the waveform. Figure  8  illustrates the compiling framework that is made up of four parts.
The first part consists in modeling the waveform in the proposed DSL. Then, this description is parsed to generate. tcl scripts for each HLS-based FB. A heterogeneous approach is also envisioned in this methodology so as to interconnect FBs issued from different HLS tools. Thus, some key words such as #catapult, #vivadohls, and #rtl enable to target Catapult-C, Vivado HLS, and native RTL blocks, respectively. The second part is the core compiler where each script is used to synthesize (at the RTL http://asp. eurasipjournals. com/content/2014/1/164 level) the blocks while a control unit is automatically inferred and generated. The connection of all the FBs into a datapath is also performed automatically in this step together with the assembly of waveform which consists of the dataflow unit (datapath) and the control unit.
The data frame specification is used to generate the stimuli for the test bench. The final waveform is verified from a generated VHDL test bench whose outputs are compared with predetermined golden outputs. Finally, the Waveform Validation takes place after bitstream synthesis. It consists essentially in testing the waveform on the platform so as to analyze its performance. Contrary to the first two steps that are performed automatically, this step is by now performed manually, and the authors are investigating on how to automate such validation process from the high-level specifications.
Testbed description and waveform implementation results The The integration of the applications is partly made by using generated. tcl scripts as entry point to the synthesis tools. Moreover, in order to demonstrate the feasibility of the concept, a first test has been made without the DSL on the same platform and the results were published in  [28]. In Figure  10 , the testbed is presented. Figure  11  on the other hand, illustrates the set of equipment utilized in this experimentation. It includes two Nutaq platforms (TX and RX) and some measurement tools such as ADS    12.
DSL complexity A waveform specification with the proposed DSL is done with a few hundreds of lines of source code. In the examples depicted in this paper, less than 150 of lines of source code was used to model the PHY IEEE 802. 11a and less than a hundred for the PHY IEEE 802. 15. 4. The flow also relies on a set of constantly evolving FB libraries, hence reducing considerably the development time. As previously explained, most of the steps in this flow are made automatic through the. tcl scripting language. The DSL compiler handles the implementation of the waveform by connecting the FBs and generating the waveform controller introduced previously in this paper. The resulting RTL source code for a given waveform consists of a few thousand of lines of source code entirely generated by both the DSL compiler and the HLS tools.
Thus, the less the initiation interval (II), is the deeper the pipeline is. One can see from these curves that low throughput in cycles (high in frequency) is achieved when the design is pipelined to a maximum (II = 1). Loop unrolling (U) impacts considerably the design throughput. However, both loop unrolling and pipelining require more resources; hence, an increasing area as can be seen in Figure  14  shows a DSE for a 256-point FFT, performed with Catapult-C in order to obtain different solutions for same FB. The DSE is performed automatically from the scripts generated by the DSL compiler. The exploration of the FFT block exhibits an increasing number of slices versus the achievable data rate. Hence, suitable solution can be chosen to compose the desired waveform. To conclude, the current version of the flow handles block-level configuration; it enables to select the architecture of a adaptive block depending on the constraints.
Weese, Holtgrewe & Reinert (2012)  categorize read mappers into best-mappers that try to find the (or any) best hit of a read (e. g. , BWA-MEM;  Li (2013) ) and all-mappers that provide a comprehensive enumeration of all hits (e. g. , RazerS 3 or the "all" mode of Bowtie 2) up to a given error threshold. While all-mappers can be much slower (depending on the number of hits), their strategy is advantageous when a confidence value is required that the reported origin is the true origin of the read. Further, all-mappers are useful when mapping to homologous sequences like alternative transcripts  (Roberts & Pachter, 2013)  or meta-genomes, where more than one hit is expected. An intermediate strategy is to report all hits of the best stratum, i. e. , all hits with the same lowest error level (instead of only the first or a random such hit).
For above notion of sensitivity, it would not be sufficient to consider the true origins of a read as they are known from the simulation with Mason. The mapped reads were used to generate gold standards for Rabema to test against. In "Comparison with other read mappers", we assess the accuracy of PEANUT in comparison to other mappers on larger datasets. We analyze the sensitivity of our algorithm using q-grams of length 16, because it is computationally optimal on the current GPU hardware. We configure PEANUT to provide all semi-global alignments of a read and leave all other parameters at their default values. Sensitivity is assessed by the Rabema measure "Normalized found intervals"  (Holtgrewe et al. , 2011)  and all alignments of a read are considered (all-mode). With a percent identity threshold of 60 (see "Validation") our algorithm provides 100% sensitivity for error rates below 5%, 99.
Comparison with other read mappers We compare the PEANUT algorithm with other state of the art read mapping algorithms in terms of run time and accuracy. The evaluation is conducted on 4 datasets: 1. 5 million simulated Illumina HiSeq 2000 reads; 2. 5 million real Illumina HiSeq 2000 reads from the human exome; claim significant speedups compared at least to other RNA-Seq focused read mappers. However, this comes at the cost of extensive memory usage by an uncompressed suffix array, which exceeds the capacity of the used test system. In the following, we distinguish between all-mappers and best-mappers (PEANUT occurs in both categories, using the all-mode and the best-stratum mode). Best-mappers only strive to find the single origin of a read on the reference sequence of a single organism.
All-mappers provide all alignments of a read down to a given error rate. Hence, all-mapping is computationally more intensive. Run time performance is measured three times as the overall wall clock time for processing a dataset on the test system. Table  1  shows the run times for PEANUT and its competitors on all datasets. First, PEANUT in best-stratum mode outperforms all best-mappers (including the other GPU based mappers NextGenMap and CUSHAW2-GPU) on all datasets. On the biggest (and therefore most realistic) dataset, PEANUT is 2 times faster than the best competitor (BWA-MEM). Second, PEANUT in all-mode is 4 to 10 times faster than the all-mapper RazerS 3 and 4 to 6 times faster than the all-mapper MrFast. While Bowtie 2 provides an all-mode, too, it did not terminate in competetive time due to extensive memory requirements exceeding the capabilities of the test system.
The accuracy of the obtained alignments is assessed using Rabema (see "Validation"). For best-mappers, using the simulated dataset 1, we measure precision and recall with Rabema as defined by Siragusa,  Weese & Reinert (2013) : Recall is the fraction of reads correctly mapped to their original location. This location is known from the read simulation with Mason (see above). Precision is the fraction of correctly mapped reads among all reads that were mapped unambiguously (i. e. , for which the mapper only provided exactly one hit). Figures  5  and 6  shows the results with increasing maximum error rate of the reads. Except when restricting to reads with zero errors (there, CUSHAW3 is slightly better), PEANUT slightly outperforms all other best-mappers in this benchmark. For best-mapping, the GCAT 9  benchmark provides an alternative, less formal approach consisting of about 12 million 100 basepair reads each.
The comparison is limited to those of our considered read mappers for which public results are available in GCAT (i. e. , BWA-MEM, Bowtie 2, CUSHAW2 and CUSHAW3). The full reports are available via the GCAT web service under the URLs provided in the footnotes. All-mappers are compared by their ability to find all alignments of a given error rate. Here, we again use the sensitivity provided by Rabema (see "Sensitivity"). This involves creating a gold standard with RazerS 3 configured to full sensitivity, which is computationally expensive. We therefore perform this on only 1,000 reads simulated with the same parameters as dataset 1. The gold standard is calculated for an error rate of at most 15%. Figure  7  shows that up to an error rate of 4% PEANUT provides a sensitivity of almost 100%, similar to RazerS 3 and nearly as good as MrFast.
Evaluation of mapping qualities Finally, we evaluate the mapping qualities provided by PEANUT. For each PHRED-scaled mapping quality q, the corresponding probability 10 -q 10 equals the expected false positive rate. Here, true positives are the correctly identified true sampling positions of the reads, whereas false positives are reported mapping locations that may have the same alignment score but are not the true origins of a read. Figure  8  shows the measured and expected false positive rate (i. e. , the fraction of false positives among all hits) at increasing mapping qualities for the hits reported by PEANUT in all-mode on dataset 1. As can be seen, the measured false positive rate rapidly decays when increasing the mapping quality from zero. A mapping quality above 10 (i. e. , a probability of 0.
1) already guarantees almost no false positives. Comparison with the dashed line, depicting the expected false positive rate for each mapping quality, shows that the mapping qualities provided by PEANUT are indeed conservative in the sense of underestimating the true probabilities. The parameters λ and C of the approximation (see "Postprocessing") can be configured to different values to achieve a closer fit for a particular reference or dataset. Despite that, the defaults provide a reasonable way to distinguish between true and false positives without the computational overhead needed for calculating concrete alignments of many suboptimal hits (see "Postprocessing").
DISCUSSION We presented the q-group index, a novel data structure for read mapping, along with parallel algorithms for index building and querying. The algorithms fit nicely to the GPU architecture by using a combination of element-wise and prefix scan operations over large arrays and requiring hardly any data transfer between the host and the GPU. We showed that the q-group index needs significantly less memory in practical scenarios than a conventional q-gram index while maintaining constant access time. The q-group index has been adopted by NVIDIA TM and is provided as part of the NVBIO library. 15 15 http://nvlabs. github. io/nvbio/ On top of the q-group index we implemented the read mapper PEANUT. The q-group index enables the mapper to be the first implementation of the filtration and validation approach that works completely on the GPU.
The benefit of this is illustrated by PEANUT showing supreme speed over state of the art read mappers like BWA, Bowtie 2, RazerS 3, CUSHAW3 and MrFast, as well as the GPU based read mappers NextGenMap and package. Filtration and validation were implemented in OpenCL, using the PyOpenCL package  (Klöckner et al. , 2012)  and postprocessing was implemented in Cython  (Behnel et al. , 2011). Documentation and installation instructions are available at http://peanut. readthedocs. org, where we further provide a Snakemake  (Köster & Rahmann, 2012)  workflow of all analyses conducted in this work.
On the contrary an implicit method may not have this step restriction but requires at each step the solution of a system of equations which is non linear when the differential system is non linear. And this is the case for most biological models. Here it is shown that a simple method called the CESTAC method can be easily used to investigate the sensitivity of the computed solution to the coefficients and initial conditions of a differential system and to detect possible instabilities. Various numerical examples coming from the modelisation of bacterial growth are presented. The structure of this paper is as follows. First stochastic arithmetic and the CESTAC method are shortly recalled. Then a software called CADNA which imple-ments the CESTAC method is presented and the use of this software to investigate the stability of the solution of a differential system is detailed.
C. The Cadna software The Cadna software implements the so-called discrete stochastic arithmetic, which is nothing else than the CESTAC method to which have been added comparison operators, the notion of non-significant result and some more complementary features. It can be freely downloaded from  [8]. Two versions exist, one in Fortran 90 and one in C++. They have been developed as libraries to be added to an already existing code. In this software, new types for single precision and double precision stochastic numbers have been defined and all arithmetic operators and tests have been overloaded so that computing with stochastic numbers is as easy as computing with real numbers. Thus, any Fortran 90 or C++ code working with real numbers can be almost instantly converted in a code working with stochastic numbers, i.
e. numbers with their errors. It has been theoretically and experimentally shown that formula (  5 ) is correct to one digit with N = 3, consequently in the Cadna software all stochastic numbers are represented as three samples with Gaussian distribution. Another feature of the Cadna software is that stochastic numbers represent imprecise numbers where the error is due not only to rounding in floating point arithmetic but also to the data which may also be imprecise. Thus in this software it is possible to introduce errors in the data so that an imprecise data is represented by a stochastic number with a known mean value and a known standard deviation. This possibility is used in the experimental investigation of the stability of the numerical solution of differential systems especially those coming from the modelisation of biological reactions.
III. APPLICATION TO SOME BIOLOGICAL MODELS Many biological models are represented as nonlinear differential systems. Studying their stability may be difficult, see for example  [6]. But the use of the Cadna software leads to an immediate answer to the question: "Is the computed solution stable around this special value of this particular parameter?" Of course this is not the answer to the more general question "What is the domain of stability of the system?" but as is shown below, it can easily help to analyse the sensitivity of the solution to some parameter or to initial conditions. As illustrations of the efficiency of the CESTAC method to experimentally investigate the stability of computed solutions, several biological model solutions have been computed using a fourth order Runge-Kutta method together with the Cadna software.
The results are shown in figures (8) and  (9). It must be noted that the concentrations of free cells and of immobilized cells are of different order, close to 0. 3 kg/m 3 for the free cells and close to 200 kg/m 3 for the immobilised cells. This is why in the figures the concentrations of immobilised cells have been scaled by a factor 0. 001. In the second experiment the Cadna software detects several instabilities as some multiplications and divisions have non-significant results. Anyhow the corresponding figure  (9)  shows that the asymptotes of all components do not depend on the initial conditions. Indeed this fact which can probably be proved has been numerically experimented by running the program with many different initial conditions and the asymptotes are always identical provided that x im (0) = 0 and that s(0) satisfies the stability condition: s 0 ≤ Ds in -β 1 x 1 (0) -β im x im (0) as explained in  [6].
IV. CONCLUSION Stochastic arithmetic has been proved to be an interesting method for the estimation of the error on a computed result when the data are inaccurate and the arithmetic operators introduce round-off errors. In this paper it has been experimentally shown on several bioreactor models that the CESTAC method and the corresponding Cadna software which are based on stochastic arithmetic can provide an easy alternative to theoretical studies when one wants to know whether the computed solution of a differential system is correct and stable or not. Of course the Cadna software does not lead to the domain of stability of the system but only to the knowledge of the stability of a particular solution computed with a particular numerical method. But in many cases the interest is not in the whole domain of stability but only in the solution of a particular model of a real experimental bioreactor.
As presented on the models taken from the classical literature, the Cadna software is particularly efficient in the detection of the coefficients or initial values, a small variation of which introduces a large variation in the solution. In the same idea, the coefficients which have a very little influence on the solution can be detected as well. This gives a precious information to the biologists who make the real experiments on the necessity of knowing some coefficients with a very good accuracy whereas some others can be only roughly known.
During the last decade the emergence of spaceborne observation platforms provide a large amount of cloud related data (AVHRR, ISCCP, MODIS, A-Train). Unlike ground-based sites, they present the great advantage to involve a uniform measurement technique with a very large coverage (almost the entire Arctic region). In particular the new generation of spaceborne instrumentation onboard CALIPSO  (Winker et al. , 2003)  and CloudSat  (Stephens et al. , 2002)  satellites (active remote sensing formed by of 532 and 1064 nm lidar and 94 GHz radar) provide since 2006 an unprecedented dataset of the vertical structure of clouds, continuously in time and space. The aim of this study is to characterize the vertical, spatial and seasonal variability of Arctic MPC at regional scale from space remote sensing.