A robust parallel programming model for dynamic non-uniform scientific computations

Explicitly parallel programs have the potential for greater performance than their implicitly parallel counterparts. However, this benefit can be accompanied by additional programming difficulties. We address one particular problem that has implications for both scalability and portability: the need for programs do accommodate diverse data decompositions. We explain why programs with explicit communication have difficulties in handling changes in data decomposition, and we present a solution to this problem which involves the notions of derivative functions and configuration parameters. We illustrate the technique by using three different data decompositions to solve the Modified Gram-Schmidt method on four parallel machines.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

A fuzzy robust nonlinear programming model is developed for the assessment of filter allocation and replacement strategies in hydraulic systems under uncertainty. It integrates the methods of fuzzy mathematic programming (FMP) and robust programming (RP) within the mixed integer nonlinear programming framework, and can facilitate dynamic analysis and optimization of filters allocation and replacement planning where the uncertainties are expressed as fuzzy membership functions. In modeling formulation, theory of contamination wear of typical hydraulic components is introduced to strengthen the presentation of relationship between system contamination and work performance. The fuzzy decision space is delimited into a more robust one by specifying the uncertainties through dimensional enlargement of the original fuzzy constraints. The piecewise linearization approach is employed to handle the nonlinearities of problem. The developed method has been applied to a case of planning filter allocation and replacement strategies under uncertainty and the generated optimal solution will help to reduce the total system cost and failure-risk level of the FPS.

PurposeCoal is a critical global energy source, and fluctuations in its price significantly impact related enterprises' profitability. This study aims to develop a robust model for predicting the coal price index to enhance coal purchase strategies for coal-consuming enterprises and provide crucial information for global carbon emission reduction.Design/methodology/approachThe proposed coal price forecasting system combines data decomposition, semi-supervised feature engineering, ensemble learning and deep learning. It addresses the challenge of merging low-resolution and high-resolution data by adaptively combining both types of data and filling in missing gaps through interpolation for internal missing data and self-supervision for initiate/terminal missing data. The system employs self-supervised learning to complete the filling of complex missing data.FindingsThe ensemble model, which combines long short-term memory, XGBoost and support vector regression, demonstrated the best prediction performance among the tested models. It exhibited superior accuracy and stability across multiple indices in two datasets, namely the Bohai-Rim steam-coal price index and coal daily settlement price.Originality/valueThe proposed coal price forecasting system stands out as it integrates data decomposition, semi-supervised feature engineering, ensemble learning and deep learning. Moreover, the system pioneers the use of self-supervised learning for filling in complex missing data, contributing to its originality and effectiveness.

The various robust linear programming models investigated so far in the literature essentially appear to be based either on what is referred to as rowwise uncertainty models or on columnwise uncertainty models (these basically assume that the rows, or the columns, of the constraint matrix are subject to changes within a well-specified uncertainty set). In this chapter, we discuss a special case of columnwise uncertainty, namely the subclass of robust linear programming (LP) models with uncertainty limited to the right hand side (RHS) only (this subclass does not appear to have been significantly investigated so far). In this context we introduce the concept of a ‘two-stage robust LP model’ as opposed to the standard case (which might be referred to as a ‘single-stage robust LP model’) and we address the question of whether LP duality can be used to convert a LP problem with RHS uncertainty into a robust LP problem with uncertainty on the objective function. We show how to derive both statements of (a) the dual to the robust model and (b) the robust version of the dual. The resulting expressions of the objective function to be optimized in both cases, appear to be clearly distinct. Moreover, from a complexity point of view, one appears to be efficiently solvable (it reduces to a convex optimization problem), whereas the other, as a nonconvex optimization problem, is expected to be computationally difficult in the general case. As an application of the two-stage robust LP model introduced here, we next investigate the PERT (program evaluation and review technique) scheduling problem, considering two possible natural ways of specifying the uncertainty set for the task durations: the case where the uncertainty set is a scaled ball with respect to the L ∞ norm; the case where the uncertainty set is a scaled Hamming ball of bounded radius (which, though leading to a quite different model, bears some resemblance to the well-known Bertsimas–Sim approach to robustness). We show that in both cases the resulting robust optimization problem can be efficiently solved in polynomial time.

