Dept. of Computer and Information science, Linköping University
Last updated: Tue, 02 Dec 1997 11:01:59
Ahrenberg, L. (1986). Lexikalisk-funktionell grammatik på svenska. Technical Report LiTH-IDA-R-86-07, Department of Computer and Information Science, Linköping University, Sweden. Finns i proc. från föredrag vid de nordiska datalingvistikdagarna 1985, Helsingfors Universitet, institutionen för lingvistik. (bibtex),
Abstract: This paper reports our experiences of applying Lexical-Functional Grammar (LFG; Bresnan, 1982) to Swedish grammar construction. The first part of the paper contains a short presentation of the LFG framework, and the second part discusses the division of labour between categorial rules and functional schemas with respect to morphology and the treatment of idioms. It is argued that categorial rules should be used to a larger extent than is done presently, both for reasons of descriptive adequacy and parsing efficiency. The paper is written in Swedish.
Dahlbäck, N. and Jönsson, A. (1986). A System for Studying Human-Computer Dialogues in Natural Language. Technical Report LiTH-IDA-R-86-42, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: The aim of the LINLIN-project, is to develop a robust and general purpose Natural Language interface for Swedish. As one part of the project, basic issues related to the construction of natural language interfaces are studied. We believe that a natural language dialogue between a computer and a human user by means of a natural language interface will in important respects differ from human dialogues, spoken as well as written. To some extent these differences are known now, but there is also a need for empirical studies aiming at uncovering the similarities and differences between these types of dialogues.In this paper we first discuss some aspects on human dialogues versus human-computer dialogues. Thereafter we describe one such research method, namely the simulation of a powerful natural language interface. There are, however, some problems when conducting an experiment using such a simulated natural language equipment. These include the need to control the variation of the responses from the "system" as well as the need to achieve a reasonable response time and appropriate response quality. We have developed a system for making the simulation more effective. In the second part of the paper we describe this system and give some preliminary results obtained by using this method. Planned experimental investigations are also discussed.
Dean, J. A., Lingas, A., and Sack, J.-R. (1986). On Recognizing Polygons, or how to Eavesdrop. Technical Report LiTH-IDA-R-86-41, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc of the Allerton Conference on Communication, Control, and Computing, Urbana, Illinois, 1986. (bibtex),
Abstract: A new class of so called pseudo star-shaped polygons is introduced. A polygon is pseudo star-shaped if there is a point from which we can see/eavesdrop its whole interior provided that it is possible to see/hear through its single edges. The class of pseudo star-shaped polygons generalizes and unifies the well known classes of convex, monotone and pseudo star-shaped polygons. We give algorithms for testing whether a polygon is pseudo star-shaped from a given point in linear time, and for constructing all regions from which the polygon is pseudo star-shaped in quadratic time. Also, we show that many standard computational geometry problems can be solved efficiently for pseudo star-shaped polygons.
Drabent, W. and Maluszynski, J. (1986). Proving Run-Time Properties of Logic Programs. Technical Report LiTH-IDA-R-86-23, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: Certain properties of logic programs are inexpressible in terms of their declarative semantics. One example of such properties would be the actual form of procedure calls and successes which occur during computations of a program. They are often used by programmers in their informal reasoning. In this paper, the inductive assertion method for proving partial correctness of logic programs is introduced and proved sound. The method makes it possible to formulate and prove properties which are inexpressible in terms of the declarative semantics. An execution mechanism using the Prolog computation rule and arbitrary search strategy (eg. OR-parallelism or Prolog backtracking) is assumed. The method may be also used to specify the semantics of some extra-logical built-in procedures for which the declarative semantics is not applicable.
Driankov, D. (1986). A Calculus for Belief-Intervals Representation of Uncertainty. Technical Report LiTH-IDA-R-86-17, Department of Computer and Information Science, Linköping University, Sweden. Also in International Conference on Information Processing and Management of Uncertainty in Expert Systems, Paris, June 30-July 4, 1986. (bibtex),
Abstract: No abstract available
Driankov, D. (1986). Inference with a Single Fuzzy Conditional Proposition. Technical Report LiTH-IDA-R-86-15, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc of IJCAI87 and in International Journal for Fuzzy Sets and Systems. (bibtex),
Abstract: In the works of L. Zadeh, J. Baldwin, E. Hisdal, R. Yager, M. Mizumoto et.al. different solutions to this problem were proposed. Though different, they all share one common feature. It is that they ignore the fact that a single fuzzy conditional proposition represents only one specific manifestaion of the causal influence exerted by X on Y which is being described by binding the fuzzy set B to the fuzzy set A. Thus, the general pattern of the causal relationship between the two linguistic variables is forgotten about. As a result the inference made when the original value of X is replaced by a new one might, in som cases, contradict the general pattern of the causal relationship.The present paper makes an attempt to specify these types of inference with a single fuzzy conditional proposition which do not depend on the general pattern of the causal relationship between X and Y. It also discusses some associated problems.
Driankov, D. (1986). Inference with Consistent Probabilities in Expert Systems. Technical Report LiTH-IDA-R-86-12, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc. of IJCAI-87. (bibtex),
Abstract: The objective of the present paper is twofold: first, to provide an algorithm which helps in eliciting consistent, with respect to the axioms of the probability theory, a priori and conditional probabilities as well as higher order conditional and joint probabilities for a set of events representing pieces of evidence and hypotheses in the context of a rule based expert system. The algorithm proposed, utilizes the least possible number of a priori and conditional probabilities as input in order to obtain all the remaining ones and then, proceeds further by producing the lower and upper bounds for particular higher order conditional and joint probabilities so that these be consistent with the input provided. In the case, when inconsistent lower and upper bounds are obtained, it is shown how the latter can be turned into consistent ones by changing the values of only these input-probabilities which are directly representing the higher order probability expressions under consideration.Secondly, a number of typical cases with respect to the problems of aggregation and propagation of uncertainty in expert systems is presented and it is shown how these can be modelled using the results of the algorithm proposed. For this purpose no global assumptions for independence of evidence and for mutual exclusiveness of hypotheses are required since the presence of independent and/or dependent pieces of evidence as well as the presence of mutually exclusive hypotheses is explicitly encoded in the input-probabilities and thus, such a presence is automatically taken care of by the algorithm when obtaining higher order probabilities.
Driankov, D. (1986). An Outline of Fuzzy Sets Approach to Decision Making with Independent Goals. Technical Report LiTH-IDA-R-86-16, Department of Computer and Information Science, Linköping University, Sweden. Also in International Journal for Fuzzy Sets and Systems. (bibtex),
Abstract: The aim of the present paper is to outline a formal framework for dealing with the problem of decision making with multiple interdependent goals. The approach uses of aspiration levels in order to bridge the gap between the prescriptive and the descriptive approaches thus allowing the problems of evaluation, choice and generation of alternatives to be treated in a coherent formal framework. On the other hand the approach recognizes the existence of interdependent and very often conflicting goals and suggests that in the case when the relationships between the goals can not be modelled by means of mathematical equations one should employ some techniques for knowledge representation based on fuzzy production rules and basic concepts from the theory of approximate reasoning.
Driankov, D. (1986). Uncertainty Calculus with Verbally Defined Belief-Intervals. Technical Report LiTH-IDA-R-86-14, Department of Computer and Information Science, Linköping University, Sweden. Also in International Journal of Intelligent Systems. (bibtex),
Abstract: No abstract available
Fagerström, J. (1986). Tradeoffs in an Architecture based on Asynchronous Processes. Technical Report LiTH-IDA-R-86-22, Department of Computer and Information Science, Linköping University, Sweden. Accepted for 2nd Nordic Symposium on VLSI in Computers and Communications, 1986. (bibtex),
Abstract: Much research today is devoted to finding new and improved computer architectures in which parallel computations can be performed, the goal being an exploitation of the natural parallelism inherent in many problem descriptions. This paper describes a family of architectures based on asynchronous processes. An important aspect of this class of architectures is its modularity. Within the architecture we hope to avoid the usual bottlenecks of Von Neuman machines and at the same time avoid the problem of dynamically binding every operation as in dataflow machines. A silicon compiler can use the modularity of descriptions to perform various optimizations on instances of the architecture. Examples of various trade-offs possible in the architecture are given.
Fagerström, J., Larsson, Y., and Strömberg, L. (1986). Debugging Techniques for Distributed Environments. Technical Report LiTH-IDA-R-86-35, Department of Computer and Information Science, Linköping University, Sweden. Accepted for the Workshop on Compiler and Incremental Compilation, Bautzen, East Germany, October 11-18, 1986 and the Workshop on Programming Environments - Programming Paradigms, Roskilde, Denmark, October 22-24, 1986. (bibtex),
Abstract: The nature of distributed systems complicates methods and tools for debugging and monitoring programs. Non-determinism, non-reproducibility of errors, and a complicated timing of events are some of the added complexities for distributed programs. This paper reports on an approach for debugging tools for procedural languages like ADA1, C[1] or Mesa [2].The debugger, consisting of a master debug module together with small slave debug modules at each node define the active part of the debugging system. High-level traces provide the backbone for examining historic states in the system.We will use these methods to provide an integrated, interactive, and incremental environment, where the user will be able to control the system from a modern, bitmapped, workstation such as SUN or XEROX workstation. The project also include studies of graphical representations of process interaction an, area where experimentation is a necessity.
Fagerström, J., Larsson, Y., and Strömberg, L. (1986). Distributed Debugging - Collected Ideas. Technical Report LiTH-IDA-R-86-21, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: This technical report presents some collected ideas from the field of debugging in the context of distributed systems. The ideas are collected from a large number of sources, some of which were presented and discussed during a number of meetings in the spring of 1986. A number of tools used in a traditional programming environment are examined together with new tools especially devised for distributed systems. Traditional tools such as sequential debuggers and tracing must be placed in the same conceptual framework as new tools such as demons. A model of systems where such tools can be helpful is presented. Finally, a few key issues that are yet to be understood before real programming environments for use in distributed systems can be constructed, are pointed out.
Fagerström, J. and Patel, M. R. (1986). High-level Simulation of Systolic Architecture. Technical Report LiTH-IDA-R-86-24, Department of Computer and Information Science, Linköping University, Sweden. Accepted for the International Workshop on Systolic Arrays, Oxford, July 2-4, 1986. (bibtex),
Abstract: Systolic architectures have proven to be cost-effective and high-performance solutions to a variety of problems often occurring in, for example, signal and image processing. Usually, the developing of a systolic solution to a problem is divided into three major steps: requirements definition, design and implementation. The design phase often consists of an ad hoc choice from a family of possible systolic solutions. To allow the designer to study and evaluate various trade- offs in different designs we propose to use a high-level simulation package tailored for systolic architectures. The system will be used for teaching under-graduates basic design principles as well as well-developed contemporary designs.
Fjellborg, B. (1986). A Simulation Study of Four Binary Tree Structures. Technical Report LiTH-IDA-R-86-19, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: The binary tree is compared with three augmented interconnection structures: the completely linked, half ring, and full ring trees. Their relative performance is compared both with respect to random message exchange as well as for implementations of algorithms for Heapsort and adaptive numerical integration. For the completely linked tree, a fault-tolerant routing algorithm is tested. Execution time is taken as measure. A simulator for this purpose, written in Occam, is described.
Fritzson, P. (1986). A Common Intermediate Representation for C, Pascal, Modula-2 and Fortran-77. Technical Report LiTH-IDA-R-86-38, Department of Computer and Information Science, Linköping University, Sweden. Also presented at the Workshop on Compiler Compilers and Incremental Compilation, Bautzen, DDR, October 12-17, 1986. (bibtex),
Abstract: This paper reports on a unified abstract syntax tree representation, called CIR, which is a program representation for a multi-language environment. The languages in question are C, Pascal, Modula-2 and Fortran-77. Nodes in this intermediate representation usually correspond to syntactic constructs in these languages. It is also possible to reconstruct source text from the CIR representation.It proved possible to achieve a fairly high degree of uniformity in the intermediate representation for the expression and statement parts of these languages. However, the declaration structure proved to be much more irregular, especially for C and Fortran-77. Also, some statistics on different node classes is presented for the languages involved, and a comparison to Diana is done.
Fritzson, P. (1986). Systems and Tools for Exploratory Programming Overview and Examples. Technical Report LiTH-IDA-R-86-36, Department of Computer and Information Science, Linköping University, Sweden. Also presented at the Workshop on Programming Environments - Programming Paradigms, Roskilde, Denmark, October 22-24, 1986. (bibtex),
Abstract: Exploratory programming may perhaps be regarded as a program development methodology. Systems supporting this methodology are characterized as being highly interactive and giving support for rapid program building, and ease of program modification and debugging. This is sometimes contrasted to more formal methodologies which emphasize that a program should be completely specified before it is implemented. The exploratory approach is motivated when we have insufficient knowledge about the application or about the interactions between the application and the environment. Powerful interactive programming environments are also necessary for efficient support and maintenance in the many cases where we have constantly changing requirements. Ideally we would like to merge the results from the formal school and the explorative school. We would like to build incremental programming environments which can support both maintenance of executable specifications and automatic transformation of these specifications into efficient executable code.
Jönsson, A. and Patel, M. (1986). An Interactive Flowcharting Technique for Communicating and Realizing Algorithms. Technical Report LiTH-IDA-R-86-04, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc. of the 19th Annual Hawaii International Conference on System Science, January 8-10, 1986. (bibtex),
Abstract: This paper describes the design, specification, implementation of and experiences from an Interactive Flowcharting Technique for communicating and realizing algorithms. Educating the expert to know how to use the ideas in the same "language" as the other persons in the software development group. Our goals are: to help novices to understand computers, by giving them a framework for organizing algorithms, and to support development of software produced by groups of people over an extended period of time. Based on the notions of Dimensional Flowcharts, a system called the DIMsystem has been developed for handling structured flowcharts.
Kamkar, M. and Shahmehri, N. (1986). Runtime Dependent Program Flow Analysis. Technical Report LiTH-IDA-R-86-40, Department of Computer and Information Science, Linköping University, Sweden. This is a revised version of paper presented at the Workshop on Programming Environments - Programming Paradigms, Roskilde, Denmark, October 22-24, 1986. (bibtex),
Abstract: Most existing debugging tools permit the user to manipulate and inspect the current runtime state of a program. However, more powerful debuggers can be built if both static and dynamic analys are combined into a single tool. In this paper we examine different categories of static program analysis. In particular we propose runtime dependent program flow analysis, where the current runtime state of a program is used to obtain increased precision of flow analysis results. This information can be made available for interactive query during a debugging session.
Karlsson, R. G. (1986). Greedy Matching on a Grid. Technical Report LiTH-IDA-R-86-25, Department of Computer and Information Science, Linköping University, Sweden. Also in BIT. (bibtex),
Abstract: A fast solution to the complete minimum matching problem using a greedy heuristic is presented, when the points are distributed on a grid domain. For this a data structure which efficiently supports nearest neighbor searches and deletions is developed.
Karlsson, R. G. (1986). Point Location in Discrete Computational Geometry. Technical Report LiTH-IDA-R-86-26, Department of Computer and Information Science, Linköping University, Sweden. A preliminary version appeared in Proc. 6th Brazilian Congress on Computing, July 1986. (bibtex),
Abstract: Based on efficient point location on two-dimensional grids fast solutions to several important problems in computational geometry are presented. For orthogonal objects log-logarithmic worst case time algorithms for point location, inclusion queries, and intersection queries, all using moderate storage, are obtained. Finally, an efficient range query algorithm is presented.
Karlsson, R. G. and Munro, J. I. (1986). Proximity on a Grid under L1 and L1 Metrics. Technical Report LiTH-IDA-R-86-27, Department of Computer and Information Science, Linköping University, Sweden. A preliminary version appeared in 2nd Symposium on Theoretical Aspects of Computer Science, 1985, Springer-Verlag, LNCS, 182, 187-196. (bibtex),
Abstract: We introduce a trie based data structure to support nearest neighbor queries, under the L1 and L norms, on a discrete u5 by u grid. It is shown that a static structure, occupying O(n) space to store n points, can be searched in O(loglog u) time. Dynamic and semidynamic (insertions permitted) are also introduced. The dynamic form supports queries and updates in O(log3/2u) time and the semidynamic, in O(log u) time. Both use O(nlog u) space and can be extended to higher dimensions.
Karlsson, R. G. and Overmars, M. H. (1986). Normalized Divide and Conquer: A Scaling Technique for Solving Multi-Dimentional Problems. Technical Report LiTH-IDA-R-86-37, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: A new technique, named normalized divide and conquer is presented to solve multi-dimensional problems on a grid in a very efficient way. It is also shown that a number of problems concerning objects in arbitrary space can be transformed into problems on a grid by using another form of normalization. In this way new solutions are obtained for the multi-dimensional maximal elements and rectangle intersection problem that are more efficient than previous solutions.
Karlsson, R. G. and Overmars, M. H. (1986). Scanline Algorithms on a Grid. Technical Report LiTH-IDA-R-86-30, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: A number of important problems in computational geometry are solved efficiently on 2- or 3-dimensional grids by means of scanline techniques. In the solutions to the maximal elements and closure problems, a factor log n is substituted by loglog u, where n is the set size and u the grid size. Next, by using a data structure introduced in the paper, the interval trie, previous solutions to the rectangle intersection and connected component problems are improved upon. Finally, a fast intersection finding algorithm for arbitrarily oriented line segments is presented.
Komorowski, J. and Maluszynski, J. (1986). Logic Programming and Rapid Prototyping. Technical Report LiTH-IDA-R-86-20, Department of Computer and Information Science, Linköping University, Sweden. Also published as report TR-01-86, Harward University, Aiken Computation Laboratory, USA. (bibtex),
Abstract: No abstract available
Lawson, Jr., and W., H. (1986). An Asynchronous Approach to Microprogramming. Technical Report LiTH-IDA-R-86-09, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: This internal report contains a chapter that will appear in a book with the preliminary title A Microprogramming Handbook to be published by van Nostrand Reinhold, New York. The book, which is edited by Professor Stanley Habib of the City College of New York and Professor Sabrata Dasgupta of the University of Southwest Louisiana, is scheduled for publication during 1987.The chapter contains a comprehensive description of the motivation for, design rationale of, and realization of the DataSaab Flexible Central Processing Unit which was designed in the early 1970s and served as the central processing unit of the DataSaab D23 computer system. The design was based upon a asynchronous strategy that led to several interesting advantages in promoting project organization, testing, manufacturing and maintenance.The lessons learned from the FCPU experience concerning asynchronous control are highly relevant today since the mastering of complexity of VLSI structures will undoubtedly rely upon asynchronous control strategies. Thus, this historic development in the field of microprogramming provides an interesting background to future VLSI directions.
Lawson, Jr., and W., H. (1986). The DATASAAB Flexible Central Processing Unit. Technical Report LiTH-IDA-R-86-06, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: Due to the recent interest in the use of asynchronous control for electronics design, this series of articles is reissued as a Departmental Report. See the article "Logic Designers Through Out the Clock" by Clifford Barney in the 9 December 1985 issue of Electronics for an account of the importance of this approach to electronic systems design. The FCPU described in the articles was designed using an asynchronous strategy for the realization of the microprogram architecture. A review of the design ideas of the FCPU and their implications will appear as a chapter on "Microprogramming: An Asynchronous Approach" to be edited by Stanley Habib and Sabrata Dasgupta and published by von Nostrand Publishing Company.
Lennartsson, B. (1986). Programming Environments and Paradigms - Some Reflections. Technical Report LiTH-IDA-R-86-32, Department of Computer and Information Science, Linköping University, Sweden. Appeared at the Workshop on Programming Environments - Programming Paradigms, Roskilde, Denmark, October 22-24, 1986. (bibtex),
Abstract: The concept Programming Environment is recognized and used in the research community. For some years it has appeared in titles of conferences, workshops, textbooks, and research reports. There is an increasing number of researchers sailing under this flag, meeting to exchange ideas and experiences. In software industry, on the other hand, the problems, methods, and tools are grouped differently. Software Engineering Environments, life cycle support, configuration management, etc., are terms frequently used. The grouping of problems and methods in industry does not match the grouping of ideas and results on the different views, their backgrounds and their meanings.
Levcopoulos, C. (1986). A fast Heuristic for Covering Polygons by Rectangles. Technical Report LiTH-IDA-R-86-03, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc. of Int. Conf. on Fundamentals of Computation Theory (FCT'85), Cottbus, GDR, September 1985 and in Lecture Notes in Computer Science No 199. (bibtex),
Abstract: During the fabrication of masks for integrated circuits, the polygons on the pattern generator must be covered by a preferably as small as possible number of rectangles. In this paper we present a fast and simple heuristic, based on Voronoi diagrams, which covers arbitrary polygons without acute interior angles by rectangles in time 0(nlog+r), where n is the number of edges of the polygon and r is the number, in practice close to n, of rectangles produced, and they suggest that the algorithm is near-optimal.
Levcopoulos, C. (1986). Fast Heuristic for Minimum Length Rectangular Partitions of Polygons. Technical Report LiTH-IDA-R-86-08, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc. of the Second ACM Symposium on Computational Geometry, Yorktown Heights, New York, June 2-4, 1986. (bibtex),
Abstract: We consider the problem of partitioning isothetic polygons into rectangles by drawing edges of minimum total length. The problem has various applications [LPRS], eg in VLSI design when dividing routing regions into channels ([Riv1]). If the polygons contain holes, the problem in NP-hard [LPRS]. In this paper it is shown how solutions within a constant factor of the optimum can be computed in time O(n log n), thus improving the previous O(n2) time bound. An unusual divide-and-conquer technique is employed, involving alternating search from two opposite directions, and further efficiency is gained by using a fast method to sort subsets of points. Generalized Voronoi diagrams are used in combination with plane sweeping in order to detect all "well bounded" rectangles, which are essential for the heuristic.
Levcopoulos, C. (1986). Minimum Length and "Thickest-First" Rectangular Partitions of Polygons. Technical Report LiTH-IDA-R-86-01, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc.of the 23rd Annual Allerton Conference on Communication, Control and Computing, Monticello, Illinois, October, 1985. (bibtex),
Abstract: Partitioning polygons into rectangles by drawing edges of minimum total length has a variety of applications [10], eg. In VLSI design when dividing routing regions into channels [12]. In this paper a simple and efficient greedy approximation algorithms is presented and analyzed, and in this way previous result are improved significantly. Roughly, the idea is to draw every time a maximal rectangle whose shortest side is as long as possible. Also, several other related results are announced.
Lingas, A. (1986). Subgraph Isomorphism for Biconnected Outerplanar Graphs in Cubic Time. Technical Report LiTH-IDA-R-86-10, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc. of the 3rd Symposium on Theoretical Aspects of Computer Science, January 1986, Orsay, France and Lecture Notes in Computer Science, Springer Verlag. (bibtex),
Abstract: It is shown that we can determine whether a biconnected outerplanar graph is isomorphic to a subgraph of another biconnected outerplanar graph in cubic time.
Lingas, A. (1986). THE GREEDY TRIANGULATION HEURISTIC FOR MINIMUM WEIGHT TRIANGULATION OF CONVEX POLYGONS APPROXIMATES THE OPTIMUM. Technical Report LiTH-IDA-R-86-11, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc. of the 2nd ACM Symposium on Computational Geometry, Yorktown Heights, New York, June 1986. (bibtex),
Abstract: No abstract available
Merkel, M. (1986). A Swedish Grammar in D-PATR. Experiences of working with D-PATR. Technical Report LiTH-IDA-R-86-31, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: The D-PATR system is an environment for writing unification-based grammars. In this paper I present an application of D-PATR to Swedish. The paper has four parts: an introduction to unification, the D-PATR system and its notation, a grammar for a subset of Swedish, and a final section where some suggestions on how to improve the D-PATR system are put forward.
Padgham, L. (1986). LINCKS Linköpings Intelligent Knowledge Communication System. Technical Report LiTH-IDA-R-86-18, Department of Computer and Information Science, Linköping University, Sweden. Also presented at I.F.I.P. Conference on Methods and Tools for Office Systems, Pisa, Italy, October 22-24, 1986 and at Interactiva Administrativa System Konferens, Åre 14-16 April, 1986. (bibtex),
Abstract: No abstract available
Peng, Z. (1986). Integration of VLSI Design Tools by a Unified Design Representation. Technical Report LiTH-IDA-R-86-29, Department of Computer and Information Science, Linköping University, Sweden. Published as a part of the Proc of the 2nd Nordic Symposium on VLSI in Computers and Communications, June 2-4, 1986. (bibtex),
Abstract: This paper describes the construction of an integrated VLSI design environment based on a unified design representation. This design representation is derived from timed petri nets and consists of separate but related models of control and data parts. It can represent multi-level details of a design, thus supporting a hierarchical design methodology. The proposed design environment, the CAMAD design aid system, is currently under development at Linköping University. The major properties of CAMAD as well as reasoning behind them are presented.
Peng, Z. (1986). Synthesis of VLSI Systems with the CAMAD Design Aid. Technical Report LiTH-IDA-R-86-28, Department of Computer and Information Science, Linköping University, Sweden. Also published as part of the Proc of the 23rd ADM/IEEE Design Automation Conference, Las Vegas, June 29 - July 2, 1986. (bibtex),
Abstract: CAMAD is a high level design tool which helps designers to model, analyze, and design VLSI systems. This design aid system is based on a unified design representation model derived from timed petri nets and consisting of separate but related models of control and data parts. The present paper describes the automatic synthesis package of the CAMAD system which takes a high level behavioral description as its input and synthesizes it into an implementation structure. This implementation structure may then be partitioned into several quasi-independent modules with well-defined interfaces, which allows potentially asynchronous operation of the designed systems as well as physical distribution of the modules.
Rankin, I. (1986). SMORF - an Implementation of Hellberg's Morphology System. Technical Report LiTH-IDA-R-86-34, Department of Computer and Information Science, Linköping University, Sweden. Also in Proc of the Fifth Scandinavian Conference of Computational Linguistics, University of Helsinki, pp 161-172. (bibtex),
Abstract: No abstract available
Rankin, I. (1986). SMORF User's Guide. Technical Report LiTH-IDA-R-86-33, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: No abstract available
Rönnquist, R. (1986). The Information Lattice of Networks Used for Knowledge Representation. Technical Report LiTH-IDA-R-86-02, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: No abstract available
Sandewall, E. (1986). Department of Computer and Information Science Annual Research Report 1985. Technical Report LiTH-IDA-R-86-05, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: No abstract.
Sandewall, E. et al. (1986). Department of Computer and Information Science Annual Research Report 1986. Technical Report LiTH-IDA-R-86-44, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: No abstract.
Sandewall, E. and Rönnquist, R. (1986). A Representation of Action Structures. Technical Report LiTH-IDA-R-86-13, Department of Computer and Information Science, Linköping University, Sweden. (bibtex),
Abstract: No abstract available
Strömfors, O. (1986). Editing Large Programs Using a Structure-Oriented Text Editor. Technical Report LiTH-IDA-R-86-43, Department of Computer and Information Science, Linköping University, Sweden. Also presented at the International Workshop on Advanced Programming Environments, Trondheim, Norway, June 16-18, 1986. (bibtex),
Abstract: This paper will describe how a structure-oriented text editor, named ED3, is used as a practical and efficient tool for program development and maintenance. Unlike syntax-directed editors this editor does not use its tree structure to represent the parse tree of the program. Instead the user is free to build any tree structure of text nodes he wants. For a block structured language the tree can be built the same way procedures are defined inside procedures.The tree structure helps the programmer handle big programs. Browsing is supported by menus automatically created from the first line of each node. To enter or modify a text node, a screen-oriented text editor is used. Syntax checking (currently for Pascal and Ada) is done by a fast combined parser/pretty-printer. A single-key command will parse and pretty-print the current text node.
Strömfors, O. (1986). A Structure Editor as a Template for Programming Environment Functions. Technical Report LiTH-IDA-R-86-39, Department of Computer and Information Science, Linköping University, Sweden. Also presented at the Workshop on Programming Environments - Programming Paradigms, Roskilde, Denmark, October 22-24, 1986. (bibtex),
Abstract: This paper presents how a structure editor, ED3, can serve as a platform for a number of programming environment functions. The structure editor and its text editing facilities has been in use since 1980. Since then, several functions have been added to it, most recently Ada oriented tools: a syntax checker, a pretty-printer, and a Pascal to Ada syntax translator.The mechanism to reference nodes without any naming encourages the user to look upon the tree as a dynamic structure to be modified whenever convenient. From several years of experience with ED3 it is evident that the block structure of a Pascal program is seldom the most natural view for the programmer.Production quality implementations of ED3 are running on a number of hosts. It is implemented in Pascal and has assisted in translating itself into Ada.