In this work an implementation of a linearized Poisson-Boltzmann equation solver based on a Finite Differences scheme on the GPU architecture is presented. The algorithm exploits the checkerboard structure of the discretized Laplace operator and follows the footprints of a popular solver called DelPhi, which is widely used in the Computational Biology community. The algorithm has been implemented using CUDA. This implementation has then been integrated with the DelPhi solver and tested over a few representative cases of biological interest. Details of the implementation as well as performance test results are illustrated.

In this paper, we present new approaches for computation of the inverse kinematics and inverse dynamics of the Gough-Stewart platform. The new approach for the inverse kinematics, i.e., the calculation of joints velocity and acceleration, is based on using the projection matrices to directly related the mobile platform velocity and acceleration to active joints velocity and acceleration. The new approach for the inverse dynamics is rather unconventional, in the sense that it is based on implicit computation and the use of constraint forces. Our detailed analysis and comparison demonstrate that our new approach for computation of both inverse kinematics and inverse dynamics achieves a better computational efficiency than previously proposed methods.

Computational complexity is still a challenging problem for intelligent systems operating in compound environments. To tackle it, an agent has to deal with perceptual information intelligently. In this paper, we propose an efficient and adaptive reasoning system based on Adaptive Logic Interpreter reasoning system, a mechanism for guiding inference through relational reinforcement learning, and a variation of Truth Maintenance Systems to speed up the inference. Relational reinforcement learning guides the inference toward the most rewarding parts of the knowledge base and truth maintenance system maintains beliefs, avoids repetitive inferences and reduces the state space. Empirical results demonstrate higher performance than the basic approach in terms of number of inferred instances, average reward, and average reward accuracy.

Embedded systems are becoming highly complex and increasingly being used in critical applications. Integrated system health management (ISHM) techniques have therefore been developed to ensure the proper operation of these systems. However, some ISHM systems are relatively complex and may consume a significant amount of resources. In some situations, activating the full ISHM system may cause resource contention and prevents the target system from timely completing critical tasks. Thus, it is imperative to introduce the notion of adaptivity into ISHM systems. This paper systematically discusses the issues that need to be addressed in an adaptive ISHM system with a focus on adaptation in terms of QoS aspects. A novel model, adaptive diagnosis quality-oriented system model (ADQSM), is proposed to model the QoS specification and fault diagnosis quality measurement issues as well as the abstraction of the adaptation problem. We then present the method to evaluate various diagnosability attributes based on a modified fault signature matrix. We further map the ADQSM model to the particle swarm optimization (PSO) problem model and use PSO for rapid configuration decision making

The G4-FET, a four-gate transistor compatible with standard silicon-on-insulator (SOI) CMOS technology, provides unique opportunities as a logic device. Combining both JFET- and MOSFET-like actions within one transistor body, the G4-FET offers two side (lateral) junction-based gates, a top MOS gate, and a MOS back gate that is activated by SOI substrate biasing. The G4-FET's conduction characteristics are controlled by the combined interaction of these four gates. In this paper, the G4-FET is demonstrated as a logic device, resulting in a universal and programmable logic gate that can lead to the design of more efficient logic circuits. As an example, we present a new full adder design based on the G4-FET that is significantly more efficient than conventional designs.

The constraint force algorithm, as originally described by Fijany et al. (1995), calculates the forward dynamics of a system comprising N rigid bodies connected together in an unbranched chain with joints from a restricted class of joint types. It was designed for parallel calculation of the dynamics, and achieves O(log N) time complexity on O(N) processors. This paper presents a new formulation of the constraint force algorithm that corrects a major limitation in the original, and sheds new light on the relationship between this algorithm and other dynamics algorithms. The new version is applicable to systems with any type of joint, floating bases, and short branches off the main chain. It is obtained using a new technique for analysing constrained rigid-body systems by means of a change of basis in a dual system of vector spaces. This new technique is also described.

These parallel algorithms described are based on a new O(N) solution to the problem. The underlying feature of this O(N) method is a different strategy for decomposition of interbody force which results in a new factorization of mass matrix (M). Specifically, a factorization of inverse of the mass matrix in the form of Schur complement is derived as M/sup -1/=C-D/sup t/A/sup -1/B wherein A, B, and C are block tridiagonal matrices. The new O(N) algorithm is then derived as a recursive implementation of this factorization of M/sup -1/. It is shown that the resulting algorithm is strictly parallel. Strategies for multilevel exploitation of parallelism in the computation are also discussed, resulting in more efficient parallel O(log N) algorithms. The parallel algorithms developed in this paper, in addition to their theoretical significance, are also important from a practical implementation standpoint due to their simple architectural requirements.>