We present a general computational narrative model encompassing primitives of space, time, and motion from the viewpoint of deep knowledge representation and reasoning about visuo-spatial dynamics, and (eye-tracking based) visual perception of the moving image. The declarative model, implemented within constraint logic programming, integrates knowledge-based qualitative reasoning (e.g., about object / character placement, scene structure) with state of the art computer vision methods for detecting, tracking, and recognition of people, objects, and cinematographic devices such as cuts, shot types, types of camera movement. A key feature is that primitives of the theory — things, time, space and motion predicates, actions and events, perceptual objects (e.g., eye-tracking / gaze points, regions of attention etc) — are available as first-class objects with deep semantics suited for inference and query from the viewpoint of analytical Q&A or studies in visual perception. We present the formal framework and its implementation in the context of a large-scale experiment concerned with analysis of visual perception and reception of the moving image in the context of cognitive film studies.

Cemented sands exhibit a complex mechanical behavior that can lead to sophisticated models, with numerous parameters without real physical meaning. However, using a rather simple generalized critical state bonded soil model has proven to be a relevant compromise between an easy calibration and good results. The constitutive model formulation considers a non-associated elasto-plastic formulation within the critical state framework.The calibration procedure, using standard laboratory tests, is complemented by the study of an uniaxial compression test observed by tomography. Using finite elements simulations, this test is simulated considering a non-homogeneous 3D media. The tomography of compression sample gives access to 3D displacement fields by using image correlation techniques. Unfortunately these fields have missing experimental data because of the low resolution of correlations for low displacement magnitudes. We propose a recovery method that reconstructs 3D full displacement fields and 2D boundary displacement fields. These fields are mandatory for the calibration of the constitutive parameters by using 3D finite element simulations. The proposed recovery technique is based on a singular value decomposition of available experimental data. This calibration protocol enables an accurate prediction of the fragmentation of the specimen.

Creating robust, reproducible and optimal computational models is a key challenge for theorists in many sciences. Psychology and cognitive science face particular challenges as large amounts of data are collected and many models are not amenable to analytical techniques for calculating parameter sets. Particular problems are to locate the full range of acceptable model parameters for a given dataset, and to confirm the consistency of model parameters across different datasets. Resolving these problems will provide a better understanding of the behaviour of computational models, and so support the development of general and robust models. In this article, we address these problems using evolutionary algorithms to develop parameters for computational models against multiple sets of experimental data; in particular, we propose the ‘speciated non-dominated sorting genetic algorithm’ for evolving models in several theories. We discuss the problem of developing a model of categorisation using twenty-nine sets of data and models drawn from four different theories. We find that the evolutionary algorithms generate high quality models, adapted to provide a good fit to all available data.

Portfolio selection is one of the most important financial and investment issues. Portfolio selection seeks to allocate a predetermined capital (wealth) over one or multiple time periods between assets and stocks in a such way that the wealth of investor (portfolio owner) is maximized the risks are minimized. In the paper, we first propose a mathematical programming model for Portfolio selection to maximize the minimum amount Sharpe ratios of portfolio in all periods (max-min problem). Then, due to the uncertain property of the input parameters of such a problem, a robust possibilistic programming model (based on necessity theory) has been developed, which is capable of adjusting the robust degree of output decisions to the uncertainty of the parameters. The proposed model has been tested on 27 companies active in the Tehran stock market. At the end, the results of the model demonestrate the good performance of the robust possibilistic programming model.

A constant development of gas utilization in domestic households, industry, and power plants has slowly transformed gaseous petrol into a noteworthy wellspring of energy. Supply and transportation planning of liquefied natural gas (LNG) need a great attention from the management of the supply chain to provide a significant development of gas trading. Therefore, this paper addresses a robust mixed-integer linear programming model for LNG sales planning over a given time horizon aiming to minimize the costs of the vendor. Since the parameter of the manufacturer supply has an uncertain nature in the real world, and this parameter is regarded to be interval-based uncertain. To validate the model, various illustrative examples are solved using CPLEX solver of GAMS software under different uncertainty levels. Furthermore, a novel metaheuristic algorithm, namely cuckoo optimization algorithm (COA), is designed to solve the problem efficiently. The obtained comparison results demonstrate that the proposed COA can generate high-quality solutions. Furthermore, the comparison results of the deterministic and robust models are evaluated, and sensitivity analyses are performed on the main parameters to provide the concluding remarks and managerial insights of the research. Finally, a comparison evaluation is done between the total vendor profit and the robustness cost to find the optimal robustness level.

