User-defined Types Research Articles

An exploration of SciDB in the context of emerging technologies for data stores in particle physics and cosmology

Traditional relational databases have not always been well matched to the needs of data-intensive sciences, but efforts are underway within the database community to attempt to address many of the requirements of large-scale scientific data management. One such effort is the open-source project SciDB. Since its earliest incarnations, SciDB has been designed for scalability in parallel and distributed environments, with a particular emphasis upon native support for array constructs and operations. Such scalability is of course a requirement of any strategy for large-scale scientific data handling, and array constructs are certainly useful in many contexts, but these features alone do not suffice to qualify a database product as an appropriate technology for hosting particle physics or cosmology data. In what constitutes its 1.0 release in June 2011, SciDB has extended its feature set to address additional requirements of scientific data, with support for user-defined types and functions, for data versioning, and more. This paper describes an evaluation of the capabilities of SciDB for two very different kinds of physics data: event-level metadata records from proton collisions at the Large Hadron Collider (LHC), and the output of cosmological simulations run on very-large-scale supercomputers. This evaluation exercises the spectrum of SciDB capabilities in a suite of tests that aim to be representative and realistic, including, for example, definition of four-vector data types and natural operations thereon, and computational queries that match the natural use cases for these data.

CRAWDAD dataset yonsei/lifemap (v.2012-01-03)

We deployed our mobility monitoring system, called LifeMap, to collect fine-grained mobility data from commercial mobile phones over two months in Seoul, Korea. The dataset contains location information (latitude and longitude) with accuracy (error bound), Wi-Fi fingerprints (MAC address and signal strength of surrounding Wi-Fi APs), user-defined types of places (workplace, cafeteria, etc.). Our system continuously collected this information every 2 to 5 minutes for everyday location monitoring.

Sequence Validation Based Extraction of Named High Cardinality Entities

One of the most useful Information Extraction (IE) solutions to Web information harnessing is Named Entity Recognition (NER). Hand-coded rule methods are still the best performers. These methods and statistical methods exploit Natural Language Processing (NLP) features and characteristics (e.g. Capitalization) to extract Named Entities (NE) like personal and company names. For entities with multiple sub-entities of higher cardinality (e.g. linux command, citation) and which are non-speech, these systems fail to deliver efficiently. Promising Machine Learning (ML) methods would require large amounts of training examples which are impossible to manually produce. We call these entities Named High Cardinality Entities (NHCEs). We propose a sequence validation based approach for the extraction and validation of NHCEs. In the approach, sub-entities of NHCE candidates are statistically and structurally characterized during top-down annotation process and guided to transformation into either value types (v-type) or user-defined types (u-type) using a ML model. Treated as sequences of sub-entities, NHCE candidates with transformed sub-entities are then validated (and subsequently labeled) using a series of validation operators. We present a case study to demonstrate the approach and show how it helps to bridge the gap between IE and Intelligent Systems (IS) through the use of transformed sub-entities in supervised learning.

Mutation Testing: Object-Oriented Mutation and Testing Tools

Software testing represents activity in detecting software failures. Mutation testing represents a way to test a test. The basic idea of mutation testing is to seed lots of artificial defects into the program, test all defects individually, focus on those mutations that are not detected, and, finally, improve the test suite until it finds all mutations. Mutants can be created by mutating the grammar and then generating strings, or by mutating values during a production. Object-oriented (OO) programming features changed the requirements for mutation testing. Non object-oriented mutation systems make mutations of expressions, variables and statements, but do not mutate type and component declarations. OO programs are composed of user-defined data types (classes) and references to the user-defined types. It is very likely that user-defined components contain many defects such as mutual dependency between members/classes, inconsistencies or conflicts between the components developed by different programmers. Class Mutation is a mutation technique for OO programs which particularly targets plausible faults that are likely to occur due to features in OO programming. Mutation testing requires automated testing tools, which is not a trivial tool to make. Automated mutation tools must be able to parse the program and know its language. When the program is run, mutant can be killed by one of two possible scenarios: if a mutant crashes, or if the mutant goes into an infinite loop.

