Search

Improving the performance of applications is a core target of computer systems research and has led to the creation of various techniques. Among them is function memoization, an intuitive technique that, unfortunately, failed to live up to its promised potential. Traditional function memoization falls short mainly because it is input-based, meaning the system needs to pattern-match the current invocations inputs with previously seen ones to decide which memoized output value to return. This is often computationally intensive and only suitable for a limited set of functions. However, function calls often exhibit temporal value locality on their output. We capitalize on this observation to create the first output-based function memoization technique. We demonstrate that compiler-directed output-based memoization reduces energy and runtime by 50 to 75 percent (2-4x speedup) at the cost of a relatively small degradation of the applications output quality. [ABSTRACT FROM AUTHOR]

Abstract: The automation of user routine tasks is one of the most important challenges in the development of Ambient Intelligence systems. However, this automation may be annoying since some tasks may grab users attention in inappropriate situations. Since user attention is a valuable resource, task automation must behave in a considerate manner demanding user attention only when it is required. To address this issue, this work presents a systematic method for supporting the design and automation of unobtrusive routine tasks that can adjust their obtrusiveness level at runtime according to the user attentional resources and context. This method proposes to design the routine tasks that the system must carry out and how they must interact with users in terms of obtrusiveness. The method also provides a software infrastructure that makes the execution of the tasks at the appropriate obtrusiveness degree a reality. Finally, the system has been validated by means of usefulness and performance tests and a practical case study that demonstrates the correctness and applicability of our approach without compromising system performance. [Copyright &y& Elsevier]

Abstract: We show that polynomial-time randomness (p-randomness) is preserved under a variety of familiar operations, including addition and multiplication by a nonzero polynomial-time computable real number. These results follow from a general theorem: If is an open interval, is a function, and is p-random, then is p-random provided [1.] f is p-computable on the dyadic rational points in I, and [2.] f varies sufficiently at r, i.e., there exists a real constant such that either or Our theorem implies in particular that any analytic function about a p-computable point whose power series has uniformly p-computable coefficients preserves p-randomness in its open interval of absolute convergence. Such functions include all the familiar functions from first-year calculus. [Copyright &y& Elsevier]

Abstract: The present article studies off-diagonal decay properties of Moore–Penrose pseudoinverses of (bi-infinite) matrices satisfying an analogous condition. Off-diagonal decay in our paper is considered with respect to specific index distance functions which incorporates those usually used for the study of localization properties for wavelet frames but also more general systems such as curvelets or shearlets. Our main result is that if a matrix satisfies an off-diagonal decay condition, then its Moore–Penrose pseudoinverse satisfies a similar condition. Applied to the study of frames this means that, if a wavelet, curvelet or shearlet frame is intrinsically localized, then its canonical dual is, too. [Copyright &y& Elsevier]

Abstract: A new method of constructing 1-Lipschitz aggregation functions is proposed and studied. As a by product, a new method of constructing (quasi-)copulas from a given (quasi-)copula C is obtained. Newly constructed copulas are negative quadrant dependent for any original copula C. The only invariant copula under this construction is the Fréchet–Höffding lower bound W. The method preserves several important properties of copulas, such as modularity, absolute continuity or symmetry, and commutes with some other constructions, e.g., the construction of survival copulas. [Copyright &y& Elsevier]

Abstract: In many practical applications, the need arises to aggregate data of varying dimension. Following from the self-identity property, some recent studies have looked at the stability of aggregation operators in terms of their behavior as the dimensionality is increased from to n. We use the penalty-based representation of aggregation functions in order to investigate the conditions for weighting vectors associated with some important weighted families, extending on the results already established for quasi-arithmetic means. In particular, we obtain results for quasi-medians and functions that involve a reordering of the inputs such as the OWA and order statistics. [Copyright &y& Elsevier]

Abstract: In functional programming it is common to write programs as compositions of other simpler functions. This makes it possible to take advantage of the well-known benefits of modular programming. However, in many cases, the resulting programs have efficiency problems caused by the generation of data structures that are solely used for communication between the functions that take part in the compositions. Many of those intermediate structures can be eliminated by an appropriate combination of the codes of the involved functions using a technique called program fusion. In this work, we propose a program fusion technique for accumulations, which are recursive functions that use additional parameters, called accumulators, for keeping intermediate results. Accumulations are known to be difficult to be fused because of the presence of the accumulators and the fact that results are usually computed in those parameters. Our technique is based on a shortcut fusion approach which turns out to be effective in the case of accumulations. We present benchmarks that illustrate the impact of shortcut fusion on accumulations. [Copyright &y& Elsevier]

