• Refine Query
  • Source
  • Publication year
  • to
  • Language
  • 284
  • 90
  • 31
  • 11
  • 11
  • 11
  • 11
  • 11
  • 11
  • 4
  • 4
  • 3
  • 2
  • 2
  • 2
  • Tagged with
  • 607
  • 607
  • 146
  • 87
  • 87
  • 71
  • 66
  • 65
  • 63
  • 61
  • 55
  • 52
  • 47
  • 47
  • 44
  • About
  • The Global ETD Search service is a free service for researchers to find electronic theses and dissertations. This service is provided by the Networked Digital Library of Theses and Dissertations.
    Our metadata is collected from universities around the world. If you manage a university/consortium/country archive and want to be added, details can be found on the NDLTD website.
281

A semantics for functions and behaviours

Daniels, Anthony Charles January 1999 (has links)
The functional animation language Fran allows animations to be programmed in a novel way. Fran provides an abstract datatype of ``behaviours'' that represent time varying values such as the position of moving objects, together with a simple set of operators for constructing behaviours. More generally, this approach has potential for other kinds of real-time systems that consist of interactive components that evolve over time. We introduce a small functional language, CONTROL, which has behaviours and operators that are similar to those in Fran. Our language improves on Fran in certain key areas, in particular, by eliminating start times and distinguishing between recursive functions and recursive behaviours. Our main contribution is to provide a complete formal semantics for CONTROL, which Fran lacks. This semantics provides a precise description of the language and can be used as the basis for proving that programs are correct. The semantics is defined under the assumption that real number computations and operations on behaviours are exact. Behaviours are modelled as functions of continuous time, and this approach is combined with the standard approach to the semantics of functional languages. This combination requires some novel techniques, particularly for handling recursively defined behaviours.
282

A multi-dimensional analytical framework for hierarchical reasoning in space and time

Lee, Howard January 2000 (has links)
No description available.
283

Interaction of periodic bursty traffic flows in ATM networks

de Carvalho, Paulo Manuel Martins January 1996 (has links)
No description available.
284

Behavioural subtyping in process algebra

Briscoe-Smith, C. January 2000 (has links)
Subtyping relations embody a notion of substitutability, and are an important tool in formal methods. The downward simulation relation is well-known and widely used as a subtyping and refinement relation for state-based approaches, but there is no single relation which is widely accepted to be the subtyping relation for the behavioural setting; however, there are several candidate relations. Developments such as the multi-viewpoint specification method of RM-ODP encourage the use of several different formal methods in a single project. Thus, it becomes important to obtain implementations of a single notion of subtyping in several different paradigms. In this thesis, we attempt to find a process algebraic relation which corresponds to the state-based subtyping relation, downward simulation. While trying to achieve this, we define a translation between a state-based notation and a process algebra, and we uncover some of the similarities and differences between these two specification paradigms. In particular, we investigate the meaning of undefined behaviour in each setting. When a state-based specification does not define an operation, the intent is that the system's behaviour is unspecified (not well-defined) if that operation is invoked. In a process algebra with refusals semantics, however, a process is implicitly specified to refuse any action it is not specified to accept, and such a refusal constitutes well-defined behaviour. As part of our translation, we devise a method of representing the unspecified behaviour of the state-based world in a process definition. Finally, we use our translation to prove that the presence of subtyping between a pair of state-based specifications implies reduction between their LOTOS translations, but that the presence of reduction does not imply subtyping. We conclude that reduction itself does not correspond to state-based subtyping, but that any relation which does must be based on a stronger semantics than reduction, such as bisimulation semantics.
285

Model translation : a UML-based specification technique and active implementation approach

Akehurst, David H. January 2000 (has links)
Many software applications involve models of data that are manipulated by the application. There is often a need to transform (or translate) the data from one model, into another in which the data is differently structured. In addition, there is an increasing requirement to pass data between different applications, which invariably have different formats for their data models. Both of these issues require a translation of the modelled data from one form to another. The process of translating a model from one form to another is known as model transformation or model translation. The literature on model transformation includes a number of techniques for specifying transformations. However, the majority of these techniques are grammar-based specifications, many of which use a textual grammar, although some make use of graphical (graph) grammars. These subsequently lead to a monolithic one-step implementation process that performs the transformation. This thesis addresses two issues that are related to the area of model transformation. Firstly, it addresses the need for a standard notation that can be used for writing model translator specifications. Secondly, a technique for implementing model translators is developed that actively performs the transformation. Rather than a single step process, that must be executed every time the source model changes, the active implementation approach presented performs a continuous translation updating the target model every time a change is made to the source model. The specification technique makes use of the standardised Unified Modelling Language (UML) and Object Constraint Language (OCL) for specifying a transformation relationship between two object-oriented models, each of which is also specified using UML and OCL. The implementation approach uses an event-based version of the observer pattern enabling the construction of translator to be formed from a number of mini-translator parts, each of which monitors a small set of components. These mini-translators act upon events generated by the model components and update the transformed components to reflect the changes. The specification and implementation techniques described can be applied to many problem areas. In particular this thesis discusses their application to Multiple View Visual Languages (i.e. the UML itself) and automatic performance model generation.
286

Flexible approaches to controlling congestion of data traffic in an ATM network

Shandal, Anil Kumar January 1996 (has links)
No description available.
287

Polyhedral domains for abstract interpretation in logic programming