A user-defined data type for the storage of time series data allowing efficient similarity screening

The volume of the experimentally measured time series data is rapidly growing, while storage solutions offering better data types than simple arrays of numbers or opaque blobs for keeping series data are sorely lacking. A number of indexing methods have been proposed to provide efficient access to time series data, but none has so far been integrated into a tried-and-proven database system. To explore the possibility of such integration, we have developed a data type for time series storage in PostgreSQL, an object-relational database system, and equipped it with an access method based on SAX (Symbolic Aggregate approXimation). This new data type has been successfully tested in a database supporting a large-scale plant gene expression experiment, and it was additionally tested on a very large set of simulated time series data.

Binders unbound

Implementors of compilers, program refactorers, theorem provers, proof checkers, and other systems that manipulate syntax know that dealing with name binding is difficult to do well. Operations such as α-equivalence and capture-avoiding substitution seem simple, yet subtle bugs often go undetected. Furthermore, their implementations are tedious, requiring "boilerplate" code that must be updated whenever the object language definition changes. Many researchers have therefore sought to specify binding syntax declaratively, so that tools can correctly handle the details behind the scenes. This idea has been the inspiration for many new systems (such as Beluga, Delphin, FreshML, FreshOCaml, Cαml, FreshLib, and Ott) but there is still room for improvement in expressivity, simplicity and convenience. In this paper, we present a new domain-specific language, Unbound , for specifying binding structure. Our language is particularly expressive - it supports multiple atom types, pattern binders, type annotations, recursive binders, and nested binding (necessary for telescopes, a feature found in dependently-typed languages). However, our specification language is also simple, consisting of just five basic combinators. We provide a formal semantics for this language derived from a locally nameless representation and prove that it satisfies a number of desirable properties. We also present an implementation of our binding specification language as a GHC Haskell library implementing an embedded domain specific language (EDSL). By using Haskell type constructors to represent binding combinators, we implement the EDSL succinctly using datatype-generic programming. Our implementation supports a number of features necessary for practical programming, including flexibility in the treatment of user-defined types, best-effort name preservation (for error messages), and integration with Haskell's monad transformer library.

Auto_deriv: Tool for automatic differentiation of a Fortran code

auto_deriv is a module comprised of a set of fortran 95 procedures which can be used to calculate the first and second partial derivatives (mixed or not) of any continuous function with many independent variables. The mathematical function should be expressed as one or more fortran 77/90/95 procedures. A new type of variables is defined and the overloading mechanism of functions and operators provided by the fortran 95 language is extensively used to define the differentiation rules. Proper (standard complying) handling of floating-point exceptions is provided by using the IEEE_EXCEPTIONS intrinsic module (Technical Report 15580, incorporated in fortran 2003). New version program summary Program title: AUTO_DERIV Catalogue identifier: ADLS_v2_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/ADLS_v2_0.html Program obtainable from: CPC Program Library, Queen's University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 2963 No. of bytes in distributed program, including test data, etc.: 10 314 Distribution format: tar.gz Programming language: Fortran 95 + (optionally) TR-15580 (Floating-point exception handling) Computer: all platforms with a Fortran 95 compiler Operating system: Linux, Windows, MacOS Classification: 4.12, 6.2 Catalogue identifier of previous version: ADLS_v1_0 Journal reference of previous version: Comput. Phys. Comm. 127 (2000) 343 Does the new version supersede the previous version?: Yes Nature of problem: The need to calculate accurate derivatives of a multivariate function frequently arises in computational physics and chemistry. The most versatile approach to evaluate them by a computer, automatically and to machine precision, is via user-defined types and operator overloading. AUTO_DERIV is a Fortran 95 implementation of them, designed to evaluate the first and second derivatives of a function of many variables. Solution method: The mathematical rules for differentiation of sums, products, quotients, elementary functions in conjunction with the chain rule for compound functions are applied. The function should be expressed as one or more Fortran 77/90/95 procedures. A new type of variables is defined and the overloading mechanism of functions and operators provided by the Fortran 95 language is extensively used to implement the differentiation rules. Reasons for new version: The new version supports Fortran 95, handles properly the floating-point exceptions, and is faster due to internal reorganization. All discovered bugs are fixed. Summary of revisions: • The code was rewritten extensively to benefit from features introduced in Fortran 95. Additionally, there was a major internal reorganization of the code, resulting in faster execution. The user interface described in the original paper was not changed. The values that the user must or should specify before compilation (essentially, the number of independent variables) were moved into ad_types module. • There were many minor bug fixes. One important bug was found and fixed; the code did not handle correctly the overloading of ∗ ∗ in a ∗ ∗ λ when a = 0 . • The case of division by zero and the discontinuity of the function at the requested point are indicated by standard IEEE exceptions ( IEEE_DIVIDE_BY_ZERO and IEEE_INVALID respectively). If the compiler does not support IEEE exceptions, a module with the appropriate name is provided, imitating the behavior of the ‘standard’ module in the sense that it raises the corresponding exceptions. It is up to the compiler (through certain flags probably) to detect them. Restrictions: None imposed by the program. There are certain limitations that may appear mostly due to the specific implementation chosen in the user code. They can always be overcome by recoding parts of the routines developed by the user or by modifying AUTO_DERIV according to specific instructions given in [1]. The common restrictions of available memory and the capabilities of the compiler are the same as the original version. Additional comments: The program has been tested using the following compilers: Intel ifort, GNU gfortran, NAGWare f95, g95. Running time: The typical running time for the program depends on the compiler and the complexity of the differentiated function. A rough estimate is that AUTO_DERIV is ten times slower than the evaluation of the analytical (‘by hand’) function value and derivatives (if they are available).

