Abstract: A superresolution electro-optic imaging system operates in a manner that takes into account the different subsystems For example, rather than designing the optical subsystem to be diffraction-limited, the optical subsystem can be designed in a manner that is better suited for subsequent superresolution processing and/or that reduces aliasing effects

Abstract: We present a novel framework for defining memory models in terms of two properties: thread-local Instruction Reordering axioms and Store Atomicity, which describes inter-thread communication via memory. Most memory models have the store atomicity property, and it is this property that is enforced by cache coherence protocols. A memory model with Store Atomicity is serializable; there is a unique global interleaving of all operations which respects the reordering rules. Our framework uses partially ordered execution graphs; one graph represents many instruction interleavings with identical behaviors. The major contribution of this framework is a procedure for enumerating program behaviors in any memory model with Store Atomicity. Using this framework, we show that address aliasing speculation introduces new program behaviors; we argue that these new behaviors should be permitted by the memory model specification. We also show how to extend our model to capture the behavior of non-atomic memory models such as SPARC R TSO.

Abstract: Computer graphics textbooks teach that sampling by deterministic patterns or even lattices causes aliasing, which only can be avoided by random, i.e. independent sampling. They recommend random samples with blue noise characteristic, which however are highly correlated due to their maximized minimum mutual distance. On the other hand the rendering software mental ray, which is used to generate the majority of visual effects in movies, entirely is based on parametric integration by quasi-Monte Carlo methods and consequently is strictly deterministic. For its superior quality the software even received a Technical Achievement Award (Oscar) by the American Academy of Motion Picture Arts and Sciences in 2003. Along the milestones of more than ten years of development of quasi-Monte Carlo methods in computer graphics, we point out that the two previous statements are not contradictory.

Abstract: Reasoning about multithreaded object-oriented programs is difficult, due to the non-local nature of object aliasing, data races, and deadlocks. We propose a programming model that prevents data races and deadlocks, and supports local reasoning in the presence of object aliasing and concurrency. Our programming model builds on the multi-threading and synchronization primitives as they are present in current mainstream languages. Java or C# programs developed according to our model can be annotated by means of stylized comments to make the use of the model explicit. We show that such annotated programs can be formally verified to comply with the programming model. In other words, if the annotated program verifies, the underlying Java or C# program is guaranteed to be free from data races and deadlocks, and it is sound to reason locally about program behavior. We have implemented a verifier for programs developed according to our model in a custom build of the Spec# programming system, and have validated our approach on a case study.

Abstract: Many state-based specification languages, including the Java Modeling Language (JML), contain at their core specification constructs familiar to most undergraduates: e.g., assertions, pre- and postconditions, and invariants. Unfortunately, these constructs are not sufficiently expressive to permit formal modular verification of programs written in modern object-oriented languages like Java. The necessary extra constructs for specifying an object-oriented module include (perhaps the less familiar) frame properties, datagroups, and ghost and model fields. These constructs help specifiers deal with potential problems related to, for example, unexpected side effects, aliasing, class invariants, inheritance, and lack of information hiding. This tutorial paper focuses on JML's realization of these constructs, explaining their meaning while illustrating how they can be used to address the stated problems.

Abstract: We present an original approach for the automated computation of model-based test cases from specifications written in Java Modeling Language (JML). We aim at activating all the behaviors from the JML method specifications. Therefore, we extract each behavior and we compute the pertinent test data for the input parameters; we select the boundary values of the ordered domains, and we consider specific features for the objects, involving inheritance and aliasing. Finally, a preamble for each test case is computed by symbolic animation of the JML specification using constraint logic programming techniques. Thus, we are able to automatically generate executable Java test sequences to be run on the system under test. Moreover, this process requires the less possible intervention from a validation engineer.

Abstract: This paper describes a method for solving the permutation problem of frequency-domain blind source separation (BSS). The method analyzes the mixing system information estimated with independent component analysis (ICA). When we use widely spaced sensors or increase the sampling rate, spatial aliasing may occur for high frequencies due to the possibility of multiple cycles in the sensor spacing. In such cases, the estimated information would imply multiple possibilities for a source location. This causes some difficulty when analyzing the information. We propose a new method designed to overcome this difficulty. This method first estimates the model parameters for the mixing system at low frequencies where spatial aliasing does not occur, and then refines the estimations by using data at all frequencies. This refinement leads to precise parameter estimation and therefore precise permutation alignment. Experimental results show the effectiveness of the new method.