Highlights: [•] A new approach for the formation of type-2 membership functions is introduced. [•] The footprint of uncertainty is formed by using rectangular type-2 fuzzy granules. [•] This new approach provides more degrees of freedom and design flexibility in type-2 fuzzy logic systems. [•] Mathematical expressions and derivative computations of granular type-2 membership functions are very simple. [•] Type-2 fuzzy logic systems using granular type-2 membership functions have more potential to model and handle uncertainties. [ABSTRACT FROM AUTHOR]

The article offers information on the changes made in the computer program language R 3.0.1. It states that this new language has included many features in its different versions such as mcparallel which starts with R process has a new argument known as mc.interactive. It informs about the changes in R 3.0.0 which include a new argument that can be used when comparing functions.

Abstract: The particle swarm optimization method (PSO) is one of population-based optimization techniques for global optimization, where a number of candidate solutions called particles simultaneously move toward the tentative solutions found by particles so far, which are called the personal and global bests, respectively. Since, in the PSO, the exploration ability is important to find a desirable solution, various kinds of methods have been investigated to improve it. In this paper, we propose a PSO with a new chaotic system derived from the steepest descent method for a virtual quartic objective function with perturbations having its global minima at the personal and global bests, where elements of each particle’s position are updated by the proposed chaotic system or the standard update formula. Thus, the proposed PSO can search for solutions around the personal and global bests intensively without being trapped at any local minimum due to the chaoticness. Moreover, we show approximately the sufficient condition of parameter values of the proposed system under which the system is chaotic. Through computational experiments, we verify the performance of the proposed PSO by applying it to some global optimization problems. [Copyright &y& Elsevier]

