Blind Detection of Polar Codes

Polar codes were recently chosen to protect the control channel information in the next-generation mobile communication standard (5G) defined by the 3GPP. As a result, receivers will have to implement blind detection of polar coded frames in order to keep complexity, latency, and power consumption tractable. As a newly proposed class of block codes, the problem of polar-code blind detection has received very little attention. In this work, we propose a low-complexity blind-detection algorithm for polar-encoded frames. We base this algorithm on a novel detection metric with update rules that leverage the a priori knowledge of the frozen-bit locations, exploiting the inherent structures that these locations impose on a polar-encoded block of data. We show that the proposed detection metric allows to clearly distinguish polar-encoded frames from other types of data by considering the cumulative distribution functions of the detection metric, and the receiver operating characteristic. The presented results are tailored to the 5G standardization effort discussions, i.e., we consider a short low-rate polar code concatenated with a CRC.Comment: 6 pages, 8 figures, to appear at the IEEE Int. Workshop on Signal Process. Syst. (SiPS) 201

BioCoder: A Benchmark for Bioinformatics Code Generation with Contextual Pragmatic Knowledge

Pre-trained language models like ChatGPT have significantly improved code generation. As these models scale up, there is an increasing need for the output to handle more intricate tasks. Moreover, in bioinformatics, generating functional programs poses additional notable challenges due to the amount of domain knowledge, the need for complicated data operations, and intricate functional dependencies between the operations. Here, we present BioCoder, a benchmark developed to evaluate existing pre-trained models in generating bioinformatics code. In relation to function-code generation, BioCoder covers potential package dependencies, class declarations, and global variables. It incorporates 1026 functions and 1243 methods in Python and Java from GitHub and 253 examples from the Rosalind Project. BioCoder incorporates a fuzz-testing framework for evaluation, and we have applied it to evaluate many models including InCoder, CodeGen, CodeGen2, SantaCoder, StarCoder, StarCoder+, InstructCodeT5+, and ChatGPT. Our detailed analysis of these models emphasizes the importance of domain knowledge, pragmatic code generation, and contextual understanding. Our dataset, benchmark, Docker images, and scripts required for testing are all available at https://github.com/gersteinlab/biocoder

A Parallel Monte Carlo Code for Simulating Collisional N-body Systems

We present a new parallel code for computing the dynamical evolution of collisional N-body systems with up to N~10^7 particles. Our code is based on the the Henon Monte Carlo method for solving the Fokker-Planck equation, and makes assumptions of spherical symmetry and dynamical equilibrium. The principal algorithmic developments involve optimizing data structures, and the introduction of a parallel random number generation scheme, as well as a parallel sorting algorithm, required to find nearest neighbors for interactions and to compute the gravitational potential. The new algorithms we introduce along with our choice of decomposition scheme minimize communication costs and ensure optimal distribution of data and workload among the processing units. The implementation uses the Message Passing Interface (MPI) library for communication, which makes it portable to many different supercomputing architectures. We validate the code by calculating the evolution of clusters with initial Plummer distribution functions up to core collapse with the number of stars, N, spanning three orders of magnitude, from 10^5 to 10^7. We find that our results are in good agreement with self-similar core-collapse solutions, and the core collapse times generally agree with expectations from the literature. Also, we observe good total energy conservation, within less than 0.04% throughout all simulations. We analyze the performance of the code, and demonstrate near-linear scaling of the runtime with the number of processors up to 64 processors for N=10^5, 128 for N=10^6 and 256 for N=10^7. The runtime reaches a saturation with the addition of more processors beyond these limits which is a characteristic of the parallel sorting algorithm. The resulting maximum speedups we achieve are approximately 60x, 100x, and 220x, respectively.Comment: 53 pages, 13 figures, accepted for publication in ApJ Supplement

Rapid prototyping with Matlab/Simulink-- A case study.