Abstract: Reasoning about multithreaded object-oriented programs is difficult, due to the non-local nature of object aliasing, data races, and deadlocks. We propose a programming model that prevents data races and deadlocks, and supports local reasoning in the presence of object aliasing and concurrency. Our programming model builds on the multi-threading and synchronization primitives as they are present in current mainstream languages. Java or C# programs developed according to our model can be annotated by means of stylized comments to make the use of the model explicit. We show that such annotated programs can be formally verified to comply with the programming model. In other words, if the annotated program verifies, the underlying Java or C# program is guaranteed to be free from data races and deadlocks, and it is sound to reason locally about program behavior. We have implemented a verifier for programs developed according to our model in a custom build of the Spec# programming system, and have validated our approach on a case study.

Abstract: Java iterators are notoriously hard to specify. This paper applies a general typestate specification technique that supports several forms of aliasing to the iterator problem. The presented specification conservatively captures iterator protocols and consistency rules. Two limitations of the specification are discussed.

Abstract: When many effects are under consideration in a screening experiment, it may be necessary to use designs with complex aliasing patterns, especially when interactions and higher-order effects exist In this situation, the selection of subsets of active effects is a challenging problem This chapter describes Bayesian methods for subset selection, with emphasis on the choice of prior distributions and the impact of this choice on subset selection, computation, and practical analysis Attention is focused on experiments where a linear regression model with Gaussian errors describes the response Ideas are illustrated through an experiment in clinical laboratory testing and through an example with simulated data Advantages of the Bayesian approach are stressed, such as the ability to incorporate useful information about which subsets of effects are likely to be active For example, an AB interaction effect might only be considered active if main effects for A and B are also likely to be active When such information is combined with a stochastic search for promising subsets of active effects, a powerful subset selection tool results The techniques may also be applied to designs without complex aliasing as a way of quantifying uncertainty in subset selection

Abstract: In this paper the problem of producing an enlarged image from a given digital image is addressed (zooming). Different image interpolation techniques are used for image enlargement. During interpolation, preserving details and smoothing data at the same time for not introducing spurious artifacts (i.e. Aliasing) is difficult. A complete and a definitive solution to this problem is still an open issue. Although there are some well known methods in the market Parket [14], Sakamote [16], the paper proposes a method that considers discontinuities and luminance variations in a sequence of non linear iterations steps. All the pixels present near the edges are diffused into the edge in a way that aliasing is reduced to a greater extent. Hence the proposed method is completed in limited computational resources. The proposed method preserves edges and brings smoothness and at the same time controls the aliasing effect.

Abstract: There is provided a method of processing an ultrasound spectrum image. According to such method, a spectrum image is formed based on ultrasound data and then the noise is removed from the spectrum image. The noise-removed spectrum image is matched with one or more spectrum models representing specific spectrum types. Then, whether or not the noise-removed spectrum image contains an aliasing is checked. If the noise-removed spectrum image contains the aliasing, then the aliasing is removed from the noise-removed spectrum image to provide a noise-removed spectrum image without the aliasing. Thereafter, contour tracing is performed on the noise-removed spectrum image without the aliasing to detect contour points. Further, peak tracing is performed on the noise-removed spectrum image without the aliasing to detect peaks.

Abstract: Aliasing occurs when two variables refer to the same memory location. This technique has been exploited for constructing resilient obfuscation transforms in languages that extensively use indirect referencing. The theoretical basis for these transforms is derived from the hard complexity results of precisely determining which set of variables refer to the same memory location at a given program point during execution. However, no method is known for randomly generating hard problem instances. Unless we are able to evaluate the obfuscatory strength of these transforms using static analysis tools, we cannot correlate the resilience expected in theory with what actually holds in practice. In this contribution, we will outline the main difficulties in experimentally evaluating obfuscatory strength and give an overview of techniques that are suited for analysing well-established alias-based obfuscation transforms.

Abstract: Privacy is an important freedom, and in the modern world of technology, the probability of our private data being comprised is more likely than in the days before computers since all of our data can be stored electronically and possibly accessed from an outside location. This paper presents a methodology for steganography based on hiding images in the Fourier domain of an image by using the properties of zero-padding an image with itself causing aliasing to occur. Seventy-five percent of the resulting spectrum before any data is embedded in the image, has the value of zero. These zeros can be changed slightly where the change in the image is not noticeable. The data changes due to formatting an image in a 24-bit color format. This change can be accounted for using a transfer function which would also be needed to decrypt the information. The reason for this approach comes from the flexibility in the amount of data which can be hidden in an image and the location of the hidden data. The proposed method would also be advantageous in the manner that a person would need four images and a transfer function or a key so to speak, to recover the data. They would also have to know what order to put the four images before decryption can occur. This adds a level of complexity to steganography which can help to insure the data being sent is kept private.