Benoy, Patricia Mary January 2002 (has links)
The motivations for program analyses are many. The impetus for the static analysis of programs initially ranged from the need for more efficient code to program transforms for parallel systems, but with the passage of time now also encompasses: providing the programmer with debugging information, program verification and program testing. Abstract interpretation is a methodology for static analysis that was formalised at the beginning of the last decade and is employed in both declarative and imperative programming paradigms. Abstract interpretation is a rigorous approximation technique that allows an analysis to focus on a particular property and infer useful information about the run time behaviour of the program being analysed. In order to implement an abstract interpretation it is necessary to chose an abstract domain that expresses the property of interest with sufficient precision to be useful. The focus of this thesis is on the use of two polyhedral domains as a means of capturing these properties of interest in logic programs. This thesis demonstrates how polyhedra can be employed to capture analyses that relate to dependency information with respect to some measure of size. Polyhedral analyses require a technique known as widening to ensure analysis convergence. Computational issues associated with widening prompted an investigation into the way linear spaces interact and how it is possible for a polyhedron to have different representations as a set of implicitly conjoined linear inequalities. Some useful computational insights are the outcome of this investigation. The observation that certain linear inequalities might represent dependency information prompted a novel approach to capturing dependency analysis with the subclass of polyhedra that can be represented by those linear inequalities. This could be advantageous for analyses in environments with constraint support as no set-up costs for the analysis would be incurred as the existing environment would be capable of supporting the abstract domain. Central to this thesis is the isomorphism that reveals the precise extent to which these polyhedra can represent dependency information. An argument-size analysis using polyhedra and a groundness analysis using certain polyhedral cones have been implemented up to the prototype stage.
288

Context-aware software

Pascoe, Jason January 2001 (has links)
With the advent of PDAs (Personal Digital Assistants), smart phones, and other forms of mobile and ubiquitous computers, our computing resources are increasingly moving off of our desktops and into our everyday lives. However, the software and user interfaces for these devices are generally very similar to that of their desktop counterparts, despite the radically different and dynamic environments that they face. We propose that to better assist their users, such devices should be able to sense, react to, and utilise, the user's current environment or context. That is, they should become context-aware. In this thesis we investigate context-awareness at three levels: user interfaces, applications, and supporting architectures/frameworks. To promote the use of context-awareness, and to aid its deployment in software, we have developed two supporting frameworks. The first is an application-oriented framework called stick-e notes. Based on an electronic version of the common Post-It Note, stick-e notes enable the attachment of any electronic resource (e.g. a text file, movie, Java program, etc.) to any type of context (e.g. location, temperature, time, etc.). The second framework we devised seeks to provide a more universal support for the capture, manipulation, and representation of context information. We call it the Context Information Service (CIS). It fills a similar role in context-aware software development as GUI libraries do in user interface development. Our applications research explored how context-awareness can be exploited in real environments with real users. In particular, we developed a suite of PDA-based context-aware tools for fieldworkers. These were used extensively by a group of ecologists in Africa to record observations of giraffe and rhinos in a remote Kenyan game reserve. These tools also provided the foundations for our HCI work, in which we developed the concept of the Minimal Attention User Interface (MAUI). The aim of the MAUI is to reduce the attention required by the user in operating a device by carefully selecting input/output modes that are harmonious to their tasks and environment. To evaluate our ideas and applications a field study was conducted in which over forty volunteers used our system for data collection activities over the course of a summer season at the Kenyan game reserve. The PDA-based tools were unanimously preferred to the paper-based alternatives, and the context-aware features were cited as particular reasons for preferring them. In summary, this thesis presents two frameworks to support context-aware software, a set of applications demonstrating how context-awareness can be utilised in the ''real world'', and a set of HCI guidelines and principles that help in creating user interfaces that fit to their context of use.
289

Multicast routing with quality of service constraints in data networks

Rio, Miguel January 2002 (has links)
No description available.
290

Transcending static deployment of circuits : dynamic run-time systems and mobile hardware processes for FPGAs

Moseley, Ralph January 2002 (has links)
The usefulness of reconfigurable hardware has been shown in research and commercial applications. Unquestionably, this has and will lead to, unique avenues of thought within computer science being explored. The interest by researchers in some specific areas has led to manufacturers developing devices which were enhanced in their ability to dynamically be configured within a run-time context. These improvements are on-going and rapid progress is being made, producing high density, system-on-a-chip capable devices, with fast run-time reconfiguration. The advancements in this technology have particularly led to a convergence between software and hardware domains, in the sense that algorithms can be implemented in either; the choice being dependent only in terms of efficiency within the medium itself. Older methods for development with these devices have become rapidly dated and inflexible. Very few suitable tools exist, for example, which are capable of fully utilising the inherent capabilities of such hardware. The approach taken here allows the division between hardware and software to be diminished. Component designs, which may be hardware description language (HDL) based or synthesised algorithms, become easily manipulated and interacted with through a run-time engine, that can deploy elements at will to local or distributed devices. Such entities are essentially hybrid in nature, possessing both hardware and software functionality. These processes are sufficiently self-supporting, to be capable of being used outside of the run-time system within a normal Java development environment. This work explores how hardware entities can become as dynamic as memory based algorithms within conventional von Neumann based systems, providing the means for extending the software programming paradigm into such areas. It analyses the possibilities of applying object-oriented and occam/Communicating Sequential Processes (CSP) based concurrency philosophies to these highly mobile, hardware processes.

Page generated in 0.1099 seconds