Managing the limited resources of money, time and space poses a real problem in the livestock business in general and the poultry sector in particular. The stochastic linear programming with recourse will permit the formulation of a mathematical model that could easily be solved in order to attain the objective of maximizing profit but this will be hindered by the presence of some parameters like demand and supply which have no predetermined probability distributions. In an attempt to address the problem of unavailable probability distribution functions, this research is aimed at proposing a robust linear programming model which can handle problems and others in similar circumstances with the need of probability distributions.The robust model thus constructed is based on a modification of the stochastic model by Soyster. An application of this model on a real life data produced results showing an increase in profit made by a local poultry farmer from 241,485 FCFA to 362,580FCFA representing an increase in profit of more than 50% in over that obtained when using the ordinary Linear Programming Technique. The belief therefore is that, if models like this are implemented, not only would the livelihood of the poultry farmers be improved, but it will go a long way to better the economy and satisfy the ever increasing need of poultry products by the communities. Key words: Maximization, livestock, stochastic, robust, linear programming, optimization. &nbsp

A new trend in programming languages is to merge multiple paradigms, rather than focusing on one as it was customary in the past. Most modern languages provide native support for imperative and functional programming, object-orientation and even concurrency. The typical mechanism used to blend heterogeneous language concepts is to rely on functions. Functions are a very well understood, usually offer an excellent abstraction over diverging models of computation, but are unsuitable to interface logic programming, unfortunately. Embedding a full logic programming language into a host is also unsatisfactory, as it impedes the ability to make data flow from one paradigm to the other. As an answer to these issues, we propose LogicKit, a library that aims to bridge the gap between logic programming and other traditional paradigms. LogicKit is a Prolog-inspired language that blends seamlessly into Swift. Predicates are first-class objects in the host language and data can flow in and out of a logic program, without the need for any data serialization/parsing. Our framework is distributed in the form of a Swift library that can be imported in any Swift project effortlessly. We elaborate on our motivation for developing LogicKit and present the library by the means of examples.

