Snakes are now a very popular technique for shape extraction by minimising a suitably formulated energy functional. A dual snake configuration using dynamic programming has been developed to locate a global energy min...
详细信息
Snakes are now a very popular technique for shape extraction by minimising a suitably formulated energy functional. A dual snake configuration using dynamic programming has been developed to locate a global energy minimum. this complements recent approaches to global energy minimisation via simulated annealing and genetic algorithms. these differ from a conventional evolutionary snake approach, where an energy function is minimised according to a local optimisation strategy and may not converge to extract the target shape, in contrast withthe guaranteed convergence of a global approach. the new technique employing dynamic programming is deployed to extract the inner face boundary, along with a conventional normal-driven technique to extract the outer face boundary. Application to a database of 75 subjects showed that the outer contour was extracted successfully for 96% of the subjects and the inner contour was successful for 82%. the results demonstrated the benefits that could accrue from inclusion of face features, giving an appropriate avenue for future research.
Constraint programming (CP) is in its substance non-algorithmic programming, not last because it is often being applied to problems for which no efficient algorithms exist. A not immediately obvious consequence of thi...
详细信息
the conference materials contain 33 papers. the topics covered include experience withfunctionalprogramming applications, theory and implementation of types, storage reclamation, semantics analysis of imperative ext...
详细信息
ISBN:
(纸本)089791595X
the conference materials contain 33 papers. the topics covered include experience withfunctionalprogramming applications, theory and implementation of types, storage reclamation, semantics analysis of imperative extensions, compiling and performance evaluation, language design, compiler optimization, static analysis, functional algorithms and partial evaluation.
Relational programming is a generalization of functionalprogrammingthat includes aspects of logic programming. We describe a relational language, Drusilla, that retains the lazy, polymorphic and higher-order aspects...
详细信息
ISBN:
(纸本)089791595X
Relational programming is a generalization of functionalprogrammingthat includes aspects of logic programming. We describe a relational language, Drusilla, that retains the lazy, polymorphic and higher-order aspects of functional languages and the flexible handling of non-determinism and search based computation of logic languages. As a result it offers certain economy of expression not found in functional or logic programming. However a complex implementation, using a combination of polymorphic type inference and automatic program transformation to select appropriate representations, is needed to support this language.
Observationally equivalent programs are programs which are indistinguishable in all contexts, as far as their termination property is concerned. In this paper, we present rules preserving observational equivalence, fo...
详细信息
ISBN:
(纸本)089791595X
Observationally equivalent programs are programs which are indistinguishable in all contexts, as far as their termination property is concerned. In this paper, we present rules preserving observational equivalence, for the parallel evaluation of programs using call/cc. these rules allow the capture of continuations in any applicative context and they prevent from aborting the whole computation when a continuation is applied in the extent of the call/cc by which it was reified. As a consequence, these results prove that one can design a functional language with first-class continuations which has transparent constructs for parallelism.
this paper presents our practical experience gained from writing image processing programs in lazy functional languages. We give some benchmarking results comparing median filter operations written in C, Miranda and H...
详细信息
ISBN:
(纸本)089791595X
this paper presents our practical experience gained from writing image processing programs in lazy functional languages. We give some benchmarking results comparing median filter operations written in C, Miranda and Haskell. (the median filter is a common method for removing noise from images.) Also, using a profiling tool, we achieve remarkable improvement of the Haskell code. In particular, we show that the Haskell program runs in constant space, which is difficult to achieve in C without extra programming effort. Although the performance of lazy functional language is beginning to make them feasible for specific purposes such as rapid prototyping, better compilers and tools are still needed to encourage wider use in image processing applications.
Five implementations of different lazy functional languages are compared using a common benchmark of a dozen medium size programs. the benchmarking procedure has been designed such that one set of programs can be tran...
详细信息
ISBN:
(纸本)089791595X
Five implementations of different lazy functional languages are compared using a common benchmark of a dozen medium size programs. the benchmarking procedure has been designed such that one set of programs can be translated automatically into different languages, thus allowing a comparison of the quality of compilers for different lazy functional languages. Aspects studied include compile time, execution time, ease of programming determined by the availability of certain key features, and the quality of the documentation. All compilers studied generate good quality code. the Nijmegen Clean system compiles faster than all the others. the FAST/FCG compiler from Southampton/Amsterdam properly supports arrays. the LML system from Chalmers is the most robust. the Haskell compilers from Chalmers and Glasgow provide the most comprehensive functionality.
the aggregate update problem in functional languages is concerned with detecting cases where a functional array or record update operation can be implemented destructively in constant time. Previous work on this probl...
详细信息
ISBN:
(纸本)089791595X
the aggregate update problem in functional languages is concerned with detecting cases where a functional array or record update operation can be implemented destructively in constant time. Previous work on this problem has assumed a fixed order of evaluation of expressions. In this paper we devise a practical analysis, for first order strict functional languages with flat aggregates, that derives a good order of evaluation for making the updates destructive. We show that for programs with no aliasing, our analysis is more precise than Hudak's abstract reference counting, even if the fixed order of evaluation assumed by Hudak happens to be the right order. We also show that our analysis algorithm runs in polynomial time, and in close to linear time for typical programs. To the best of our knowledge, all previous algorithms of this kind require exponential time.
We answer the following question: Can a deque (double-ended queue) be implemented in a purely functional language such that each push or pop operation on either end of a queue is accomplished in O(1) time in the worst...
详细信息
ISBN:
(纸本)089791595X
We answer the following question: Can a deque (double-ended queue) be implemented in a purely functional language such that each push or pop operation on either end of a queue is accomplished in O(1) time in the worst case? the answer is yes, thus solving a problem posted by Gajewska and Tarjan and by Ponder, McGeer, and Ng, and refining results of Sarnak and Hoogerwoord. We term such a deque real-time, since its constant worst-case behavior might be useful in real time programs (assuming real-time garbage collection, etc.) Furthermore, we show that no restriction of the functional language is necessary, and that push and pop operations on previous versions of a deque can also be achieved in constant time. We present a purely functional implementation of real-time deques and its complexity analysis. We then show that the implementation has some interesting implications, and can be used to give a real-time simulation of a multihead Turing machine in a purely functional language.
this paper describes a method for eliminating a certain class of space leaks in lazy functional languages. A program that space leaks consumes more memory than would be expected. this may lead to longer execution time...
详细信息
ISBN:
(纸本)089791595X
this paper describes a method for eliminating a certain class of space leaks in lazy functional languages. A program that space leaks consumes more memory than would be expected. this may lead to longer execution time, or that the program unnecessarily runs out of memory. It has been known for a long time that functions returning tuples may give rise to space leaks. Hughes [Hug83] has shown that some programs must leak memory, if a sequential evaluator is used. Several researchers have tried to solve this problem, with varying approaches, by introducing the necessary parallelism. Some of them modify the garbage collector, or use special operators to parallelize the programs explicitly. the approach used here is to use pattern bindings in definitions, which are available in most functional languages, to control the parallelism. No modification of the garbage collector or special operators are needed. the method has been implemented in the Chalmers LML/HBC compiler [AJ93, AJ89].
暂无评论