Library Code Research Articles

SkData: data sets and algorithm evaluation protocols in Python

Machine learning benchmark data sets come in all shapes and sizes, whereas classification algorithms assume sanitized input, such as (x, y) pairs with vector-valued input x and integer class label y. Researchers and practitioners know all too well how tedious it can be to get from the URL of a new data set to a NumPy ndarray suitable for e.g. pandas or sklearn. The SkData library handles that work for a growing number of benchmark data sets (small and large) so that one-off in-house scripts for downloading and parsing data sets can be replaced with library code that is reliable, community-tested, and documented. The SkData library also introduces an open-ended formalization of training and testing protocols that facilitates direct comparison with published research. This paper describes the usage and architecture of the SkData library.

Sparse maps—A systematic infrastructure for reduced-scaling electronic structure methods. I. An efficient and simple linear scaling local MP2 method that uses an intermediate basis of pair natural orbitals.

In this work, a systematic infrastructure is described that formalizes concepts implicit in previous work and greatly simplifies computer implementation of reduced-scaling electronic structure methods. The key concept is sparse representation of tensors using chains of sparse maps between two index sets. Sparse map representation can be viewed as a generalization of compressed sparse row, a common representation of a sparse matrix, to tensor data. By combining few elementary operations on sparse maps (inversion, chaining, intersection, etc.), complex algorithms can be developed, illustrated here by a linear-scaling transformation of three-center Coulomb integrals based on our compact code library that implements sparse maps and operations on them. The sparsity of the three-center integrals arises from spatial locality of the basis functions and domain density fitting approximation. A novel feature of our approach is the use of differential overlap integrals computed in linear-scaling fashion for screening products of basis functions. Finally, a robust linear scaling domain based local pair natural orbital second-order Möller-Plesset (DLPNO-MP2) method is described based on the sparse map infrastructure that only depends on a minimal number of cutoff parameters that can be systematically tightened to approach 100% of the canonical MP2 correlation energy. With default truncation thresholds, DLPNO-MP2 recovers more than 99.9% of the canonical resolution of the identity MP2 (RI-MP2) energy while still showing a very early crossover with respect to the computational effort. Based on extensive benchmark calculations, relative energies are reproduced with an error of typically <0.2 kcal/mol. The efficiency of the local MP2 (LMP2) method can be drastically improved by carrying out the LMP2 iterations in a basis of pair natural orbitals. While the present work focuses on local electron correlation, it is of much broader applicability to computation with sparse tensors in quantum chemistry and beyond.

Behavior-based features model for malware detection

The sharing of malicious code libraries and techniques over the Internet has vastly increased the release of new malware variants in an unprecedented rate. Malware variants share similar behaviors yet they have different syntactic structure due to the incorporation of many obfuscation and code change techniques such as polymorphism and metamorphism. The different structure of malware variants poses a serious problem to signature-based detection technique, yet their similar exhibited behaviors and actions can be a remarkable feature to detect them by behavior-based techniques. Malware instances also largely depend on API calls provided by the operating system to achieve their malicious tasks. Therefore, behavior-based detection techniques that utilize API calls are promising for the detection of malware variants. In this paper, we propose a behavior-based features model that describes malicious action exhibited by malware instance. To extract the proposed model, we first perform dynamic analysis on a relatively recent malware dataset inside a controlled virtual environment and capture traces of API calls invoked by malware instances. The traces are then generalized into high-level features we refer to as actions. We assessed the viability of actions by various classification algorithms such as decision tree, random forests, and support vector machine. The experimental results demonstrate that the classifiers attain high accuracy and satisfactory results in the detection of malware variants.

SU‐E‐T‐212: Comparison of TG‐43 Dosimetric Parameters of Low and High Energy Brachytherapy Sources Obtained by MCNP Code Versions of 4C, X and 5

