- 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.
Search results
Showing 11 to 20 of 21 (0.09 seconds)| 11 |
Hibridna softverska arhitektura kao podrška primeni harmonijski spojenog metoda konačnih traka / A hybrid software architecture for supporting the harmonic coupled finite strip methodMarić Petar 02 June 2016 (has links)
<p>Ova doktorska teza analizira problem rešavanja karakterističnih<br />jednačina, koje se koriste prilikom rešavanja jednačina svojstvenih<br />oblika, definisanih kroz harmonijski spojen metod konačnih<br />traka. U slučaju složenijih graničnih uslova pokazano<br />je da greške određivanja korenova karakteristične jednačine rastu<br />gotovo eksponencijalno sa svakim narednim modom, usled<br />prirode sâmih karakterističnih jednačina. Tako dobijeni korenovi<br />karakteristične jednačine značajno i nepovoljno utiču na<br />tačnost rešavanja jednačina svojstvenih oblika, izračunavanja<br />određenih integrala, kao i celokupnih proračuna. Predstavljena<br />je hibridna metoda putem koje se na pouzdan nacin određuju<br />korenovi karakterističnih jednačina, rešavaju jednačine svojstvenih<br />oblika i izračunavaju određeni integrali. Razvijen je<br />prototip referentne Open Source implementacije hibridne metode,<br />uz podsistem za automatsku verifikaciju koji rigorozno<br />verifikuje karakteristike hibridne metode i njene referentne implementacije,<br />za sve navedene granične uslove i integrale.</p> / <p>This PhD thesis analyzes the problem of solving the characteristic<br />equations of the basic functions, as defined by the harmonic<br />coupled finite strip method. It’s found that with each increasing<br />mode the characteristic equation root-finding error grows<br />exponentially for all but the most trivial edge boundary conditions,<br />due to the hyperbolic functions involved. These large rootfinding<br />errors will lead to severe accuracy issues when computing<br />basic functions and their integrals, especially for higher modes.<br />A hybrid method for accurately solving characteristic equations<br />and obtaining the required integrals is presented, along with its<br />reference Open Source implementation. An extensive test suite<br />has been developed to verify the hybrid method and its implementation<br />for all the presented boundary conditions and integrals.</p>
|
| 12 |
Abitbol : un langage sur mesure pour la métaprogrammationArchambault-Bouffard, Vincent 04 1900 (has links)
Ce mémoire a pour thèse que les fonctions devraient être transparentes lors de la phase de métaprogrammation. En effet, la métaprogrammation se veut une possibilité pour le programmeur d’étendre le compilateur. Or, dans un style de programmation fonctionnelle, la logique du programme se retrouve dans les définitions des diverses fonctions le composant. Puisque les fonctions sont généralement opaques, l’impossibilité d’accéder à cette logique limite les applications possibles de la phase de métaprogrammation.
Nous allons illustrer les avantages que procurent les fonctions transparentes pour la métaprogrammation. Nous donnerons notamment l’exemple du calcul symbolique et un exemple de nouvelles optimisations désormais possibles. Nous illustrerons également que la transparence des fonctions permet de faire le pont entre les datatypes du programme et les fonctions.
Nous allons également étudier ce qu'implique la présence de fonctions transparentes au sein d'un langage. Nous nous concentrerons sur les aspects reliés à l'implantation de ces dernières, aux performances et à la facilité d'utilisation. Nous illustrerons nos propos avec le langage Abitbol, un langage créé sur mesure pour la métaprogrammation. / Our main thesis is that functions should be transparent during the metaprogramming stage. Metaprogramming is intended as a possibility for the programmer to extend the compiler. But in a functional programming style, the program logic is found in the definition of its functions. Since functions are generally opaque, it is impossible for the programmer to access this information and this limits the metaprogramming possibilities.
We will illustrate the benefits of transparent functions for metaprogramming. We will give the example of symbolic computation and also show new forms of optimizations now available at the metaprogramming stage. We will also illustrate that transparency allows us to bridge the gap between the datatypes of a program and its functions.
We will also examine how transparent functions affects other aspects of the language. We will focus on how to implement them, their performance impact and their ease of use.
We illustrate our thesis with Abitbol, a language designed for metaprogramming.
|
| 13 |
Extending type theory with syntactic models / Etendre la théorie des types à l'aide de modèles syntaxiquesBoulier, Simon Pierre 29 November 2018 (has links)
Cette thèse s'intéresse à la métathéorie de la théorie des types intuitionniste. Les systèmes que nous considérons sont des variantes de la théorie des types de Martin-Löf ou du Calcul des Constructions, et nous nous intéressons à la cohérence de ces systèmes ou encore à l'indépendance d'axiomes par rapport à ces systèmes. Le fil rouge de cette thèse est la construction de modèles syntaxiques, qui sont des modèles qui réutilisent la théorie des types pour interpréter la théorie des types. Dans une première partie, nous introduisons la théorie des types à l'aide d'un système minimal et de plusieurs extensions potentielles. Dans une seconde partie, nous introduisons les modèles syntaxiques donnés par traduction de programme et donnons plusieurs exemples. Dans une troisième partie, nous présentons Template-Coq, un plugin de métaprogrammation pour Coq. Nous montrons comment l'utiliser pour implémenter directement certains modèles syntaxiques. Enfin, dans une dernière partie, nous nous intéressons aux théories des types à deux égalités : une égalité stricte et une égalité univalente. Nous proposons une relecture des travaux de Coquand et. al. et Orton et Pitts sur le modèle cubique en introduisant la notion de fibrance dégénérée. / This thesis is about the metatheory of intuitionnistic type theory. The considered systems are variants of Martin-Löf type theory of Calculus of Constructions, and we are interested in the coherence of those systems and in the independence of axioms with respect to those systems. The common theme of this thesis is the construction of syntactic models, which are models reusing type theory to interpret type theory. In a first part, we introduce type theory by a minimal system and several possible extensions. In a second part, we introduce the syntactic models given by program translation and give several examples. In a third part, we present Template-Coq, a plugin for metaprogramming in Coq. We demonstrate how to use it to implement directly some syntactic models. Last, we consider type theories with two equalities: one strict and one univalent. We propose a re-reading of works of Coquand et.al. and of Orton and Pitts on the cubical model by introducing degenerate fibrancy.
|
| 14 |
Application of Model-Driven Engineering and Metaprogramming to DEVS Modeling & SimulationTouraille, Luc 07 December 2012 (has links) (PDF)
The multiplication of software environments supporting DEVS Modeling & Simulation is becoming a hindrance to scientific collaboration. Indeed, the use of disparate tools in the community makes the exchange, reuse and comparison of models very difficult, preventing practitioners from building on previous works to devise models of ever-increasing complexity. Tool interoperability is not the only issue raised by the need for models of higher and higher complexity. As models grow, their development becomes more error-prone, and their simulation becomes more resource-consuming. Consequently, it is necessary to devise techniques for improving simulators performance and for providing thorough model verification to assist the practitioner during model design. In this thesis, we propose two innovative approaches for DEVS Modeling & Simulation that tackle the aforementioned issues. The first contribution described in this document is a model-driven environment for modeling systems with the DEVS formalism, named SimStudio. This environment relies on Model-Driven Engineering to provide a high-level framework where practitioners can create, edit and visualize models, and automatically generate multiple artifacts, most notably model specifications compatible with various DEVS simulators. The core of SimStudio is a platform-independent metamodel of the DEVS formalism, which provides a pivot format for DEVS models. Based on this metamodel, we developed several model verification features as well as many model transformations that can be used to automatically generate documentation, diagrams or code targeting various DEVS platforms. Thus, SimStudio gives a proof of concept of the integration capabilities that a DEVS standard would provide; as a matter of fact, the metamodel presented in this thesis could possibly serve as a basis for such a standard. The second contribution of this thesis is DEVS-MetaSimulator (DEVS-MS), a DEVS library relying on metaprogramming to generate simulation executables that are specialized and optimized for the model they handle. To do so, the library performs many computations during compilation, resulting in a simulation code where most overhead have been eliminated. The tests we conducted showed that the generated programs were very efficient, but the performance gain is not the only feature of DEVS-MS. Indeed, through metaprogramming, DEVS-MS can also assert the correctness of models by verifying model characteristics at compile-time, detecting and reporting modeling errors very early in the development cycle and with better confidence than what could be achieved with classical testing.
|
| 15 |
Um processo dirigido a modelos para geração de códigoPapotti, Paulo Eduardo 17 May 2013 (has links)
Made available in DSpace on 2016-06-02T19:06:04Z (GMT). No. of bitstreams: 1
5180.pdf: 8285938 bytes, checksum: 0110755140178ec91052f03c8f73ca2d (MD5)
Previous issue date: 2013-05-17 / Universidade Federal de Sao Carlos / Software development is an activity in constant change over time. Given the complexity and high cost that exists in software construction, there is high demand, especially in the software industries, for methodologies and tools that enable to increase software productivity by spending less time and effort in its development. Among the challenges that exist in Software Engineering, there is a need in knowing and exploring techniques and tools that enable to increase productivity and maintai software quality. Approaches related to model-driven development can be used as a starting point for modeling and to specify the requirements of a software system. Models provide a representation with higher level of abstraction of system design and assist to understand the system. Through the execution of model-to-code transformation mechanisms, implementation artifacts for different technologies can be generated based on data extracted and interpreted from models. Furthermore, reflexive metaprogramming is a technique that can be used to complement the code generation performed by model-to-code transformations, automating most of tasks of developers, such as CRUD (Create, Retrieve, Update, Delete) functionalities, freeing them to perform more important tasks in development process. Therefore, this research proposes a software process to guide professionals in developing applications using such techniques to accomplish code generation, in order to increase software productivity and facilitate maintenance. / O desenvolvimento de software é uma atividade em constante mudança ao longo do tempo. Diante da complexidade e do alto custo existente na construção de um software, existe uma grande demanda, sobretudo nas indústrias de software, por metodologias e ferramentas que possibilitem aumentar a produtividade de software, gastando menos tempo e esforços em seu desenvolvimento. Dentre os desafios existentes na Engenharia de Software, existe a necessidade de conhecer e explorar diferentes técnicas e ferramentas que viabilizem aumentar a produtividade mantendo a qualidade do software. Abordagens relacionadas ao desenvolvimento dirigido a modelos podem ser utilizadas como ponto de partida para modelar e especificar os requisitos de um sistema de software. Os modelos fornecem uma representação com maior nível de abstração do projeto do sistema e auxiliam na compreensão do sistema. Por meio da aplicação de mecanismos de transformação de modelos em código, é possível gerar código de artefatos de implementação para diferentes tecnologias a partir de dados extraídos e interpretados dos modelos. Além disso, a metaprogramação reflexiva é uma técnica que pode ser empregada para complementar a geração de código realizada por transformações de modelos, automatizando grande parte das tarefas do desenvolvedor, tais como as funcionalidades CRUD (Create, Retrieve, Update, Delete), liberandoo para atuar em outras tarefas mais importantes do processo de desenvolvimento. Dessa forma, este trabalho define um processo de software que visa orientar os profissionais no desenvolvimento de aplicações utilizando tais técnicas para realizar geração código, que tem como objetivo aumentar a produtividade de software e facilitar sua manutenção.
|
| 16 |
Indexování objektů v 3D prostoru / 3D Spatial Indexing of ObjectsDrbal, Miroslav January 2010 (has links)
This diploma thesis defines the term indexing and in preamble are discussed known indexing algorithms and difference between indexing static and moving objects. The practical part of this diploma thesis is aimed to designing and implementing of indexing algorithm for open source application MaNGOS with respect to generic design pattern and effectiveness of spatial search queries for selection of the objects given properties in the specified area. At the end I present and discuss reached results.
|
| 17 |
Typer a de la classe : le polymorphisme ad hoc dans un langage avec des types dépendants et de la métaprogrammationBarszcz, Jean-Alexandre 05 1900 (has links)
La modularité est un enjeu important en programmation, surtout quand on l’enrichit avec des preuves, comme dans les langages avec des types dépendants. Typer est un tel langage, et afin d’augmenter sa modularité et de lui ajouter un moyen de faire la surcharge d’opérateurs, on s’inspire d’Agda et Coq et on l’étend avec les arguments instances, qui généralisent les classes de types de Haskell. Un aspect qui distingue notre conception est que comme Typer généralise les définitions, la généralisation des contraintes de classe est grandement facilitée. Pour pouvoir faire les preuves de lois de classes, on doit également ajouter l’élimination dépendante des types inductifs au langage, dont certains aspects sont en retour facilités par les arguments instances. Sur la base de ces deux fonctionnalités, on offre également une solution au problème de la cécité booléenne, tel que décrit par Harper. / Modularity is an important concern for software development, especially when the latter is enriched with proofs in a language with dependent types. Typer is such a language, and in order to increase its modularity, and also provide a way to overload operators, we take inspiration from Agda and Coq and extend it with instance arguments, a generalization of Haskell’s type classes. An aspect that sets our design apart is that since Typer generalizes definitions, it greatly simplifies the generalization of class constraints. In order to allow writing proofs for class laws, we must also implement the dependent elimination of inductive types. In return, instance arguments facilitate some details of dependent elimination. Using both features, we suggest a solution to the problem of Boolean Blindness.
|
| 18 |
Metaprogramming Program AnalyzersGuannan Wei (16650384) 28 July 2023 (has links)
<p>Static program analyzers are vital tools to produce useful insights about programs without executing these programs. These insights can be used to improve the quality of programs, e.g., detecting defects in programs, or optimizing programs to use fewer resources. However, building static program analyzers that are simultaneously sound, performant, and flexible is notoriously challenging.</p>
<p>This dissertation aims to address this challenge by exploring the potential of applying correct-by-construction metaprogramming techniques to build static program analyzers. Metaprogramming techniques manipulate and transform programs as data objects. In this thesis, we consider static program analyzers as the objects to be manipulated or transformed. We show that metaprogramming techniques can improve our understanding, the construction, flexibility, and performance of program analyzers.</p>
<p>We first study the inter-derivation of abstract interpreters. Using off-the-shelf program transformation techniques such as refunctionalization, we demonstrate that big-step abstract interpreters can be mechanically derived from their small-step counterparts, thus building a functional correspondence between two different styles of abstract interpretation.</p>
<p>To build high-performance program analyzers, we exploit the first Futamura projection to build compilers for abstract interpretation and symbolic execution. The first Futamura projection states that specializing an interpreter with respect to an input program is a process equivalent to compilation, thus providing a practical way to repurpose interpreters for compilation and code generation. We systematically apply this idea to build program-analysis compilers by writing analyzers as staged interpreters using higher-level abstractions. The staged interpreter can be used for generating sound and performant analysis code given a specific input program. Moreover, the approach enables using abstractions without regret: by using higher-level program abstractions, the analyzer can be written in a way that is close to its high-level specification (e.g. big-step operational semantics), and by compilation, the analyzer is performant since it does not need to pay the runtime overhead of using these abstraction mechanisms.</p>
<p>We also develop novel type systems that track sharing and separation in higher-order imperative languages. Such type systems are useful both for general-purpose programming languages and for optimization of domain-specific metaprograms such as those program-analysis compilers.</p>
<p><br></p>
|
| 19 |
Implementace součtového datového typu v C++ / Implementation of Sum Data Type in C++Novák, Samuel Matyáš January 2020 (has links)
Práce se zaobírá problematikou implementace součtového datového typu v jazyce C++. Nejprve navrhuje vlastní abstrakce pro manipulaci s posloupnostmi hodnot a typů, které následně umožňují vyjadřovat komplexní operace deklarativně. V průběhu implementace jsou prezentovány návrhové vzory obvyklé pro oblast metaprogramování. Implementace přichází s rozhodnutími odlišnými od referenční implementace. Pro manipulaci se součtovým typem jsou představeny dvě šablony funkce, lišící se sémantikou. Užití součtového typu je ukázano na příkladu konečného stavového automatu.
|
| 20 |
Well-Formed and Scalable Invasive Software Composition / Wohlgeformte und Skalierbare Invasive SoftwarekompositionKarol, Sven 26 June 2015 (has links) (PDF)
Software components provide essential means to structure and organize software effectively. However, frequently, required component abstractions are not available in a programming language or system, or are not adequately combinable with each other. Invasive software composition (ISC) is a general approach to software composition that unifies component-like abstractions such as templates, aspects and macros. ISC is based on fragment composition, and composes programs and other software artifacts at the level of syntax trees. Therefore, a unifying fragment component model is related to the context-free grammar of a language to identify extension and variation points in syntax trees as well as valid component types. By doing so, fragment components can be composed by transformations at respective extension and variation points so that always valid composition results regarding the underlying context-free grammar are yielded. However, given a language’s context-free grammar, the composition result may still be incorrect.
Context-sensitive constraints such as type constraints may be violated so that the program cannot be compiled and/or interpreted correctly. While a compiler can detect such errors after composition, it is difficult to relate them back to the original transformation step in the composition system, especially in the case of complex compositions with several hundreds of such steps. To tackle this problem, this thesis proposes well-formed ISC—an extension to ISC that uses reference attribute grammars (RAGs) to specify fragment component models and fragment contracts to guard compositions with context-sensitive constraints. Additionally, well-formed ISC provides composition strategies as a means to configure composition algorithms and handle interferences between composition steps.
Developing ISC systems for complex languages such as programming languages is a complex undertaking. Composition-system developers need to supply or develop adequate language and parser specifications that can be processed by an ISC composition engine. Moreover, the specifications may need to be extended with rules for the intended composition abstractions.
Current approaches to ISC require complete grammars to be able to compose fragments in the respective languages. Hence, the specifications need to be developed exhaustively before any component model can be supplied. To tackle this problem, this thesis introduces scalable ISC—a variant of ISC that uses island component models as a means to define component models for partially specified languages while still the whole language is supported. Additionally, a scalable workflow for agile composition-system development is proposed which supports a development of ISC systems in small increments using modular extensions.
All theoretical concepts introduced in this thesis are implemented in the Skeletons and Application Templates framework SkAT. It supports “classic”, well-formed and scalable ISC by leveraging RAGs as its main specification and implementation language. Moreover, several composition systems based on SkAT are discussed, e.g., a well-formed composition system for Java and a C preprocessor-like macro language. In turn, those composition systems are used as composers in several example applications such as a library of parallel algorithmic skeletons.
|
Page generated in 0.0983 seconds