waashk/dblp huggingface dataset:
call me e-mail: arranging the keyboard with a permutation-coded genetic algorithm. keyboard design is a combinatorial problem of perennial interest to those who work with computers. an evolutionary algorithm can search a space of key arrangements for one that is easy to use. its genotypes represent candidate keyboards, and its fitness function measures the difficulty of typing a specified body of text. here, a genetic algorithm seeks to arrange the twenty-six letter and six punctuation marks (four of the latter in two pairs) on three rows of ten keys each. it encodes keyboards as permutations of key positions. its evaluation function considers the relative loads on the hands, consecutive keystrokes by one hand or finger, and the relative difficulties of using individual fingers as it simulates typing a block of text. in tests using a concatenated body of text and its three components (a collection of message logs, moby dick, and the king james bible), the ga consistently evolved keyboards with markedly better evaluations than either the qwerty or dvorak keyboards, though the ga's keyboards differed depending on the text it used in its evaluation function.
individual-based simulation of the clustering behaviour of epidermal growth factor receptors. this paper describes ongoing work on a project to simulate the behaviour of epidermal growth factor receptors. these are structures which can be found on the surface of cells in the body, which receive and process chemical signals concerned with cell growth. we describe the implementation of a program which simulates the stimulation and clustering behaviour of these structures, discuss how we scale up this simulation so that we can simulate a whole cell on a tractable timescale, and discuss ongoing work in which we are calibrating our simulation against results from experiments.
a branch and prune algorithm for the approximation of non-linear ae-solution sets. non-linear ae-solution sets are a special case of parametric systems of equations where universally quantified parameters appear first. they allow to model many practical situations. a new branch and prune algorithm dedicated to the approximation of non-linear ae-solution sets is proposed. it is based on a new generalized interval (intervals whose bounds are not constrained to be ordered) parametric hansen-sengupta operator. in spite of some restrictions on the form of the ae-solution set which can be approximated, it allows to solve problems which were before out of reach of previous numerical methods. some promising experimentations are presented.
managing duplicates in a web archive. crawlers harvest the web by iteratively downloading documents referenced by urls. it is frequent to find different urls that refer to the same document, leading crawlers to download duplicates. hence, web archives built through incremental crawls waste space storing these documents. in this paper, we study the existence of duplicates within a web archive and discuss strategies to eliminate them at storage level during the crawl. we present a storage system architecture that addresses the requirements of web archives and detail its implementation and evaluation. the system is now supporting an archive for the portuguese web replacing previous nfs-based storage servers. experimental results showed that the elimination of duplicates can improve storage throughput. the web storage system outperformed nfs based storage by 68% in read operations and by 50% in write operations.1
defining coordination in multi-agent systems within an agent oriented software engineering methodology. though interactions could be considered a key entity in the design and implementation of coordination in a multi-agent system (mas), interactions alone do not suffice to capture the coordination view of a mas. they are related with the evolution of agent mental states, through the execution of tasks, and determined by the context of the organization to which agents belong. therefore, a complete specification of interactions should be more that a mere definition of a set of ordered messages. in this paper we present a semiformal description of interactions as first-class entities, and the contribution of other components of a mas to this definition. also, we present its computational realization, as a tool to animate and monitor the execution of specifications.
meta-models for building multi-agent systems. this paper reports the experience of using meta-models for improving analysis and design activities in multi-agent system engineering. four meta-models describing different views of the mas such as organization view, agent, goals/tasks, and interactions are presented. meta-models are described in uml mof which make them compatible with current software engineering formalisms. engineers may instantiate the meta- models to produce the entities that may appear in concrete mas. these meta-models have been derived from several experimentations in mas, which are briefly described in the paper. engineering experience in using the meta-models for building mas applications is also reported in the conclusions.
architect-r: a system for reconfigurable robots design. an increasing interest in the design of mobile robots has been observed in recent years, which is mainly motivated by technological advances that may allow their application to consumer markets, in addition to industrial areas.although sophisticated techniques have been developed, choosing the appropriate hardware-software partitioning and programming robot functions are still very complex tasks.current approaches often involve the design and implementation of hardwired solutions, with the associated problems of a long development cycle and inflexibility.in this paper we present a framework called architect-r, which aims to design and program specialized hardware for robots based on fpgas. we also present the first results obtained using this framework.
a coarse-grain parallel genetic algorithm for finding ramsey numbers. ramsey theory studies the existence of highly regular patterns within a large system or a set of randomly selected points or numbers. the role of ramsey numbers is to quantify some of the general existential theorems in ramsey theory. attempting to find ramsey numbers has been an arduous task that is too often unfruitful. only a handful of specific numbers are known. genetic algorithms (ga), which are based on the idea of optimizing by simulating the natural processes of evolution, have proven successful in solving complex problems that are not easily solved through conventional methods. however, premature convergence is an inherent characteristic of traditional gas that makes them incapable of searching numerous points in a problem domain. parallel ga (pga) is an extension of the classical ga that takes advantage of a ga's inherent parallelism to improve its time performance and reduce the likelihood of premature convergence. a cgga (coarse-grain ga) maintains a number of independent populations and allows for the occasional interchange of individuals. in this manner, a cgga increases the diversity of search paths and helps to stop premature convergence to nonoptimal solutions. given this motivation, a tool was developed, called sipagar (simulated parallel genetic algorithm for finding ramsey numbers), that allows us to verify and validate the superior performance of cggas over traditional gas applied to the problem of improving the bounds of classical ramsey numbers. significant differences between the simulated cgga and traditional ga were observed in both the premature convergence rate and the quality of the results. this leads us to the conclusion that future cgga-based attempts to improve the bounds of ramsey numbers will probably be more promising than those based on traditional gas.
empirical evaluation of openccm for java-based distributed, real-time, and embedded systems. component technology can overcome many limitations of conventional object request brokers (orbs) in developing distributed, real-time, and embedded (dre) applications. component technology has particular advantages for building large-scale dre systems. the corba component model (ccm) enables the composition and reuse of software components and the configuration of key non-functional aspects of dre systems such as timing, fault-tolerance, and security. however, the ccm can introduce additional overhead to the runtime performance and code size of middleware. hence, the overhead for using the ccm needs to be evaluated to determine if the ccm can be effectively employed in the design of high-reliability dre applications. in this paper, we empirically evaluated the performance of openccm, a java-based implementation of the ccm standard, when configured with two java orbs: with zen, a real-time java orb, and with openorb, a desktop java orb. we measured throughput, latency, and jitter of method invocations for both orbs configured with and without openccm. we also measured the additional memory requirement introduced by the ccm implementation. we concluded that openccm adds some overhead to both java orbs, affecting openorb's performance more than zen's. more development of the ccm may be necessary to bring its advantages to high-performance dre systems.
controlling data movement in global computing applications. we present a programming notation aiming at protecting the secrecy of both host and agent data in global computing applications. the approach exploits annotations with sets of node addresses, called regions. a datum can be annotated with a region that specifies the network nodes that are allowed to interact with it. network nodes come eqipped with two region annotations specifying the nodes that can send data and spawn processes over them. the langauge semantics guarantees that computation proceeds according to these region constraints. to minimize the overhead of runtime checks, a static compilation phase is exploited. the proposed approach is largely independent of a specific programming language; however, to put it in concrete form, here we focus on its integration within the process language &mu;klaim. we prove that in compiled &mu;klaim nets, data can be manipulated only by authorized users. we also give a more local formulation of this property, where only a subnet is compiled. finally, we use our theory to model the secure behaviour of a unix-like multiuser system.
editorial message: special track on dependable and adaptive distributed systems. distributed systems and databases are at the core of the information society and increasingly pervade many aspects of our daily lives. while mobility and pervasiveness require support for systems that adapt themselves to changing environments, the middleware infrastructures become more and more heterogeneous and complex. in addition, we can see an increasing demand for dependability of such systems, taking into account the software as well as the surrounding environment. generally, adaptiveness can either satisfy a change in user requirements or seek to fulfill the same requirements in a changing system context and environment. in particular, adaptation is also a means to achieve dependability in a computing infrastructure with dynamically varying structure and properties. fault tolerance can consequently be seen as a special case, where the adaptation seeks to overcome an otherwise negative effect of a change in the computing infrastructure that can be classified as a fault. however, dependability can not only be achieved by fault tolerance, but also by other means like fault avoidance (e.g. through formal methods). therefore, future middleware needs to support adaptiveness and dependability while maintaining scalability and mastering complexity. still, software legacy must be integrated in a way, such that open and standardized interfaces support not only functional integration, but also a seamless integration of non-functional aspects. moreover, service-oriented architectures need coordination in order to achieve dependability and can further benefit from context-aware approaches.
interface utilization in the java development kit. interfaces as defined in the java programming language can enhance both decoupling and comprehensibility of large code bases. several researchers have pointed out this key role of interfaces in object-oriented programming, but so far only little insight as to how interfaces are actually used in practice has been made avilable. we fill this gap by applying a special metrics suite to one of the most popular pieces of software, the java development kit, and present interesting results.
a quantitative analysis of implicational paradoxes in classical mathematical logic. classical mathematical logic includes a lot of ''implicational paradoxes'' as its logic theorems. this paper uses the property of strong relevance as the criterion to identify implicational paradoxes in logical theorems of classical mathematical logic, and enumerates logical theorem schemata of classical mathematical logic that do not satisfy the strong relevance. this quantitative analysis shows that classical mathematical logic is by far not a suitable logical basis for automated forward deduction.
on considering an interval constraint solving algorithm as a free-steering nonlinear gauss-seidel procedure. we show that a classical interval constraint propagation algorithm enforcing box consistency may be interpreted as a free-steering nonlinear gauss-seidel procedure. this suggests that the choice of a transversal in the incidence matrix associated with the problem to solve is paramount to the efficiency of the algorithm. we present experimental evidences that it is indeed so, and we suggest an heuristics to compute good transversals. the improved interval constraint algorithm is compared with a classical one and with standard methods such as hansen-sengupta on some well-known benchmarks.
controlled propagation in continuous numerical constraint networks. local consistency is usually enforced on continuous constraints by decomposing them beforehand into so-called primitive constraints. it has long been observed that such a decomposition drastically slows down the computation of solutions. five years ago, benhamou et al. introduced an algorithm that avoids formally decomposing constraints, and whose efficiency is often on a par with state-of-the-art methods. it is shown here that this algorithm implements a strategy to enforce on a continuous constraint a consistency akin to directional bounds consistency as introduced by dechter and pearl for discrete problems. the actual impact of decomposition is also thoroughly analyzed by means of new experimental results.
automatic code generation for executing tiled nested loops onto parallel architectures. this paper presents a novel approach for the problem of generating tiled code for nested for-loops using a tiling transformation. tiling or supernode transformation has been widely used to improve locality in multi-level memory hierarchies as well as to efficiently execute loops onto non-uniform memory access architectures. however, automatic code generation for tiled loops can be a very complex compiler work due to non-rectangular tile shapes and iteration space bounds. our method considerably enhances previous work on rewriting tiled loops by considering parallelepiped tiles and arbitrary iteration space shapes. the complexity of code generation for tiling transformation is now reduced to the complexity of code generation for any linear transformation. experimental results which compare all so far presented approaches, show that the proposed approach for generating tiled code is significantly accelerated.
automatic parallel code generation for tiled nested loops. this paper presents an overview of our work, concerning a complete end-to-end framework for automatically generating message passing parallel code for tiled nested for-loops. it considers general parallelepiped tiling transformations and general convex iteration spaces. we address all problems regarding both the generation of sequential tiled code and its parallelization. we have implemented our techniques in a tool which automatically generates mpi parallel code and conducted several series of experiments, concerning the compilation time of our tool, the efficiency of the generated code and the speedup attained on a cluster of pcs. apart from confirming the value of our techniques, our experimental results show the merit of general parallelepiped tiling transformations and verify previous theoretical work on scheduling-optimal tile shapes.
double- and triple-step incremental linear interpolation. incremental linear interpolation determines the set of n+1 equidistant points on an interval [a,b] where all variables involved (n, a, b, and the set of equidistant points) are integers and n
pseudozero set of interval polynomials. interval polynomials are useful to describe perturbed polynomials. we present a graphical tool to describe how perturbations of the polynomial coefficients affect its zeros without using interval arithmetic nor matrix representation. this tool implements real pseudozero set that differ from the well known complex pseudozero set restricting perturbations to be real and applied to real polynomials. we introduce a computable formula for this real pseudozero set and compare complex and real pseudozero sets. we propose a graphical matlab interface to draw zeros of such interval polynomials.
improving the compensated horner scheme with a fused multiply and add. several different techniques and softwares intend to improve the accuracy of results computed in a fixed finite precision. here we focus on a method to improve the accuracy of the polynomial evaluation. it is well known that the use of the fused multiply and add operation available on some microprocessors like intel itanium improves slightly the accuracy of the horner scheme. in this paper, we propose an accurate compensated horner scheme specially designed to take advantage of the fused multiply and add. we prove that the computed result is as accurate as if computed in twice the working precision. the algorithm we present is fast since it only requires well optimizable floating point operations, performed in the same working precision as the given data.
inner approximation of distance constraints with existential quantification of parameters. this paper presents and compares two methods for checking if a box is included inside the solution set of an equality constraint with existential quantification of its parameters. we focus on distance constraints, where each existentially quantified parameter has only one occurrence, because of their usefulness and their simplicity. the first method relies on a specific quantifier elimination based on geometric considerations whereas the second method relies on computations with generalized intervals (interval whose bounds are not constrained to be ordered). we show that on two dimensions problems, the two methods yield equivalent results. however, when dealing with higher dimensions, generalized intervals are more efficient.
parallel hypothesis driven video content analysis. extraction of features from images, followed by pattern classification, is a promising approach to automatic video analysis. however, a parallel processing environment is typically required for real-time performance. still, single-cpu bayesian network systems for hypothesis driven feature extraction have been able to classify image content real-time --- the expected information value and processing cost of features are measured, and only efficient features are extracted. the goal in this paper is to combine the processing benefits of parallel and hypothesis driven approaches. we use dynamic bayesian networks to specify video analysis tasks and the particle filter (pf) for approximate inference, i.e., feature selection and classification. the inference accuracy of any given pf is determined by the number of particles it maintains. to increase the number of particles maintained without reducing the processing rate, we apply multiple pfs distributed in a lan, and a pooling system to coordinate their output. our resulting multi-pf architecture supports three video frame processing phases: a parallelized feature selection phase, followed by a parallelized feature extraction- and classification phase. unfortunately, we observe a loss of inference accuracy when splitting a single pf into multiple independent pfs. to reduce this loss, we let the pooled pfs exchange particles across the lan. an object tracking simulation demonstrates the ability of our architecture to select efficient features as well as the effectiveness of our particle exchange scheme --- we observe a significant increase in inference accuracy compared to the tested non-parallel pf.
secs: scalable edge-computing services. we present the architecture of a scalable and dynamic intermediary infrastructure for developing and deploying advanced edge computing services, by using a cluster of heterogeneous machines. our main goal is to address the challenges of the next-generation internet services: scalability, high availability, fault-tolerance and robustness. moreover, secs offers an easy, "on-the-fly" and per-user configuration of services. the architecture is based on ibm's web based intermediaries (wbi) [8, 9].
on designing a low-power garbage collector for java embedded devices: a case study. this paper presents an energy consumption comparison between two well-known garbage collection algorithms---mark-sweep-compact and reference counting. our goal is to evaluate the suitability of reference counting as an algorithm for memory-constrained java embedded devices. we hypothesize that reference counting would be suitable because it has higher data locality, which should reduce the number of data-cache misses, and so reduce energy consumption. however, this benefit could be offset by the extra instructions required for each reference update, a basic requirement of reference counting. to test our hypothesis, we implement, into sun's kvm, a hybrid scheme that combines a standard mark-sweep-compact collector and limited-field reference counting. our hybrid scheme is then compared against the default kvm with only mark-sweep-compact. we investigate several performance metrics that contribute to the performance of the system, including number of garbage collections, instructions, level-1 instruction and data cache misses, and total energy consumption.based on our observations, the hybrid scheme yields three important benefits: (a) the hybrid scheme reclaims most memory quickly, resulting in less mark-sweep garbage collection invocations, (b) the reduction in garbage collection improves cache locality and reduces the number of main memory accesses, and (c) the reduction in memory accesses ultimately results in lower energy consumption, since a memory access can be energy-intensive. our results confirm our hypothesis, with the hybrid scheme requiring up to 59% less energy than the default kvm.
automatic generation of application-specific systems based on a micro-programmed java core. this paper describes a co-design based approach for automatic generation of application specific systems, suitable for fpga-centric embedded applications. the approach augments a processor core with hardware accelerators extracted automatically from a high-level specification (java) of the application, to obtain a custom system, optimised for the target application. we advocate herein the use of a microprogrammed core as the basis for system generation in order to hide the hardware access operations in the micro-code, while conserving the core data-path (and clock frequency). to prove the feasibility of our approach, we also present an implementation based on a modified version of the java optimized processor soft core on a xilinx virtex-ii fpga.