Abstract: Table lookup oscillators form a basic building block of most software synthesis systems. Several of the classical digital and analog synthesis techniques require their use. The classical table lookup oscillator [1, 2] is commonly discussed regarding its amplitude error, but another source of error is mostly disregarded, although it influences the sound quality to a much higher degree, especially when running the oscillators at elevated frequencies. This error is due to the aliasing effect that occurs when shifting (or resampling) the original lookup table at higher rates. One obstacle that has been encountered when trying to emulate classical analog synthesizers, is that the naive implementation of waveforms for subtractive synthesis generate the same aliasing frequencies. Over the years, several solutions for the problem of generating high quality band-limited waveforms for emulating classical analog synthesis have been proposed, solving the problem for specific waveforms. Never-the-less, the general question of how to manage aliasing behavior efficiently in general table lookup oscillators is still not resolved. This article reviews existing techniques for analog synthesis and tries to expand them for the general case.

Abstract: We present aliasing models for statistical response compacters (SRCs) for built-in self-testing (BIST) (Khan and Bushnell, 2004). The SRCs are drastically different from the conventional multiple-input signature register (MISR), and use the signal processing Hadamard transform to extract the digital spectral content in output bit streams of circuits and store it in counters. Any deviation of the spectral content from the good machine spectral content indicates a fault. We use the asymmetric error model (AEM) (Xavier et al., 1992) to describe the behavior of a response compacter for a faulty circuit-under-test (CUT). We construct Markov processes for the aliasing models of the response compacters, which have never been studied. The Markov processes iteratively compute exact aliasing probabilities for any test session length and determine the asymptotic probability of aliasing for statistical response compactor 1 (SRC1). Other compacters (SRC2 and SRC5) have too many Markov process states and formulating exact aliasing probability equations is infeasible. So, we present only the asymptotic aliasing probability results, which converge to very low values rapidly. SRC1 does not alias at all on the ISCAS '89 benchmarks, but SRC2 and 5 alias occasionally. The model agrees with previously published simulations (Khan and Bushnell, 2004).

Abstract: The Universe type system allows to restrict the possible aliasing in object-oriented programs and thereby enables static reasoning about individual components. Compared to other ownership type systems, the Universe type system is lightweight, but annotating existing software is still a considerable effort. To ease the effort of annotation, static inference of Universe modifiers from Java source code is an interesting problem. In this work, we investigated the use of pseudo-boolean optimizers to find Universe annotations. To show the benefit of the new backend we implemented a new static Universe type inferer. The results reveal that also heavy annotated programs can be typed correctly. This report presents the architecture, implementation, and results of the new tool.

Abstract: A fundamental complexity in understanding and reasoning about object-oriented languages is the need for programmers to view variables as references to objects rather than directly as objects. The need arises because a simplified view of variables as (mutable) objects is not sound in the presence of aliasing. Tako is an object-oriented language that is syntactically similar to Java but incorporates alias-avoidance techniques. This paper describes the features of the Tako language and shows how it allows programmers to view all variables directly as objects without compromising sound reasoning. It discusses the benefits of such a language, including its use as an instructional tool to help teach students how to reason formally about their code.

Abstract: This paper proves a multidimensional sampling theorem of Hermite type,from which the exact estimate of order of aliasing error on Sobolev classes of functions are deter- mined.

Abstract: High-accuracy branch prediction is crucial for high-performance processors. Inspired by the work on indexing functions to eliminate conflict-misses in memory hierarchy, this paper explores different indexing approaches to reduce conflict aliasing in branch-prediction tables. Our results show that indexing functions provide a highly complexity-effective way to enhance prediction accuracy

Abstract: A system and method for broadcasting instructions/data to a plurality of processors in a multiprocessor device via aliasing are provided. In order to broadcast data to a plurality of processors, a control processor writes to the registers that store the identifiers of the processors and sets two or more of these registers to a same value. The control processor may write the desired data/instructions to be broadcast to a portion of memory corresponding to the starting address associated with the processor identifier of the two or more processors. When the two or more processors look for a starting address of their local store from which to read, the two or more processors will identify the same starting address, essentially aliasing the memory region. The two or more processors will read the instructions/data from the same aliased memory region starting at the identified starting address and process the same instructions/data.