Purpose:Different versions of MCNP code are widely used for dosimetry purposes. The purpose of this study is to compare different versions of the MCNP codes in dosimetric evaluation of different brachytherapy sources.Methods:The TG‐43 parameters such as dose rate constant, radial dose function, and anisotropy function of different brachytherapy sources, i.e. Pd‐103, I‐125, Ir‐192, and Cs‐137 were calculated in water phantom. The results obtained by three versions of Monte Carlo codes (MCNP4C, MCNPX, MCNP5) were compared for low and high energy brachytherapy sources. Then the cross section library of MCNP4C code was changed to ENDF/B‐VI release 8 which is used in MCNP5 and MCNPX codes. Finally, the TG‐43 parameters obtained using the MCNP4C‐revised code, were compared with other codes.Results:The results of these investigations indicate that for high energy sources, the differences in TG‐43 parameters between the codes are less than 1% for Ir‐192 and less than 0.5% for Cs‐137. However for low energy sources like I‐125 and Pd‐103, large discrepancies are observed in the g(r) values obtained by MCNP4C and the two other codes. The differences between g(r) values calculated using MCNP4C and MCNP5 at the distance of 6cm were found to be about 17% and 28% for I‐125 and Pd‐103 respectively. The results obtained with MCNP4C‐revised and MCNPX were similar. However, the maximum difference between the results obtained with the MCNP5 and MCNP4C‐revised codes was 2% at 6cm.Conclusion:The results indicate that using MCNP4C code for dosimetry of low energy brachytherapy sources can cause large errors in the results. Therefore it is recommended not to use this code for low energy sources, unless its cross section library is changed. Since the results obtained with MCNP4C‐revised and MCNPX were similar, it is concluded that the difference between MCNP4C and MCNPX is their cross section libraries.

DNP3에 적합한 발신 부인 방지 기법 제안과 그 구현

DNP3(Distributed Network Protocol) is one of the most representative protocols which is used in SCADA(Supervisory Control and Data Acquisition) system. IEC 62351 is listing the integrity, confidentiality, availability and non-repudiation or accountability as the security requirement. However, IEEE Std. 1815 that is DNP3 standards does not define a mechanism for non-repudiation or accountability. In this paper, we propose a non-repudiation of origin technique about the sender of critical ASDU and implement the proposed scheme using software such as OpenSSL and SCADA source code library.

SOURCE CODE ANALYSIS AS TECHNICAL ART HISTORY

As part of its program to conserve software-based artworks, the Museum of Modern Art undertook a risk analysis of 13 works that use a variety of software programs, programming languages, and code libraries. Risks assessed in this study include the potential impact due to changes and upgrades to hardware, operating systems, and programming languages that would render the software obsolete. The assessment made clear that one of the museum's primary conservation strategies should be building technical documentation about the artworks. Consequently, the museum undertook a second project to build documentation about the software and hardware dependencies for 13 software-based works. While analyzing artist-rendered source code, the researchers in some cases discovered hidden information about the working methods of the artists and their programmers. This information includes the development of aesthetic properties such as color, movement, and sound. The discovery of these clues to the artists’ concerns broadened the scope of the research to include an argument for source code analysis as a tool for technical art history. In this article the authors describe the potential for adapting documentation methods from software engineering for conservation purposes, and further argue for using these methods in art-historical research.

Automatic Generation of Agents using Reusable Soft Computing Code Libraries to develop Multi Agent System for Healthcare

This paper illustrates architecture for a multi agent system in healthcare domain. The architecture is generic and designed in form of multiple layers. One of the layers of the architecture contains many proactive, co-operative and intelligent agents such as resource management agent, query agent, pattern detection agent and patient management agent. Another layer of the architecture is a collection of libraries to auto-generate code for agents using soft computing techniques. At this stage, codes for artificial neural network and fuzzy logic are developed and encompassed in this layer. The agents use these codes for development of neural network, fuzzy logic or hybrid solutions such as neuro-fuzzy solution. Third layer encompasses knowledge base, metadata and other local databases. The multi layer architecture is supported by personalized user interfaces for friendly interaction with its users. The framework is generic, flexible, and designed for a distributed environment like the Web; with minor modifications it can be employed on grid or cloud platform. The paper also discusses detail design issues, suitable applications and future enhancement of the work.

Summary-Based Context-Sensitive Data-Dependence Analysis in Presence of Callbacks