A number of concurrent computers have been designed, such as [Ametek 1988] and [NCUBE 1986]. Taking advantage of concurrency on these computers will require new languages, operating systems, and environments to support the programming, monitoring and control of applications. The Rosette project at MCC is developing a system architecture for general-purpose concurrent computation based on the Actor model [Agha 1986]. The aim of the Rosette architecture is to support the use of concurrent computers in solving computationally intensive problems whose structure is not statically determined. The architecture will support variable grain size, dynamic resource management, reflection, and heterogeneity. A number of concurrent language proposals have employed computational models that are limited in their applicability because of assumptions such as granularity of concurrency, static process topology, or inherent communications cost. Others, for example, functional programming, cannot be used to model shared, modifiable objects. The Actor model addresses these issues directly. However, the difficulties of using concurrent computers cannot be addressed solely through programming languages. Traditional operating systems treat each process as an independent entity for the purposes of resource management (i.e., for the run-time allocation of processor, storage, and communication resources.) In the context of concurrent applications, effective operation on a concurrent computer requires that communities of processes be managed together, taking into account the ways in which they interact, and providing for the application itself to guide resource management. For example, consider that programming systems often provide only limited support for the control of resource consumption in search problems in the face of combinatorial explosion; further, it is generally recognized that to optimize search performance, it is useful to vary the resources provided depending on how promising intermediate results of a given path are judged to be. The Rosette architecture will allow the programmer to integrate high-level algorithms within the application for dividing resources dynamically among the sub-computations that are spawned. These algorithms will provide an assessment of the progress of the sub-computations, and will be used to make the large number of low-level resource management decisions that are necessary in carrying out the computation. Thus, operating system functionality will be folded into the application. The Rosette architecture has two major components: an interface layer and a system environment . The interface layer provides mechanisms for the monitoring and control of concurrent applications. It supports a uniform view of the system resources and applications through the use of actors and message-passing semantics. The interface layer includes a set of actors that represent the processing, storage and communication resources across the hardware base. The system environment contains actor communities which implement resource management policies , and support for programming concurrent applications. The environment consists of an extensible set of actors that are organized via a class-based object model. These actors provide monitoring, debugging, resource management system simulation, and compilation/transformation facilities. To demonstrate the effectiveness of the Rosette architecture, as well as to drive its development, two classes of applications are being used. The first class is the Rosette system itself: all of the system components necessary for resource management, monitoring, debugging, and program development are being constructed in the Rosette language and will take full advantage of both concurrency and object-oriented programming support. The second category of applications is chosen to be somewhat independent of the Rosette system so as to ensure adequate feed-back concerning applicability to domains other than software engineering. These applications are in the general area of knowledge-based signal interpretation. The Rosette architecture is implemented via a concurrent object-oriented programming language that provides the following features: Inherent concurrency : A declarative approach is needed which allows fine-grained concurrency to arise naturally from the program. If the programmer is forced to express all of the details of the concurrent execution of an application, it becomes difficult to re-map a given program to different concurrent computers which have varying concurrency characteristics. Dynamic creation/modification of objects : This allows the system to be extensible and reconfigurable. Sharing : The language should support mechanisms such as inheritance so that code, structure, and values need not be replicated. Classes : Objects can be organized into classes to permit more effective management of resources, as for example in a very large database. Classes should be first-class objects and hence it should be possible to create classes dynamically. The Rosette language is a high-level language that is translated into a base language that directly expresses concurrent computations in terms of the semantics of the Actor model. The Rosette language extends the base language with data abstraction facilities and a library of classes, and is used to implement the non-built-in actors of the interface layer, components of the system environment, and applications. Using data abstraction extensions to the base language, the Rosette language organizes actors into classes according to common sets of behaviors and local state. Inheritance is used as a means of sharing code and structure that is common among classes. There is considerable evidence, for example [LaLonde 1986] and [Snyder 1987], that a robust class system should support separate hierarchies that represent what is modeled by a class and how some class of objects are actually implemented. Our approach is to use three different kinds of classes to organize the various kinds of actors in a system and information about these actors: abstract classes specify observable requests, responses, and actions; representation classes specify resource management characteristics of implementations; and behavior classes contain the actual implementations. Associated with an abstract class is the set of representations that are available to implement the particular abstraction. Each representation is associated with the behavior class that contains the corresponding implementation. The power of this separation is that each of the three kinds of class may be related to others in a class hierarchy. This means that the relationships between abstract classes are not forced to have the same structure as the relationships among implementations. Sharing via inheritance among behavior classes is related to engineering concerns; relations among abstract classes are dictated by external/observable behavior. As an example, an abstract class might specify the operations available over real-matrices . There are several ways of representing a matrix as a community of actors, and each of these would be specified with appropriate representation and behavior classes. There is a well-defined abstract hierarchy of matrices such as invertible, positive , etc. These abstract kinds of matrices are independent of the various implementations, which may be chosen according to application and hardware resource constraints. The Rosette language embodies a reflective model of the interface layer that is similar to that used in ABCL/R, [Watanabe and Yonezawa 1988]. This model is t

In many scientific computing problems, the overall execution time is dominated by the time to solve very large linear systems. Quite often, the matrices are unsymmetric and ill conditioned, with an irregular sparsity structure reflecting the irregular refinement in the discretization grid. With increasing problem size and problem dimension, direct solvers cannot be used because of the huge memory requirements. The performance of preconditioned iterative solvers is largely dominated by memory-related aspects like size, bandwidth, and indirect addressing speed. This article summarizes the experience of the authors on the relationship between memory aspects and performance in real applications in the domain of very large scale integration (VLSI) device simulation. The authors analyze storage requirements of direct and iterative solvers on a statistical data set, and demonstrate performance variations due to memory-related architectural features on a number of computers ranging from workstations to Cray, NEC, and Fujitsu supercomputers for typical and ill-conditioned linear systems, using different iterative methods and preconditioners. The experiments are done using PILS, a package of iterative linear solvers. PILS implements a large number of iterative methods and preconditioners and allows them to be combined in a flexible way.

Open wedge high tibial osteotomy does not decrease patellar height relative to femur: A three-dimensional computer model analysis

Effect of different aspects of multiple earthquakes on the nonlinear behavior of RC structures