Design optimization with static and dynamic displacement constraints

A design optimization procedure using a sequential linear programming technique is proposed in this paper to design minimum weight structures subjected to frequency response and static displacement constraints. The merit of the proposed approach is that the reanalyses of the static and dynamic responses, as well as the computations of the static and dynamic sensitivity data, are performed in a reduced approximate model. A significant saving of computer time for large scale structures is expected. Two numerical examples show good results of this method.     

Automatic verification of Java programs with dynamic frames

Framing in the presence of data abstraction is a challenging and important problem in the verification of object-oriented programs Leavens et al. (Formal Aspects Comput (FACS) 19:159–189, 2007). The dynamic frames approach is a promising solution to this problem. However, the approach is formalized in the context of an idealized logical framework. In particular, it is not clear the solution is suitable for use within a program verifier for a Java-like language based on verification condition generation and automated, first-order theorem proving. In this paper, we demonstrate that the dynamic frames approach can be integrated into an automatic verifier based on verification condition generation and automated theorem proving. The approach has been proven sound and has been implemented in a verifier prototype. The prototype has been used to prove correctness of several programming patterns considered challenging in related work.     

Synthesis of opaque systems with static and dynamic masks

Opacity is a security property formalizing the absence of secret information leakage and we address in this paper the problem of synthesizing opaque systems. A secret predicate S over the runs of a system G is opaque to an external user having partial observability over G, if s/he can never infer from the observation of a run of G that the run belongs to S. We choose to control the observability of events by adding a device, called a mask, between the system G and the users. We first investigate the case of static partial observability where the set of events the user can observe is fixed a priori by a static mask. In this context, we show that checking whether a system is opaque is PSPACE-complete, which implies that computing an optimal static mask ensuring opacity is also a PSPACE-complete problem. Next, we introduce dynamic partial observability where the set of events the user can observe changes over time and is chosen by a dynamic mask. We show how to check that a system is opaque w.r.t. to a dynamic mask and also address the corresponding synthesis problem: given a system G and secret states S, compute the set of dynamic masks under which S is opaque. Our main result is that the set of such masks can be finitely represented and can be computed in EXPTIME and this is a lower bound. Finally we also address the problem of computing an optimal mask.     

2D shape optimization with static and dynamic constraints

The paper presents an approach that allows us to consider in the shape optimization several static loading conditions together with constraints imposed on eigenfrequencies. The idea of the method is based upon simultaneous solutions of equations and inequalities arising from the Kuhn-Tucker necessary conditions for an optimum problem. The paper is illustrated with four examples in which stress and eigenfrequency are active constraints.     

Migration-aware adaptive MPSoC static schedules with dynamic reconfigurability

Technology scalings in semiconductors have enabled the integration of dozens of processing elements (PEs) onto a single chip (MPSoC). Scheduling application tasks onto the target MPSoC has been widely reported in the literature. Both technology scalings and resource competitions among applications have led to the variations of availability resources at runtime. While adaptive static schedules with predictable responses to runtime resource variations have consequently been proposed, a large number of task migrations upon PE failures in this reconfigurable schedule scheme will lead to excessive migration cost among processors and performance degradation. In this paper, we present an algorithm to reduce the number of task migrations while retaining the benefits of the fore techniques. Through embedding several soft constraints into the baseline heuristic scheduling algorithm, the proposed algorithm can decrease the number of task migrations significantly on the basis of holding the advantages of the initial dynamic reconfigurable schedule scheme. The performance evaluation of the proposed technique is carried out by incorporation into a well known heuristic scheduling algorithm. The simulation results confirm its effectiveness in minimizing the number of task migrations during dynamic reconfiguration.     

Extending Java to dynamic object behaviors

Class inheritance and dynamic binding are the key features of object-oriented programming and they permit designing and developing complex systems. However, standard class inheritance is essentially static and cannot be directly employed for modeling dynamic object behaviors. In this paper we propose a linguistic extension of Java, called Dec-Java, that is partially inspired by the decorator design pattern. This extension permits easily separating the basic features of objects (that are likely not to change during the application) from their behaviors (that, instead, can be composed dynamically at run-time). Thus, Dec-Java enables a dynamic extension and specialization of object responsibilities.     

Algorithms for Web service selection with static and dynamic requirements

A main feature of Service Oriented Architectures is the capability to support the development of new applications through the composition of existing Web services that are offered by different service providers. The runtime selection of which providers may better satisfy the end-user requirements in terms of quality of service remains an open issue in the context of Web services. The selection of the service providers has to satisfy requirements of different nature: requirements may refer to static qualities of the service providers, which do not change over time or change slowly compared to the service invocation time (for example related to provider reputation), and to dynamic qualities, which may change on a per-invocation basis (typically related to performance, such as the response time). The main contribution of this paper is to propose a family of novel runtime algorithms that select service providers on the basis of requirements involving both static and dynamic qualities, as in a typical Web scenario. We implement the proposed algorithms in a prototype and compare them with the solutions commonly used in service selection, which consider all the service provider qualities as static for the scope of the selection process. Our experiments show that a static management of quality requirements is viable only in the unrealistic case where workload remains stable over time, but it leads to very poor performance in variable environments. On the other hand, the combined management of static and dynamic quality requirements allows us to achieve better user-perceived performance over a wide range of scenarios, with the response time of the proposed algorithms that is reduced up to a 50 % with respect to that of static algorithms.     