In this paper new factorization techniques for computation of the operational space mass matrix (/spl Lambda/) and its inverse (/spl Lambda//sup -1/) are developed. Starting with a new factorization of the inverse of mass matrix (M/sup -1/) in the form of Schur complement as M/sup -1/=C-B/sup T/A/sup -1/B, where A and B are block tridiagonal matrices and C is a tridiagonal matrix, similar factorizations for /spl Lambda/ and /spl Lambda//sup -1/ are derived. Specifically, the Schur complement factorizations of /spl Lambda//sup -1/ and /spl Lambda/ are derived as /spl Lambda//sup -1/=D-E/sup T/A/sup -1/E and /spl Lambda/=G-R/sup T/S/sup -1/R, where E and R are sparse matrices and D and G are 6/spl times/6 matrices. The Schur complement factorization provides a unified framework for computation of M/sup -1/, /spl Lambda//sup -1/, and /spl Lambda/. The main advantage of these new factorizations is that they are highly efficient for parallel computation. With O(N) processors, the computation of /spl Lambda//sup -1/ and /spl Lambda/ as well as their operator applications can be performed in O(log N) steps.>

In this paper, two parallel O(log N) algorithms for the computation of manipulator forward dynamics are presented. They are based on a new O(N) algorithm for the problem which is developed from a new factorization of mass matrix M. Specifically, a factorization of the inverse M/sup -1/ in the form of a Schur complement is derived. The new O(N) algorithm is then developed as a recursive implementation of this factorization. It is shown that the resulting algorithm is strictly parallel, that is, it is less efficient than other algorithms for serial computation of the problem. However, to our knowledge, it is the only algorithm that can be parallelized to derive both a time-optimal O(logN) - and processor-optimal - O(N) - parallel algorithm for the problem. A more efficient parallel O(logN) algorithm based on a multilevel exploitation of parallelism is also briefly described. In addition to their theoretical significance, these parallel algorithms allow a practical implementation due to their simple architectural requirements.>

Abstract The paper presents the implementation of a new class of massively parallel algorithms for solving certain time‐dependent partial differential equations (PDEs) on massively parallel supercomputers. Such PDEs are usually solved numerically, by discretization in time and space, and by applying a time‐stepping procedure to data and algorithms potentially parallelized in the spatial domain. In a radical departure from such a strictly sequential temporal paradigm, we have developed a concept of time‐parallel algorithms, which allows the marching in time to be fully parallelized. This is achieved by using a set of transformations based on eigenvalue‐eigenvector decomposition of the matrices involved in the discrete formalism. Our time‐parallel algorithms possess a highly decoupled structure, and can therefore be efficiently implemented on emerging, massively parallel, high‐performance supercomputers, with a minimum of communication and synchronization overhead. We have successfully carried out a proof‐of‐concept demonstration of the basic ideas using a two‐dimensional heat equation example implemented on the Intel Touchstone Delta supercomputer. Our results indicate that linear, and even superlinear, speed‐up can be achieved and maintained for a very large number of processor nodes.

In this paper, fast time- and space-parallel algorithms for solution of parabolic PDEs are developed. It is shown that the seemingly strictly serial time-stepping procedures for solution of problem can be completely decoupled. This is achieved by developing time-parallel algorithms which allow the solution for all time steps to be computed in parallel. The time-parallel algorithms have a highly decoupled structure and hence can be efficiently implemented on emerging massively parallel MIMD architectures with minimum communication and synchronization overhead.

Parallel computation of manipulator forward dynamics is investigated. Considering the three classes of algorithms for the problem, the authors show that the O(n/sup 3/) algorithms are the most efficient for parallel computation. Parallel algorithms for computation of inertia matrix, the bias vector, and the linear system solution are developed which can be efficiently implemented on a unique architecture, a triangular array of n(n+1)/2 processors with a nearest neighbor interconnection. This architecture is highly suitable for VLSI and WSI implementation.>

An efficient method of computation of the manipulator inertia matrix is presented. Using spatial notations, the method leads to the definition of the composite rigid-body spatial inertia, which is a spatial representation of the notion of augmented body. The previously proposed methods, the physical interpretations leading to their derivation, and their redundancies are analyzed. The proposed method achieves a greater efficiency by eliminating the redundancy in the intrinsic equations as well as by a better choice of coordinate frame for their projection. In this case, removing the redundancy leads to greater efficiency of the computation in both serial and parallel senses.>

Parallel and parallel/pipeline algorithms for computation of the manipulator inertia matrix are presented. An algorithm based on the composite rigid-body spatial inertia method, which provides better features for parallelization, is used for the computation of the inertia matrix. Two parallel algorithms are developed which achieve the time lower bound in computation. Also described is the mapping of these algorithms with topological variation on a two-dimensional processor array, with nearest-neighbor connection, and with cardinality variation on a linear processor array. An efficient parallel/pipeline algorithm for the linear array was also developed and has significantly higher efficiency.>

A class of parallel and parallel/pipeline algorithms for computation of the manipulator inertial matrix is presented. An algorithm based on the composite rigid-body spatial inertia method, which results in less data dependency and hence better parallelization efficiency, is used for computation of the inertia matrix. Two parallel algorithms are developed which achieve the time lower bound of O((log/sub 2/ n))+O(1) in the computation with O(n/sup 2/) processors. The architectural features required for perfect mapping of these algorithms and their communication complexity are analyzed. The performance of the algorithms when mapped on two- and one-dimensional (linear) processor arrays with nearest-neighbor connection is investigated. Mapping on the linear array results in new algorithms with a computational complexity of k/sub 1/n(log/sub 2/n)+k/sub 2/(log/sub 2/n)+k/sub 3/. A parallel/pipeline algorithm is also presented which achieves the computation time of k/sub 1/n+k/sub 2/(log/sub 2/ n)+k/sub 3/ on the linear array. An architecture-oriented approach is used in the design of the algorithms.>

Symbolic inversion of the Jacobian matrix for spherical wrist arms is investigated. It is shown that, taking advantage of the simple geometry of these arms, the closed-form solution of the system Q=J/sup -1/X, representing a transformation from task space to joint space, can be obtained very efficiently. The solutions for PUMA and Stanford arms and a six-revolute-joint coplanar arm, along with all singular points, are presented. The solution for each joint variable is found as an explicit function of the singular points which provided a better insight into the effect of different singular investigated points on the motion and force exertion of each individual joint. For the arms investigated, the computation cost of the solution is the same order as the cost of forward kinematic solution and it is significantly reduced if a forward kinematic solution is already obtained. A comparison with previous methods shows that this method is the most efficient to date.>