Abstract: This article shows the reader how to design high quality anti -aliasing filters in sampling system. It starts by guiding the reader through the design process for the basic filters like Butterworth, Chebyshev, and Bessel with separate components, it then goes on to introduce designing anti-aliasing filters using integrated circuits.

Abstract: We expect interfaces in programming languages to expose essential parts of the objects’ internal synchronization as well as required external synchronization. Clients need this information to provide required and avoid conflicting synchronization. We propose a mixed static and dynamic token-based approach to uniformly specify internal and external synchronization in a simplified Java-like language. This concept gives us much flexibility on token management, ensures race-free programs without any need for complete aliasing information, and supports static type checking of synchronization using a rich notion of subtyping.

Abstract: The documentation of object-oriented frameworks and class libraries needs to provide enough information so programmers can reason about the correctness of subclass methods without superclass code. Even though a superclass method satisfies its specification and behaves properly in the context of the superclass itself, a new subclass may cause that method to have unexpected or unverifiable behavior. For example, inherited superclass code can call down to subclass methods which may cause a superclass method to no longer satisfy its specification. Furthermore, without superclass code, downcalls can result in unverifiable side-effects. Aliasing can also result in unexpected or unverifiable side-effects. In this dissertation, we present a reasoning technique that allows programmers, who have no access to superclass code, to avoid the problems caused by downcalls and aliasing. The rules use the specification of the abstract data representation of a class and the frame axiom of each method to determine when a method override is necessary and when verifiers can safely reason about the behavior of super-calls. We describe a type system and propose a tool that would warn when a super-call is unsafe or when a superclass method needs to be overridden. A verification logic is also presented and proved sound. The verification logic is based on specifications given in the Java Modeling Language (JML) and uses superclass and subclass specifications to modularly verify the correctness of subclass code. A set of guidelines is proposed for class library implementers that, if followed, guarantees that superclass methods will always be safe to call and that our verification logic can safely be used. These guidelines make our technique easy to use in practice.

Abstract: Computer games and simulators are among the most demanding real-time computer graphics applications. In these applications, shadows greatly contribute to the visual realism and provide important depth cues. However, computing high-quality shadows at interactive rates in a complex and dynamic environment remains a challenging problem. In this paper, we restrict ourselves to generating hard shadows from point light sources. One of the popular techniques for interactive shadow generation is shadow mapping [Williams 1978]. A major disadvantage of shadow maps is that they are prone to aliasing artifacts if they have inadequate resolution. Aliasing error can be classified as perspective or projection aliasing [Stamminger and Drettakis 2002]. Current practical shadow mapping solutions reduce perspective aliasing by reparameterizing the shadow map to allocate more resolution to the undersampled regions of a scene [Stamminger and Drettakis 2002; Wimmer et al. 2004]. These algorithms use the 4× 4 projective transformation matrices available on current GPUs to obtain a non-uniform parameterization. The optimal shadow mapping parameterization, however, involves logarithmic transformations. Since perspective and logarithmic functions can diverge significantly, approximations with projective transformations can require much higher shadow map resolution to avoid perspective aliasing.

Abstract: [1] We propose a very simple and straightforward technique to reduce aliasing effects on the digital spectra of turbulent data from field experiments. A detailed analysis of the technique is done, and it is tested and compared with more traditional low-pass filtering and with oversampling. The proposed method shows satisfactory results for all tests performed.

Abstract: For a space compactor, degradation of fault detection capability caused by the masking effects from unknown values is much more serious than that caused by error masking (i.e. aliasing). In this paper, we first propose a mathematical framework to estimate the percentage of observable responses under unknown-induced masking for a space compactor. We further develop a prediction scheme which can correlate the percentage of observable responses with the modeled-fault coverage and with an n-detection metric for a given test set. As a result, the quality of a space compactor can be measured directly based on its test quality, instead of based on indirect metrics such as the number of tolerated unknowns or the aliasing probability. With the prediction scheme above, we propose a construction flow for space compactors to achieve the desired level of test quality while maximizing the compaction ratio.

Abstract: This paper describes an approximate approach for combinational equivalence checking. We propose an architecture such that a virtually-zero aliasing rate is obtained in a single-pass probability calculation. Furthermore, the aliasing rate can be easily configured in various precision by designers. We conduct experiments on a set of ISCAS'85 benchmarks. Experimental results show that with virtually-zero aliasing rate, for example, 10?74, our approach is more efficient than those exact approaches.