In order to minimise development time it is important to be able to implement and test control functions at an early stage in a project, even before the electronic hardware of the new product is available. For this purpose, a PC based rapid prototyping system including a graphical modelling/simulation tool and automatic C code generation for real-time simulations with hardware in the loop may be used. In this thesis an evaluation of Matlab/Simulink as a tool for rapid prototyping of control functions in dialysis machines has been done. A comparison has also been done to the tool that is in use today at Gambro Lundia AB, MatrixX/SystemBuild. The sections that have been investigated are block diagram modelling including translation from SystemBuild block diagram, state machine implementation, Graphical User Interface, data acquisition, simulation with hardware-in-the-loop, and code generation. The Matlab/Simulink tool has been tested on a hydraulic system prototype during the evaluation and advantages and disadvantages have been noted. The report gives an overview of howMatlab/Simulink meets the requirements that can be expected of a rapid prototyping tool, for control functions and design tips to avoid problems during the development phase

Finding The Lazy Programmer's Bugs

Traditionally developers and testers created huge numbers of explicit tests, enumerating interesting cases, perhaps biased by what they believe to be the current boundary conditions of the function being tested. Or at least, they were supposed to. A major step forward was the development of property testing. Property testing requires the user to write a few functional properties that are used to generate tests, and requires an external library or tool to create test data for the tests. As such many thousands of tests can be created for a single property. For the purely functional programming language Haskell there are several such libraries; for example QuickCheck [CH00], SmallCheck and Lazy SmallCheck [RNL08]. Unfortunately, property testing still requires the user to write explicit tests. Fortunately, we note there are already many implicit tests present in programs. Developers may throw assertion errors, or the compiler may silently insert runtime exceptions for incomplete pattern matches. We attempt to automate the testing process using these implicit tests. Our contributions are in four main areas: (1) We have developed algorithms to automatically infer appropriate constructors and functions needed to generate test data without requiring additional programmer work or annotations. (2) To combine the constructors and functions into test expressions we take advantage of Haskell's lazy evaluation semantics by applying the techniques of needed narrowing and lazy instantiation to guide generation. (3) We keep the type of test data at its most general, in order to prevent committing too early to monomorphic types that cause needless wasted tests. (4) We have developed novel ways of creating Haskell case expressions to inspect elements inside returned data structures, in order to discover exceptions that may be hidden by laziness, and to make our test data generation algorithm more expressive. In order to validate our claims, we have implemented these techniques in Irulan, a fully automatic tool for generating systematic black-box unit tests for Haskell library code. We have designed Irulan to generate high coverage test suites and detect common programming errors in the process

Modeling radiation belt radial diffusion in ULF wave fields: 1. Quantifying ULF wave power at geosynchronous orbit in observations and in global MHD model

[1] To provide critical ULF wave field information for radial diffusion studies in the radiation belts, we quantify ULF wave power (f = 0.5–8.3 mHz) in GOES observations and magnetic field predictions from a global magnetospheric model. A statistical study of 9 years of GOES data reveals the wave local time distribution and power at geosynchronous orbit in field-aligned coordinates as functions of wave frequency, solar wind conditions (Vx, ΔPd and IMF Bz) and geomagnetic activity levels (Kp, Dst and AE). ULF wave power grows monotonically with increasing solar wind Vx, dynamic pressure variations ΔPd and geomagnetic indices in a highly correlated way. During intervals of northward and southward IMF Bz, wave activity concentrates on the dayside and nightside sectors, respectively, due to different wave generation mechanisms in primarily open and closed magnetospheric configurations. Since global magnetospheric models have recently been used to trace particles in radiation belt studies, it is important to quantify the wave predictions of these models at frequencies relevant to electron dynamics (mHz range). Using 27 days of real interplanetary conditions as model inputs, we examine the ULF wave predictions modeled by the Lyon-Fedder-Mobarry magnetohydrodynamic code. The LFM code does well at reproducing, in a statistical sense, the ULF waves observed by GOES. This suggests that the LFM code is capable of modeling variability in the magnetosphere on ULF time scales during typical conditions. The code provides a long-missing wave field model needed to quantify the interaction of radiation belt electrons with realistic, global ULF waves throughout the inner magnetosphere