Data Management System for Complex Mechanical Product in Collaborative Simulation Environment

In order to implement collaborative work in enterprises, it is important to exchange and share data during product design process. According to the characteristics and types of simulation data for mechanical properties analysis, an effective data management method is presented. Based on the functional framework of collaborative simulation environment, a new database system has been designed by combining relational database and content repository. The content repository for simulation data has been established and designed by user-defined node type whose model is a simple hierarchy. In this repository, simulation metadata have been stored as node properties. Furthermore, simulation data files can be stored in node which facilitates the upload and download of files. In the mean while, simulation flow data can be stored in relational database. An engineering application is employed to demonstrate the feasibility and practicability of the data management system.

Reusable, generic program analyses and transformations

The optimizations in modern compilers are constructed for a predetermined set of primitive types. As a result, programmers are unable to exploit optimizations for user-defined types where these optimizations would be correct and beneficial. Moreover, because the set of optimizations is also fixed, programmers are unable to incorporate new optimizations into the compiler. To address these limitations, we apply the reuse methodologies from generic programming to compiler analyses and optimizations. To enable compilers to apply optimizations to classes of types rather than particular types, we define optimizations in terms of generic interface descriptions (similar to C++ concepts or Haskell type classes). By extending these interface descriptions to include associated program analysis and transformation fragments, we enable compilers to incorporate user-defined transformations and analyses. Since these transformations are explicitly associated with interface descriptions, they can be applied in generic fashion by the compiler. We demonstrate that classical compiler optimizations, when generalized using this framework, can apply to a broad range of types, both built-in and user-defined. Finally, we present an initial implementation, the principles of which are generalizable to other compilers.

Maple procedures for the coupling of angular momenta. An up-date of the Racah module

An up-date of the Racah module is presented, adopted to Maple 11 and 12, which supports both, algebraic manipulations of expressions from Racah's algebra as well as numerical computations of many functions and symbols from the theory of angular momentum. The functions that are known to the program include the Wigner rotation matrices and n-j symbols, Clebsch–Gordan and Gaunt coefficients, spherical harmonics of various kinds as well as several others.

Tightly-coupled spatial database features in the Odysseus/OpenGIS DBMS for high-performance