Building a summary for library code is a common approach to speeding up the analysis of client code. In presence of callbacks, some reachability relationships between library nodes cannot be obtained during library-code summarization. Thus, the library code may have to be analyzed again during the analysis of the client code with the library summary. In this paper, we propose to summarize library code with tree-adjoining-language (TAL) reachability. Compared with the summary built with context-free-language (CFL) reachability, the summary built with TAL reachability further contains conditional reachability relationships. The conditional reachability relationships can lead to much lighter analysis of the library code during the client code analysis with the TAL-reachability-based library summary. We also performed an experimental comparison of context-sensitive data-dependence analysis with the TAL-reachability-based library summary and context-sensitive data-dependence analysis with the CFL-reachability-based library summary using 15 benchmark subjects. Our experimental results demonstrate that the former has an 8X speed-up over the latter on average.

Criticality safety analysis using continuous energy libraries of MCNP code

The study of subcritical and critical systems is useful to guide decisions about design, installation and operation of some devices, mainly nuclear reactors and power plants. The information generated by these systems guides the best decisions to be made in executive project, economic viability and the safety measures to be employed in a nuclear facility. Simulating some experiments from the International Handbook of Evaluated Criticality Safety Benchmark Experiments, the MCNP5 code has been validated as an important tool to make an analysis about nuclear criticality safety. Its continuous libraries have been used. The average values and the standard deviation (SD) are evaluated. The results are very close to the values obtained by the benchmark experiments and in agreement with the criticality safety limits required by the Brazilian authorities.

ScalaLab and GroovyLab: Comparing Scala and Groovy for Scientific Computing

ScalaLab and GroovyLab are both MATLAB-like environments for the Java Virtual Machine. ScalaLab is based on the Scala programming language and GroovyLab is based on the Groovy programming language. They present similar user interfaces and functionality to the user. They also share the same set of Java scientific libraries and of native code libraries. From the programmer's point of view though, they have significant differences. This paper compares some aspects of the two environments and highlights some of the strengths and weaknesses of Scala versus Groovy for scientific computing. The discussion also examines some aspects of the dilemma of using dynamic typing versus static typing for scientific programming. The performance of the Java platform is continuously improved at a fast pace. Today Java can effectively support demanding high-performance computing and scales well on multicore platforms. Thus, both systems can challenge the performance of the traditional C/C++/Fortran scientific code with an easier to use and more productive programming environment.

ViSlang: A System for Interpreted Domain-Specific Languages for Scientific Visualization.

Researchers from many domains use scientific visualization in their daily practice. Existing implementations of algorithms usually come with a graphical user interface (high-level interface), or as software library or source code (low-level interface). In this paper we present a system that integrates domain-specific languages (DSLs) and facilitates the creation of new DSLs. DSLs provide an effective interface for domain scientists avoiding the difficulties involved with low-level interfaces and at the same time offering more flexibility than high-level interfaces. We describe the design and implementation of ViSlang, an interpreted language specifically tailored for scientific visualization. A major contribution of our design is the extensibility of the ViSlang language. Novel DSLs that are tailored to the problems of the domain can be created and integrated into ViSlang. We show that our approach can be added to existing user interfaces to increase the flexibility for expert users on demand, but at the same time does not interfere with the user experience of novice users. To demonstrate the flexibility of our approach we present new DSLs for volume processing, querying and visualization. We report the implementation effort for new DSLs and compare our approach with Matlab and Python implementations in terms of run-time performance.

Numerical study of the effect of ethanol blending with gasoline surrogate on pollutant emission in well-stirred reactor

In the present study, the effect of ethanol blending on pollutant emissions in oxidation of ethanol-gasoline mixtures is numerically investigated. In doing so, a jet-stirred reactor (JSR) is considered and one representative of each class of constituting ethanol-gasoline (iso-octane, toluene and hexene as the representative of iso-paraffin, aromatic and olefin respectively) is considered. For validating the numerical results, the available experimental data are used in temperature range of 770–1,220 K, at 10 atm. In order to simulate combustion in JSR, the CHEMKIN II library code is used. Furthermore, a detailed kinetic scheme resulting from merging of validated data for the oxidation of the ethanol-gasoline components is used in the CHEMKIN II library code. Based on the numerical results, it is shown that emissions of CO and CO2 can be reduced with the addition of the ethanol. Furthermore, it is concluded that decreasing C/H ratio by ethanol addition leads to the increase of H2O concentration.

Malware clustering using suffix trees