结合VRML和Java建立动态场景

随着虚拟现实技术的发展,对虚拟现实场景不仅要求有逼真的效果,同时还要求有生动的交互功能,而VRML(Visual Reality Modeling Language)与Java的结合是目前常用的交互式虚拟现实技术。文章介绍了虚拟现实建模语言VRML,以及怎样利用VRML与Java语言建立动态交互场景,列举了Java与VRML的几种常用的结合方式,并给出了一个实例。     

Specification and static enforcement of scheduler-independent noninterference in a middleweight Java

We introduce a new timing covert channel that arises from the interplay between multithreading and object orientation. This example motivates us to explore the root of the problem and to devise a mechanism for preventing such errors. In doing so, we first add multithreading constructs to Middleweight Java, a subset of the Java programming language with a fairly rich set of features. A noninterference property is then presented which basically demands program executions be equivalent in the view of whom observing final public values in environments using the so-called high-independent schedulers. It is scheduler-independent in the sense that no matter which scheduler is employed, the executions of the program satisfying the property do not lead to illegal information flows in the form of explicit, implicit, or timing channels. We also give a provably sound type-based static mechanism to enforce the proposed property.     

Hashing for dynamic and static internal tables

The authors survey the classical hashing-function approach to information retrieval and show how general hashing techniques exchange speed for memory space and flexibility in data manipulation operations such as insert, delete, and overflow. They also discuss recent developments in perfect hashing and minimal perfect hashing, which provide speed and memory compactness when the keys are known in advance     

Squaring down by static and dynamic compensators

Given a system, which is not necessarily invertible and which has an unequal number of inputs, a method of `squaring down', that is a method of designing pre-compensators and postcompensators such that the resulting system has an equal number of inputs and outputs and is invertible, is presented. The compensators are, in general, dynamic and have the property that the additional finite zeros induced by them are assignable to the open left-half complex plan. Furthermore, the compensators are asymptotically stable, and hence do not deteriorate the robustness and performance of an eventual feedback design. Also, the compensator design preserves the stabilizability, detectability, and minimum-phase properties and the infinite zero structure of the original system. Thus, a method of designing nonsquare systems by converting them to square invertible systems is introduced. Two applications of such a design philosophy, (1) diagonal decoupling with state feedback; and (2) almost disturbance decoupling with output feedback, are pointed out     

Coordinating static and dynamic supply chains with advertising through two-part tariffs

Zaccour (2008) analyses a marketing channel where firms invest in advertising to increase brand equity, showing that an exogenous two-part tariff cannot replicate the vertically integrated performance. I revisit the model proving that a multiplicity of efficient franchising contracts exists. I characterise an optimal two-part tariff specified as a linear function of the upstream firm’s advertising effort, performing this task both in the static and in the dynamic games. An analogous result emerges both in the static game, writing the fixed component of the two-part tariff as a non-linear function of the manufacturer’s advertising effort, and in the dynamic game, using a contract which is linear in the brand equity.     

Robot perception of static and dynamic objects with an autonomous floor scrubber

Intelligent Service Robotics - This paper presents the perception system of a new professional cleaning robot for large public places. The proposed system is based on multiple sensors including 3D...     

Research on dynamic update transaction for Java classes

Dynamic software updating is critical for many systems that must provide continuous service. In addition, the Java language is gaining increasing popularity in developing distributed systems. Most previous works on updating are concerned with safely updating one class every time. It has many limitations on updating classes, such as not allowing deleting methods invoked in other classes. In this paper, the update transaction is purposed to dynamically update the class set, and some of its properties are discussed, such as atomicity, consistency, isolation, and durability (ACID). Then the property of type-safety is proven formally. In order to update without changing the Java Virtual Machine (JVM) and the Java programming language, this paper proposes a new implementation method. The method makes use of the Java class loading mechanism and reflection mechanism. We also present how to design an updatable Java program and a Java updating program. At the end of the paper, an experiment is made for analysis.     

Binding-time analysis for both static and dynamic expressions

This paper presents a specializer and a binding-time analyzer for a functional language where expressions are allowed to be used as both static and dynamic. With both static and dynamic expressions, data structures can be statically accessed while they are residualized at the same time. Previously, such data structures were treated as completely dynamic, which prevented their components from being accessed statically. The technique presented in this paper effectively allows data structures to be lifted which was prohibited in the conventional partial evaluators. The binding-time analysis is formalized as a type system and the solution is obtained by solving constraints generated by the type system. We prove the correctness of the constraint solving algorithm and show that the algorithm runs efficiently in almost linear time. Kenichi Asai, Ph.D.: He is a research associate at the Department of Computer Science, Faculty of Science, the University of Tokyo. He obtained his bachelors degree, masters degree, and doctor of Science from the University of Tokyo in 1990, 1992, and 1997, respectively. His research interests are in Programming Languages in general, in Partial Evaluation and Reflection in particular. He is a member of ACM, IPSJ, and JSSST.