Conventional object-relational database management system (ORDBMS) vendors provide extension mechanisms for adding user-defined types and functions to their own DBMSs. Here, the extension mechanisms are implemented using a high-level (typically, SQL-level) interface. We call this mechanism loose-coupling. The advantage of loose-coupling is that it is easy to implement. However, it is not preferable for implementing new data types and operations in large databases when high performance is required. We have earlier proposed the tight-coupling architecture (Whang et al. 2002, 2005) to satisfy this requirement. In tight-coupling, new data types and operations are integrated into the core of the DBMS engine in the extensible type layer. Thus, they are supported in a consistent manner with high performance. This tight-coupling architecture is being used to incorporate information retrieval features and spatial database features into the Odysseus ORDBMS that has been under development at KAIST/AITrc for 19 years. In this paper, we introduce the tightly-coupled spatial database features of Odysseus/OpenGIS. By taking advantage of tight-coupling, Odysseus/OpenGIS provides excellent performance in processing spatial queries as well as flexible concurrency control and recovery on spatial data. We show the performance through extensive experiments. Finally, we present sample applications of a geographical information system (GIS) implemented using Odysseus/OpenGIS.

Research on PLM System Interoperability with a Feature-Object-Based Approach

Interoperability can be described as the interpretability of data types and related information by different computer systems. Standards for data format and communication protocols have been developed and adopted by different industries. So far, interoperability has only been investigated at the data level. This paper addresses a research approach proposing a system design and a set of generic methods so that to embed engineering knowledge and to achieve interoperability at the feature level in an open collaborative engineering environment. Ideally, the proposed new approach would allow knowledge rules to be embedded into the constraints of features supported by the complex associations of a multi-application engineering repository. Potentially, the system proposed offers user-defined feature types that support flexibility in feature-based information definition, sharing and mapping.

Database design for ecologists: Composing core entities with observations

The ecoinformatics community recognizes that ecological synthesis across studies, space, and time will require new informatics tools and infrastructure. Recent advances have been encouraging, but many problems still face ecologists who manage their own datasets, prepare data for archiving, and search data stores for synthetic research. In this paper, we describe how work by the Canopy Database Project (CDP) might enable use of database technology by field ecologists: increasing the quality of database design, improving data validation, and providing structural and semantic metadata — all of which might improve the quality of data archives and thereby help drive ecological synthesis. The CDP has experimented with conceptual components for database design, templates, to address information technology issues facing ecologists. Templates represent forest structures and observational measurements on these structures. Using our software, researchers select templates to represent their study’s data and can generate normalized relational databases. Information hidden in those databases is used by ancillary tools, including data intake forms and simple data validation, data visualization, and metadata export. The primary question we address in this paper is, which templates are the right templates. We argue for defining simple templates (with relatively few attributes) that describe the domain's major entities, and for coupling those with focused and flexible observation templates. We present a conceptual model for the observation data type, and show how we have implemented the model as an observation entity in the DataBank database designer and generator. We show how our visualization tool CanopyView exploits metadata made explicit by DataBank to help scientists with analysis and synthesis. We conclude by presenting future plans for tools to conduct statistical calculations common to forest ecology and to enhance data mining with DataBank databases. DataBank could be extended to another domain by replacing our forest–ecology-specific templates with those for the new domain. This work extends the basic computer science idea of abstract data types and user-defined types to ecology-specific database design tools for individual users, and applies to ecoinformatics the software engineering innovations of domain-specific languages, software patterns, components, refactoring, and end-user programming.

A taste of functional programming — 2

Functional programming has its roots in Alonzo Church’s lambda calculus. In the first part1 of this article, we explored some basic notions of functional programming using the language Haskell. We now examine some more advanced concepts, including polymorphism, infinite data types and computations, and user-defined data types.

Designing nesting structures of user-defined types in object-relational databases

This paper presents a methodology for designing proper nesting structures of user-defined types in object-relational databases. Briefly, we envision that users model a real-world application by using the EER model, which results in an EER schema. Our algorithm then uses the theory we developed for nested relations to generate scheme trees from the EER schema. We shall prove that the resulting scheme trees have exactly the same information content as the EER schema, and the scheme-tree instances over the resulting scheme trees do not store information redundantly. Finally, the scheme trees are transformed to Oracle Database 10 g nested object types for implementation. The algorithm in this paper forms the core of a computerized object-relational database design tool we shall develop in the future.