Clustering is an important problem in malware research, as the number of malicious samples that appear every day makes manual analysis impractical. Although these samples belong to a limited number of malware families, it is difficult to categorize them automatically as obfuscation is involved. By extracting relevant features we can apply clustering algorithms, then only analyze a couple of representatives from each cluster. However, classic clustering algorithms that compute the similarity between each pair of samples are slow when a large collection is involved. In this paper, the features will be strings of operation codes extracted from the binary code of each sample. With a modified suffix tree data structure we can find long enough substrings that correspond to portions of a program’s code. These substrings must be filtered against a database of known substrings so that common library code will be ignored. The items that have common substrings above a certain threshold will be grouped into the same cluster. Our algorithm was tested with data extracted from real-world malware and constructed quality clusters.

Computer Aided Instrument to be Used as an Automatic Design Component

The paper presents an original method to enhance the productivity of the design activity based on a dimensioning stage which integrates information from various sources: tabular data, diagrams, experimental data and others. The integration of such data in an analytic way is based on anoriginal data processorwhich interpolates data and outputs diagrams, and outputs information regarding the laws of variation expressed as comma separated values data files, as well as automatically generated source code libraries in C++, Java and MATHLAB/GNU Octave. This automatically generated code is optimized in terms of execution time and it was verified in several applications. The data processor allows the user to visually verify the output data accuracy. The paper also presents some of the applications of the data processor: automatic design, method to enhance the accuracy of computer based calculus for both analytic and numerical methods, conversion of the discontinuous experimental data into laws of variation and experimental data processing in applied elasticity. There are several directions offuture research, such as: a more general mathematical approach, development of a more general computer based instrument with increased flexibility and accuracy. Also, a complex software for applied elasticity calculi based on the results of the data processor is under development. Implementation of these applications in commercial CAD/CAE applications is another direction of research.

Investigation of (n,γ) reactions in fissionable fluids in a hybrid reactor system

Abstract In this study, the effect of (n,γ) reactions in spent fuel-grade (SFG)-PuO2, UO2, NpO2 and UCO contents was investigated in a designed hybrid reactor system. In this system, the molten salt-heavy metal mixtures 93 – 85 % Li20Sn80 + 5 % SFG-PuO2 and 2 – 10 % UO2, 93 – 85 % Li20Sn80 + 5 % SFG-PuO2 and 2 – 10 % NpO2, 93 – 85 % Li20Sn80 + 5 % SFG-PuO2 and 2 – 10 % UCO were used as fluids. Beryllium (Be) is used as neutron multiplier by (n,2n) reactions. Thence, a Be zone with a width of 3 cm was used in order to contribute on fissile fuel breeding between the liquid first wall and blanket. (n,γ) reactions were calculated in the liquid first wall, blanket and shield zones, which SFG-PuO2, UO2, NpO2 and UCO contents. 9Cr2WVTa ferritic steel with the width of 4 cm was used as the structural material. Three-dimensional nucleonic calculations were performed using the most recent version MCNPX-2.7.0 the Monte Carlo code and nuclear data library ENDF/B-VII.0.

BioC implementations in Go, Perl, Python and Ruby

As part of a communitywide effort for evaluating text mining and information extraction systems applied to the biomedical domain, BioC is focused on the goal of interoperability, currently a major barrier to wide-scale adoption of text mining tools. BioC is a simple XML format, specified by DTD, for exchanging data for biomedical natural language processing. With initial implementations in C++ and Java, BioC provides libraries of code for reading and writing BioC text documents and annotations. We extend BioC to Perl, Python, Go and Ruby. We used SWIG to extend the C++ implementation for Perl and one Python implementation. A second Python implementation and the Ruby implementation use native data structures and libraries. BioC is also implemented in the Google language Go. BioC modules are functional in all of these languages, which can facilitate text mining tasks. BioC implementations are freely available through the BioC site: http://bioc.sourceforge.net.Database URL: http://bioc.sourceforge.net/

Natural language processing pipelines to annotate BioC collections with an application to the NCBI disease corpus

BioC is a new format and associated code libraries for sharing text and annotations. We have implemented BioC natural language preprocessing pipelines in two popular programming languages: C++ and Java. The current implementations interface with the well-known MedPost and Stanford natural language processing tool sets. The pipeline functionality includes sentence segmentation, tokenization, part-of-speech tagging, lemmatization and sentence parsing. These pipelines can be easily integrated along with other BioC programs into any BioC compliant text mining systems. As an application, we converted the NCBI disease corpus to BioC format, and the pipelines have successfully run on this corpus to demonstrate their functionality. Code and data can be downloaded from http://bioc.sourceforge.net.Database URL: http://bioc.sourceforge.net