This paper studies the notions of self-reducibility and autoreducibility. Our main result regarding length-decreasing self-reducibility is that any complexity class $\mathcal{C}$ that has a (logspace) complete language and is closed under polynomial-time (logspace) padding has the property that if all $\mathcal{C}$ -complete languages are length-decreasing (logspace) self-reducible then $\mathcal{C}\subseteq \mathrm {P}$ ( $\mathcal {C}\subseteq \mathrm {L}$ ). In particular, this result applies to NL, NP and PSPACE. We also prove an equivalent of this theorem for function classes (for example, for #P). We also show that for several hard function classes, in particular for #P, it is the case that all their complete functions are deterministically autoreducible. In particular, we show the following result. Let f be a #P parsimonious function with two preimages of 0. We show that there are two FP functions h and t such that for all inputs x we have f( x)= t( x)+ f( h( x)), h( x)≠ x, and t( x)∈{0,1}. Our results regarding single-query autoreducibility of #P functions can be contrasted with random self-reducibility for which it is known that if a #P complete function were random self-reducible with one query then the polynomial hierarchy would collapse. [ABSTRACT FROM AUTHOR]

This paper reported another recovery model to enhance system survivability. The model focuses on how to preserve the system and resume its critical service while incident occurs by reconfiguring the damaged critical service resources based on available resources without affecting the stability and functioning of the system. There are three critical requisite conditions in this recovery model: the number of pre-empted non-critical service resources, the response time of resource allocation, and the cost of reconfiguration, which are used in some scenarios to find and re-allocate the available resource for the reconfiguration. To validate the viability of the approach, one instance case is provided. The adoption of fault-tolerance and survivability using redundancy re-allocation in this recovery model is discussed from a new perspective. [ABSTRACT FROM AUTHOR]

This paper addresses the schedulability problem of periodic and sporadic real-time task sets with constrained deadlines preemptively scheduled on a multiprocessor platform composed by identical processors. We assume that a global work-conserving scheduler is used and migration from one processor to another is allowed during a task lifetime. First, a general method to derive schedulability conditions for multiprocessor real-time systems will be presented. The analysis will be applied to two typical scheduling algorithms: Earliest Deadline First (EDF) and Fixed Priority (FP). Then, the derived schedulability conditions will be tightened, refining the analysis with a simple and effective technique that significantly improves the percentage of accepted task sets. The effectiveness of the proposed test is shown through an extensive set of synthetic experiments. [ABSTRACT FROM AUTHOR]

The authors discuss Universal Multimedia Access (UMA), which promises to adaptively deliver multimedia content to users according to their needs. Central to UMA is the development of metadata standards for describing multimedia resources to allow their adaptation. The authors report on the development of the Bitstream Syntax Description Language (BSDL), which allows computers to perform operations on data without requiring specific software for every format they might encounter. The article describes applications for scalable content adaptation, format independent streaming, and delivery and configurable media coding.

We present a program-generation approach to address a software-reuse challenge in the area of scientific computing. More specifically, we describe the design of a program generator for the specification of subroutines that can be generic in the dimensions of arrays, parameter lists, and called subroutines. We describe the application of that approach to a real-world problem in scientific computing which requires the generic description of inverse ocean modeling tools. In addition to a compiler that can transform generic specifications into efficient Fortran code for models, we have also developed a type system that can identify possible errors already in the specifications. This type system is important for the acceptance of the program generator among scientists because it prevents a large class of errors in the generated code. [ABSTRACT FROM AUTHOR]

A number of authors have looked at the problem of deriving a checking experiment from a nondeterministic finite state machine that models the required behaviour of a system. We show that these methods can be extended if it is known that the implementation is equivalent to some (unknown) deterministic finite state machine. When testing a deterministic implementation, the test output provides information about the implementation under test and can thus guide future testing. The use of an adaptive test process is thus proposed. [ABSTRACT FROM AUTHOR]

SUMMARY The subroutine system FIT is a new algorithm for the fitting of statistical models to data. Its purpose is to make available a wide range of model-fitting procedures in a single system. At the same time, the algorithm is a case study for the design of statistical computing systems; a number of relevant questions (and possibly a few answers) have arisen during the design of the system. [ABSTRACT FROM AUTHOR]

Reusability is the probability in a fragment of original code that can be utilized again to unite late functionalities with slight or no change. Reusable modules and classes lessen implementation time, expand the possibility that earlier testing and then utilize has wiped out bugs and limits code adjustments when a modification in implementation is needed. Subroutines or works are the most basic shape of reuse. These approaches have multiple and cross cutting impacts on the development practices and quality attributes pragmatic studies in industry answer questions why and when certain approaches are chosen, how these are approached which impact on the system. It involves designing and implementing software components, assembling system from prebuilt components and deploying system into their target environments A piece of code is normally composed utilizing modules or namespaces into layers. Reusability suggests some explicit administration of assemble, bundling, dissemination, instatement, setup, organization, maintenance and redesign issues. [ABSTRACT FROM AUTHOR]

The article presents some references on digital representation of human movement. Digital system BUCK76 contains the development of a choreographic notation called English Language Dance Notation (ELDN), a natural language notation that uses only typewritten characters. The structure of the notation reflects programming language notations of subroutine and block structure. The thesis contains a short history of dance notation and an analysis of dance movement, discussions on the translation from ELDN and a structured design for a computer implementation of ELDN. Another digital system TRAC74 demonstrates a way into Labanotation, a computer-aided dance notation system.

High confidence in floating-point programs requires proving numerical properties of final and intermediate values. One may need to guarantee that a value stays within some range, or that the error relative to some ideal value is well bounded. This certification may require a time-consuming proof for each line of code, and it is usually broken by the smallest change to the code, e.g., for maintenance or optimization purpose. Certifying floating-point programs by hand is, therefore, very tedious and error-prone. The Gappa proof assistant is designed to make this task both easier and more secure, due to the following novel features: It automates the evaluation and propagation of rounding errors using interval arithmetic. Its input format is very close to the actual code to validate. It can be used incrementally to prove complex mathematical properties pertaining to the code. It generates a formal proof of the results, which can be checked independently by a lower level proof assistant like Coq. Yet it does not require any specific knowledge about automatic theorem proving, and thus, is accessible to a wide community. This paper demonstrates the practical use of this tool for a widely used class of floating-point programs: implementations of elementary functions in a mathematical library. [ABSTRACT FROM AUTHOR]