Matching large schemas: Approaches and evaluation

Current schema matching approaches still have to improve for large and complex Schemas. The large search space increases the likelihood for false matches as well as execution times. Further difficulties for Schema matching are posed by the high expressive power and versatility of modern schema languages, in particular user-defined types and classes, component reuse capabilities, and support for distributed schemas and namespaces. To better assist the user in matching complex schemas, we have developed a new generic schema matching tool, COMA++, providing a library of individual matchers and a flexible infrastructure to combine the matchers and refine their results. Different match strategies can be applied including a new scalable approach to identify context-dependent correspondences between schemas with shared elements and a fragment-based match approach which decomposes a large match task into smaller tasks. We conducted a comprehensive evaluation of the match strategies using large e-Business standard schemas. Besides providing helpful insights for future match implementations, the evaluation demonstrated the practicability of our system for matching large schemas.

A Behavioral Specification of Imperative Programming Languages

In this paper, we give a denotational semantics of imperative programming languages as a CafeOBJ behavioral specification. Since CafeOBJ is an executable algebraic specification language, not only execution of programs but also semi-automatic verification of programs properties can be done. We first describe an imperative programming language with integer and Boolean types, called IPL. Next we discuss about how to extend IPL, that is, IPL with user-defined types. We give a notion of equivalent programs, which is defined by using the notion of the behavioral equivalence of behavioral specifications. We show a sufficient condition for the equivalence relation of programs, which reduces the task to prove programs to be equivalent.

Object-relational complex structures for XML storage

XML data can be stored in various database repositories, including Object-Relational Database (ORDB). Using an ORDB, we get the benefit of the relational maturity and the richness of Object-Oriented modeling, including various complex data types. These data types resemble the true nature of XML data and therefore, the conceptual semantic of XML data can be preserved. However, very often when the data is stored in an ORDB repository, they are treated as purely flat tables. Not only do we not fully utilize the facilities in current ORDB, but also we do not preserve the conceptual semantic of the XML data. In this paper, we propose novel methodologies to store XML data into new ORDB data structures, such as user-defined type, row type and collection type. Our methodology has preserved the conceptual relationship structure in the XML data, including aggregation, composition and association. For XML data retrieval, we also propose query classification based on the current SQL. Compared to the existing techniques, this work has several contributions. Firstly, it utilizes the newest features of ORDB for storing XML data. Secondly, it covers a full database design process, from the conceptual to the implementation phase. Finally, the proposed transformation methodologies maintain the conceptual semantics of the XML data by keeping the structure of the data in different ORDB complex structures.

Semantic type qualifiers

We present a new approach for supporting user-defined type refinements, which augment existing types to specify and check additional invariants of interest to programmers. We provide an expressive language in which users define new refinements and associated type rules. These rules are automatically incorporated by an extensible typechecker during static typechecking of programs. Separately, a soundness checker automatically proves that each refinement's type rules ensure the intended invariant, for all possible programs. We have formalized our approach and have instantiated it as a framework for adding new type qualifiers to C programs. We have used this framework to define and automatically prove sound a host of type qualifiers of different sorts, including pos and neg for integers, tainted and untainted for strings, and nonnull and unique for pointers, and we have applied our qualifiers to ensure important invariants on open-source C programs.

Finite Element Analysis of the non Linear Behavior of a Multilayer Piezoelectric Actuator

AbstractA constitutive law for ferroelectric and ferroelastic piezoceramics is implemented in ABAQUS Standard using the subroutine user element. A linear solid element is defined: it is an eight-node hexahedron having the mechanical displacement components and the electric potential as degrees of freedom for each node. The element is formulated for static analysis and it needs the definition of the contribution of this element to the Jacobian (stiffness) and the definition of an array containing the contributions of this element to the right-hand-side vectors of the overall system of equations The subroutine is called for each element that is of a user-defined element type each time element calculations are required. As an example, the element is used for the simulation of a multilayer actuator made of piezoceramics. In this case, the piezoelectric equations are not valid since the electric loading induces non linear phenomena, which are captured through the constitutive law implemented in the user element.