Adventures in the microlensing cloud: Large datasets, eResearch tools, and GPUs

As astronomy enters the petascale data era, astronomers are faced with new challenges relating to storage, access and management of data. A shift from the traditional approach of combining data and analysis at the desktop to the use of remote services, pushing the computation to the data, is now underway. In the field of cosmological gravitational microlensing, future synoptic all--sky surveys are expected to bring the number of multiply imaged quasars from the few tens that are currently known to a few thousands. This inflow of observational data, together with computationally demanding theoretical modelling via the production of microlensing magnification maps, requires a new approach. We present our technical solutions to supporting the GPU-Enabled, High Resolution cosmological MicroLensing parameter survey (GERLUMPH). This extensive dataset for cosmological microlensing modelling comprises over 70,000 individual magnification maps and ${\sim}10^6$ related results. We describe our approaches to hosting, organizing, and serving ${\sim}$30 Terabytes of data and metadata products. We present a set of online analysis tools developed with PHP, JavaScript and WebGL to support access and analysis of GELRUMPH data in a Web browser. We discuss our use of graphics processing units (GPUs) to accelerate data production, and we release the core of the GPU-D direct inverse ray--shooting code (Thompson et al., 2010; Astrophysics Source Code Library, record ascl:1403.001) used to generate the magnification maps. All of the GERLUMPH data and tools are available online from http://gerlumph.swin.edu.au . This project made use of gSTAR, the GPU Supercomputer for Theoretical Astrophysical Research.

UWB1 – Fast nuclear fuel depletion code

The research presented in this paper aims at the development and introduction of acomputational tool to evaluate advanced types of burnable absorbers (BA) in nuclear fuel. BAs compensate for the initial excess reactivity and consequently allow for lower power peaking factors and longer fuel cycles with higher fuel enrichments. Such a nuclear fuel design optimization requires a very fast depletion calculation in order to achieve useful results in a reasonable time. The state-of-the-art calculation scheme consists of consecutively solved inventory and transport equations for each depletion time step. Different calculation time reduction methods can be applied with the aim at simplifying or even omitting the transport part of the depletion scheme.The newly developed UWB1 code allows calculation time reduction by omitting the solution step for the Boltzmann transport equation. Therefore, microscopic cross sections are assumed to be constant throughout depletion calculation steps. The UWB1 consists of a point depletion code and a prepared set of nuclear data libraries for selected nuclear fuels. The UWB1 code is Fortran-based and employs features from state-of-art codes: (1) pointwise-based nuclear data library prepared with neutron spectra from the SCALE code package, (2) CRAM method for simplifying matrix exponential determination from SERPENT code and (3) LAPACK algebraic library for solving inverse matrices.Using typical desktop computers, solving one depletion time step for 3820 nuclides takes approximately 10s with the UWB1 code. A simplified depletion code will allow faster calculation analysis of BA parameters for optimized nuclear fuel design.

Efficiently Securing Systems from Code Reuse Attacks

Code reuse attacks (CRAs) are recent security exploits that allow attackers to execute arbitrary code on a compromised machine. CRAs, exemplified by return-oriented and jump-oriented programming approaches, reuse fragments of the library code, thus avoiding the need for explicit injection of attack code on the stack. Since the executed code is reused existing code, CRAs bypass current hardware and software security measures that prevent execution from data or stack regions of memory. While software-based full control flow integrity (CFI) checking can protect against CRAs, it includes significant overhead, involves non-trivial effort of constructing a control flow graph, relies on proprietary tools and has potential vulnerabilities due to the presence of unintended branch instructions in architectures such as x86—those branches are not checked by the software CFI. We propose branch regulation (BR), a lightweight hardware-supported protection mechanism against the CRAs that addresses all limitations of software CFI. BR enforces simple control flow rules in hardware at the function granularity to disallow arbitrary control flow transfers from one function into the middle of another function. This prevents common classes of CRAs without the complexity and run-time overhead of full CFI enforcement. BR incurs a slowdown of about 2% and increases the code footprint by less than 1% on the average for the SPEC 2006 benchmarks.