Compilers and interpreters Books

Book SynopsisAdvanced Guide to Python 3 Programming 2nd Edition delves deeply into a host of subjects that you need to understand if you are to develop sophisticated real-world programs. Each topic is preceded by an introduction followed by more advanced topics, along with numerous examples, that take you to an advanced level.This second edition has been significantly updated with two new sections on advanced Python language concepts and data analytics and machine learning. The GUI chapters have been rewritten to use the Tkinter UI library and a chapter on performance monitoring and profiling has been added. In total there are 18 new chapters, and all remaining chapters have been updated for the latest version of Python as well as for any of the libraries they use. There are eleven sections within the book covering Python Language Concepts, Computer Graphics (including GUIs), Games, Testing, File Input and Output, Databases Access, Logging, Concurrency and Parallelism, Reactive Programming, Networking and Data Analytics. Each section is self-contained and can either be read on its own or as part of the book as a whole. It is aimed at those who have learnt the basics of the Python 3 language but wish to delve deeper into Python’s eco system of additional libraries and modules.Table of ContentsIntroduction.- Part 1: Advanced language features.- Python type hints.- Class slots.- Weak references.- Data classes.- Structural pattern matching.- Working with pprint.- Shallow v deep copy.- The __init__versus __new__ and __call__.- Python metaclasses and meta programming.- Part 2: Computer graphics and GUIs.- Introduction to computer graphics.- Python turtle graphics.- Computer generated art.- Introduction to Matplotlib.- Graphing with Matplotlib pyplot.- Graphical user interfaces.- Tkinter GUI library.- Events in Tkinter user interfaces.- PyDraw Tkinter example application.- Part 3: Computer graphics and GUIs.- Introduction to games programming.- Building games with pygame.- StarshipMeteors pygame.- Part 4: Testing.- Introduction to testing.- PyTest testing framework.- Mocking for testing.- Part 5: File Input / Output.- Introduction to files, paths and IO.- Reading and writing files.- Stream IO.- Working with CSV files.- Working with excel files.- Regular expressions in Python.- Part 6: Database access.- Introduction to databases.- Python DB-API.- PyMySQL module.- Part 7: Logging.- Introduction to logging.- Logging in Python.- Advanced logging.- Part 8: Concurrency and parallelism.- Introduction to concurrency and parallelism.- Threading.- MultiProcessing.- Inter thread / Process synchronisation.- Futures.- Concurrency with AsyncIO.- Performance monitoring and profiling.- Part 9: Reactive programming.- Reactive programming introduction.- RxPy observables, observers and subjects.- RxPy operators.- Part 10: Network programming.- Introduction to sockets and web services.- Sockets in Python.- Web services in Python.- Flask web services.- Flask bookshop web service.- Part 11: Data analytics and machine learning.- Introduction to data science.- Pandas and data analytics.- Alternatives to pandas.- Machine learning in Python.- Pip and Conda virtual environments.

Read more less

Book SynopsisTesting is the primary hardware and software verification technique used by industry today. Usually, it is ad hoc, error prone, and very expensive. In recent years, however, many attempts have been made to develop more sophisticated formal testing methods. This coherent book provides an in-depth assessment of this emerging field, focusing on formal testing of reactive systems. This book is based on a seminar held in Dagstuhl Castle, Germany, in January 2004. It presents 19 carefully reviewed and revised lectures given at the seminar in a well-balanced way ensuring competent complementary coverage of all relevant aspects. An appendix provides a glossary for model-based testing and basics on finite state machines and on labelled transition systems. The lectures are presented in topical sections on testing of finite state machines, testing of labelled transition systems, model-based test case generation, tools and case studies, standardized test notation and execution architectures, and beyond testing.Table of ContentsTesting of Finite State Machines.- I. Testing of Finite State Machines.- 1 Homing and Synchronizing Sequences.- 2 State Identification.- 3 State Verification.- 4 Conformance Testing.- II. Testing of Labeled Transition Systems.- Testing of Labeled Transition Systems.- 5 Preorder Relations.- 6 Test Generation Algorithms Based on Preorder Relations.- 7 I/O-automata Based Testing.- 8 Test Derivation from Timed Automata.- 9 Testing Theory for Probabilistic Systems.- III. Model-Based Test Case Generation.- Model-Based Test Case Generation.- 10 Methodological Issues in Model-Based Testing.- 11 Evaluating Coverage Based Testing.- 12 Technology of Test-Case Generation.- 13 Real-Time and Hybrid Systems Testing.- IV. Tools and Case Studies.- Tools and Case Studies.- 14 Tools for Test Case Generation.- 15 Case Studies.- V. Standardized Test Notation and Execution Architecture.- Standardized Test Notation and Execution Architecture.- 16 TTCN-3.- 17 UML 2.0 Testing Profile.- VI. Beyond Testing.- Beyond Testing.- 18 Run-Time Verification.- 19 Model Checking.- VII. Appendices.- Appendices.- 20 Model-Based Testing – A Glossary.- 21 Finite State Machines.- 22 Labelled Transition Systems.

Read more less

Book SynopsisThis book constitutes the refereed proceedings of the 23rd International Conference on Computer Aided Verification, CAV 2011, held in Snowbird, UT, USA, in July 2011. The 35 revised full papers presented together with 20 tool papers were carefully reviewed and selected from 161 submissions. The papers are organized in topical sections on the following workshops: 4th International Workshop on Numerical Software Verification (NSV 2011), 10th International Workshop on Parallel and Distributed Methods in Verifications (PDMC 2011), 4th International Workshop on Exploiting Concurrency Efficiently and Correctly (EC2 2011), Frontiers in Analog Circuit Synthesis and Verification (FAC 2011), International Workshop on Satisfiability Modulo Theories, including SMTCOMP (SMT 2011), 18th International SPIN Workshop on Model Checking of Software (SPIN 2011), Formal Methods for Robotics and Automation (FM-R 2011), and Practical Synthesis for Concurrent Systems (PSY 2011).

Read more less

Book SynopsisThis book constitutes the refereed proceedings of the 16th International Conference on Model Driven Engineering Languages and Systems, MODELS 2013, held in Miami, FL, USA, in September/October 2013. The 47 full papers presented in this volume were carefully reviewed and selected from a total of 180 submissions. They are organized in topical sections named: tool support; dependability; comprehensibility; testing; evolution; verification; product lines; semantics; domain-specific modeling languages; models@RT; design and architecture; model transformation; model analysis; and system synthesis.Table of ContentsTool support.- Dependability.- Comprehensibility.- Testing.- Evolution.- Verification.- Product lines.- Semantics.- Domain-specific modeling languages.- Design and architecture.- Model transformation.- Model analysis.- System synthesis.

Read more less

Book SynopsisDas Buch vermittelt die Fähigkeit, zu jeder Zeit an jedem Ort Probleme mit Java erfolgreich zu lösen. Nach dem Einstieg mit kleinen klassischen Programmieraufgaben wird schrittweise und mit vielen Beispielen an die anspruchsvolleren Bestandteile von JAVA herangeführt. Mit der Zeichenkettenarbeit kommen die Objekte und Klassen. Eigene Klassen werden programmiert, Konstruktoren und das Überladen werden erklärt. Schließlich leiten Vererbung, abstrakte Klassen und Interfaces über zur Herstellung von Benutzeroberflächen mit Java und zu den Java-Applets. Über die Inhalte des Buches hinaus können Programmbeispiele, Übungen und Lösungen vom kostenlosen Onlineservice zum Buch heruntergeladen werden.Trade Review"Der Autor ist bekannt durch Bücher, in denen Einsteiger ohne Vorkenntnisse, gestützt auf viele Beispiele, in die Sprachen Delphi und Turbo-Pascal eingeführt werden. Ähnlich geht das vorliegende Buch bei der Einführung in Java, der Sprache des Internets, vor. [...] Auch dieser Weg der vielen kleinen Schritte führt zum Verständnis von Klassen, Konstruktoren, Vererbung und Überladen von Methoden." ekz-Informationsdienst, ID 9/06 - BA 4/06Table of ContentsProgramm und Programmiersprache - Java-Prinzip, Verarbeitung von Java-Programmen - Strukturiertes Programmieren mit Java - Arbeit mit String-Objekten, eigene Objekte - Klassen, Konstruktoren, Überladen von Methoden - Java als Methodensammlung, Java-Dokumentation - Vererbung, abstrakte Klassen, Interfaces - Benutzeroberflächen mit Java programmieren - 150 Programmbeispiele - 80 Übungen mit Lösungen, alle Dateien online verfügbar

Read more less

Book SynopsisIt is the first book that I have read that makes STL quickly usable by working programmers Francis Glassborow, Chair of The Association of C & C++ Users (ACCU) STL for C++ programmers Leen Ammeraal The Standard Template Library (STL) provides many useful and generally applicable programming tools. This book combines reference material and a well-paced tutorial to get you past the basics quickly. Small, complete programs illustrate the key STL features such as containers, algorithms, iterators and function objects. A section is devoted to the new string data type. All STL algorithms are formally presented by their prototypes and then informally described to show how to use them in practice. Concepts are well illustrated with a large number of example programs all of which are available via ftp (for access details please refer to the preface of the book or Wiley''s website). Finally, special examples are given to explain the advanced notions of function objects and function adaptors, incTable of ContentsSTL for Beginners. More Algorithms and Containers. Sequence Containers. Associative Containers. Container Adaptors. Function Objects and Adaptors. Generic Algorithms. An Application: Very Large Numbers. Bibliography. Index.

Read more less

Book SynopsisEach statistical chapter in the second part relies on one or more real biomedical data sets, kindly made available by the Bordeaux School of Public Health (Institut de Santé Publique, d'Épidémiologie et de Développement - ISPED) and described at the beginning of the book.Trade ReviewFrom the book reviews:“This is a great addition to the chorus of books on R. It is a clear an excellent resource for teaching courses on data analysis and statistical computing using R at the graduate and advanced undergraduate levels. The book can be an asset for data scientists, and even more broadly for a wide variety of users including students, teachers, researchers, software engineers, and others whose work involves statistics, mathematics, and computer science.” (Yousri El Fattah, Computing Reviews, January, 2015)Table of ContentsForeward.- Basic Concepts and Data Organisation.- Importing, Exporting and Producing Data.- Data Manipulation, Functions.- R and its Documentation.- Drawing Curves and Plots.- Programming in R.- Managing Sessions.- Basic Mathematics.- Descriptive Statistics.- A Better Understanding of Random Variables.- Confidence Intervals and Hypothesis Testing.- Simple and Multiple Linear Regression.- Elementary Analysis of Variance.- Installing R and R Packages.- References.- Indices.- Solutions.

Read more less

Book SynopsisLearn how Roslyn s new code generation capability will let you write software that is more concise, runs faster and is easier to maintain. You will learn from real-world business applications to create better software by letting the computer write its own code based on your business logic already defined in lookup tables.Table of Contents1. Introduction2. Putting Business Logic in Tables3. Pulling Table Driven Logic into Code4. An Introduction to Roslyn5. Generating Code6. Deploying Generated Code7. Reflecting on Generated Code8. Best Practices

Read more less

Book SynopsisRely on this robust and thorough guide to build and maintain successful test automation. As the software industry shifts from traditional waterfall paradigms into more agile ones, test automation becomes a highly important tool that allows your development teams to deliver software at an ever-increasing pace without compromising quality. Even though it may seem trivial to automate the repetitive tester''s work, using test automation efficiently and properly is not trivial. Many test automation endeavors end up in the graveyard of software projects. There are many things that affect the value of test automation, and also its costs. This book aims to cover all of these aspects in great detail so you can make decisions to create the best test automation solution that will not only help your test automation project to succeed, but also allow the entire software project to thrive.One of the most important details that affects the success of the test automation is Table of Contents Part 1: The “Why” and the “What”.- Chapter 1: The Value of Test Automation.- Chapter 2: From Manual to Automated Testing.- Chapter 3: People and Tools.- Chapter 4: Reaching Full Coverage.- Chapter 5: Business Processes.- Chapter 6: Test Automation and Architecture.- Chapter 7: Isolation and Test Environments.- Chapter 8: The Big Picture.- Part 2: The “How”.- Chapter 9: Preparing for the Tutorial.- Chapter 10: Designing the First Test Case.- Chapter 11: Start Coding the First Test.- Chapter 12: Completing the First Test.- Chapter 13: Investigating Failure.- Chapter 14: Adding More Tests.- Chapter 15: Continuous Integration.- Chapter 16: Acceptance Test Driven Development.- Chapter 17: Unit tests and TDD.- Chapter 18: Other Types of Automated Tests.- Chapter 19: Where to Go from Here.- Appendix A: Real-World Examples.- Appendix B: Cleanup Mechanism.- Appendix C: Test Automation Essentials.- Appendix D: Tips and Practices for Programmer’s Productivity.-

Read more less

Book Synopsis Discover how Verilog-A is particularly designed to describe behavior and connectivity of circuits and system components for analog SPICE-class simulators, or for continuous time (SPICE-based) kernels in Verilog-AMS simulators. With continuous updates since it''s release 30 years ago, this practical guide provides a comprehensive foundation and understanding to the  modeling language in its most recent standard formulation.  With the introduction of language extensions to support compact device modeling, the Verilog-A has become today de facto standard language in the electronics industry for coding compact models of active and passive semiconductor devices. You''ll gain an in depth look at how analog circuit simulators work, solving system equations, modeling of components from other physical domains, and modeling the same physical circuits and systems at various levels of detail and at different levels of abstraction. Table of ContentsChapter 1: IntroductionChapter Goal: Verilog-A delineation. Comparison to other HDLs and modeling languages. Book organization.Chapter 2: The Lexical Basis of Verilog-AChapter Goal: Introducing Verilog-A lexical tokens, token separators as well as basic token groups and token containers.Chapter 3: Basic Types and ExpressionsChapter Goal: Introducing integer, real and string data types and how expressions are assembled for different types using operators.Chapter 4: Nets and SignalsChapter Goal: Introducing the concept of nets and signals defined by nature and net_discipline types.Chapter 5: Modules and NetlistsChapter Goal: Introducing modules, as basic units of hierarchy in Verilog-A language, and their instantiation in SPICE and Verilog-A netlists.Chapter 6: Parameters and ParamsetsChapter Goal: Introducing the concept of parameters, customization of modules by passing parameters into a module at instantiation and the concept of instance and model parameters defined via paramsets.Chapter 7: Branch Contribution StatementsChapter Goal: Introducing the concept of analog branch assignments and signal access mechanisms.Chapter 8: Procedural StatementsChapter Goal: Introducing analog procedural block and procedural control statements.Chapter 9: Derivative and Integral OperatorsChapter Goal: Detailed description of analog functions used to perform differentiation and integration in time.Chapter 10: Built-in Mathematical FunctionsChapter Goal: Define all Verilog-A standard mathematical function.Chapter 11: User Defined FunctionsChapter Goal: Describe how to write modular, maintainable and reusable models in Verilog-A using user defined functions.Chapter 12: Analog Filter FunctionsChapter Goal: Introducing Verilog-A time and frequency domain filter functions and their usage with constant and dynamic arguments.Chapter 13: Look-Up Table ModelsChapter Goal: Describing how to create a multidimensional interpolation lookup-up table models in Verilog-AChapter 14: Small Signal and Noise SourcesChapter Goal: Introducing Verilog-A functions supporting small signal and noise analysis in SPICE simulators.Chapter 15: EventsChapter Goal: Introducing methods to control analog behaviour of the component models in Verilog-A.Chapter 16: Input and OutputChapter Goal: Describe methods and functions to read and write formatted data.Chapter 17: Simulator Query and Control MethodsChapter Goal: Describing the methods to access the simulator kernel parameters in the Verilog-A model.Chapter 18: AttributesChapter Goal: Introducing attributes as a mechanism for specifying properties about objects, statements and groups of statements in the Verilog-A source that can be used by the simulator.Chapter 19: Compiler DirectivesChapter Goal: Introducing compiler directives that dictate Verilog-A compiler behaviour in a pre-processingcompilation phase.Chapter 20: SPICE CompatibilityChapter Goal: Describes the degree of compatibility with SPICE-like simulators which Verilog-A provides and the approach taken to provide that compatibility.

Read more less

Book SynopsisGo from competent C++ developer to skilled designer or architect using this book as your personal C++ design master class. Updated for the C++20 standard, this title will guide you through the design and implementation of an engaging case study that forms the backdrop for learning the art of applying design patterns and modern C++ techniques to create a high quality, robust application.  Starting with a quick exploration of the requirements for building the application, you''ll delve into selecting an appropriate architecture, eventually designing and implementing all of the necessary modules to meet the project''s requirements. By the conclusion of Practical C++ Design, you''ll have constructed a fully functioning calculator capable of building and executing on any platform that supports both Qt and C++20. Access to the complete source code will help speed your learning. Utilize the Model-View-Controller pattern as the basis for the architecTable of ContentsPreface (5 pages)The preface details my motivation for writing the book, the target audience for the book, thegeneral structure of the book, and how to contact the author. Of particular importance is therationale behind choosing the case study, the target language (C++), and the GUI toolkit (Qt).Chapter 1: Defining the Case Study (6 pages)The first chapter describes, in detail, the case study to be examine in the book. The chapterdiscusses requirements in the abstract and then transitions to the calculator’s specific requirements.This sets the stage for the remainder of the book, which describes, in detail, the design andimplementation of the calculator, pdCalc, proposed in Chapter 1.1. A Brief Introduction2. A Few Words About Requirements3. Reverse Polish Notation (RPN)4. The Calculator’s Requirements5. The Source Code1The advice, information, and conclusions discussed in this book are those of the author and have not beenendorsed by, or reflect the opinions or practices of, ExxonMobil Corporation or its affiliates.5Chapter 2: Decomposition (18 pages)In this chapter, I explain the elements of a good decomposition and strategies for decomposing aproblem into manageable pieces. Subsequently, an architecture for pdCalc is selected, the calculatoris modularized, and use cases are used to develop interfaces for the high level calculator modules.The four high level modules are the stack, the command dispatcher, the user interface (subdividedinto a command line interface and a graphic user interface), and a plugin manager.1. The Elements of a Good Decomposition2. Selecting An Architecture3. Interfaces4. Assessment of Our Current Design5. Next StepsChapter 3: The Stack (20 pages)The stack is the first module discussed in detail. The stack is the fundamental data repositoryof the calculator. As part of the calculator’s design and implementation, the singleton pattern isexplored. The stack also affords the first opportunity to discuss an event system for the calculator,which provides a backdrop for exploration of the observer pattern, including the design andimplementation of reusable publisher and observer abstract classes.1. Decomposition of the Stack Module2. The Stack Class3. Adding Events4. A Quick Note on TestingChapter 4: The Command Dispatcher (32 pages)This chapter describes the design and implementation of the command dispatcher, the module ofthe calculator responsible for the creation, storage, and execution of commands. Of particular notein this chapter is the exposition on the command pattern and how it can be used to implement apractical undo/redo framework. In addition to exploring a traditional deep hierarchy method forimplementing commands, a C++11 alternative using lambda expressions and the standard functiontemplate are presented as a modern alternative design.1. The Decomposition of the Command Dispatcher2. The Command Class3. The Command Repository4. The Command Manager5. The Command Dispatcher6. Revisiting Earlier Decisions6Chapter 5: The Command Line Interface (14 pages)This chapter marks an important milestone, the creation of the first user executable program.In addition to building a simple command line interface, we’ll explore how to create an abstractsoftware interface suitable for both a command line interface and a graphical user interface. Withinthe context of the command line interface, we’ll learn techniques for simple parsing and tokenizingof input text streams.1. The User Interface Abstraction2. The Concrete CLI Class3. Tying It Together: A Working ProgramChapter 6: The Graphical User Interface (24 pages)In this chapter, we build the Qt-based graphical user interface for the calculator. Here, we’llexamine different strategies for building GUIs, abstraction of GUI elements, and modularization ofthe overall GUI design. Included in the discussion is design for the separation of on-screen widgetsfrom look-and-feel.1. Requirements2. Building GUIs3. Modularization4. A Working Program5. A Microsoft Windows Build NoteChapter 7: Plugins (38 pages)In this chapter, I describe how to build a cross-platform plugin system. This system includes theabstract interface for C++ plugins as well as the operating system specific mechanics involved withloading plugins and executing plugin functions. In the concrete case of the plugin loader, I explainthe many build tricks that can be used to handle cross-platform code and demonstrate how theabstract factory pattern provides an elegant design solution to this problem.1. What Is a Plugin?2. Problem 1: The Plugin Interface3. Problem 2: Loading Plugins4. Problem 3: Retrofitting pdCalc5. Incorporating Plugins6. A Concrete Plugin7. Next Steps7Chapter 8: New Requirements (24 pages)Any developer who has ever worked on a production software project quickly learns that newrequirements are always added late in the development cycle. In this chapter, we explore theaddition of new user requests after the original requirements have already been satisfied. Thediscussion progresses from fully implemented solutions to design only solutions to vague ideas forthe reader to explore on her own.1. Fully Designed New Features2. Designs Toward a More Useful Calculator3. Some Interesting Extensions for Self-ExplorationAppendix A: Acquiring, Building, and Executing pdCalc (4 pages)This appendix explains how to download the source code from GitHub and how to build the casestudy on Linux and Windows. Once the program is built, readers will want to execute the codeand its included test suite; execution instructions are therefore provided.1. Getting The Source Code2. Dependencies3. Building pdCalc4. Executing pdCalcAppendix B: Organization of the Source Code (6 pages)This appendix simply explains the organization of the source tree for pdCalc. This appendix isuseful for finding the locations for the source files referenced in the text.1. The src Directory2. The test DirectoryReferences (2 pages)This section lists twenty-nine references cited in the book.Index (3 pages)This section is a complete index for the book.

Read more less

Book SynopsisHarness the power of MATLAB for deep-learning challenges. Practical MATLAB Deep Learning, Second Edition, remains a one-of a-kind book that provides an introduction to deep learning and using MATLAB''s deep-learning toolboxes. In this book, you''ll see how these toolboxes provide the complete set of functions needed to implement all aspects of deep learning. This edition includes new and expanded projects, and covers generative deep learning and reinforcement learning.Over the course of the book, you''ll learn to model complex systems and apply deep learning to problems in those areas. Applications include: Aircraft navigation An aircraft that lands on Titan, the moon of Saturn, using reinforcement learning Stock market prediction Natural language processing Music creation usng generative deep learning Plasma control Earth sensor processing for spacecraft MATLAB Bluetooth data acquisition applied to danTable of Contents1. What is deep learning? – no changes except editoriala. Machine learning vs. deep learningb. Approaches to deep learningc. Recurrent deep learningd. Convolutional deep learning2. MATLAB machine and deep learning toolboxesa. Describe the functionality and applications of each toolboxb. Demonstrate MATLAB toolboxes related to Deep Learningc. Include the text toolbox generative toolbox and reinforcement learning toolboxd. Add more detail on each3. Finding Circles – no changes except editorial.4. Classifying movies – no changes except editorial.5. Tokamak disruption detection – this would be updated.6. Classifying a pirouette – no changes except editorial.7. Completing sentences - This would be revamped using the MATLAB Text Processing Toolbox.8. Terrain based navigation-The example in the original book would be changed to a regression approach that can interpolate position. We would switch to a terrestrial example applicable to drones.9. Stock prediction – this is a very popular chapter. We would improve the algorithm.10. Image classification – no changes except editorial.11. Orbit Determination – add inclination to the algorithm.12. Earth Sensors – a new example on how to use neural networks to measure roll and yaw from any Earth sensor.13. Generative deep learning example. This would be a neural network that generates pictures after learning an artist’s style.14. Reinforcement learning. This would be a simple quadcopter hovering control system. It would be simulation based although readers would be able to apply this to any programmable quadcopter.

Read more less

Book SynopsisThis handy reference book detailing the intricacies of R covers version 4.x features, including numerous and significant changes to syntax, strings, reference counting, grid units, and more. Starting with the basic structure of R, the book takes you on a journey through the terminology used in R and the syntax required to make R work. You will find looking up the correct form for an expression quick and easy. Some of the new material includes information on RStudio, S4 syntax, working with character strings, and an example using the Twitter API. With a copy of the R 4 Quick Syntax Reference in hand, you will find that you are able to use the multitude of functions available in R and are even able to write your own functions to explore and analyze data. What You Will LearnDiscover the modes and classes of R objects and how to use themUse both packaged and user-created functions in RImport/export data and create new data objects in RCreate descriptive functions and manipulate objecTable of ContentsPart 1: R Basics1. Downloading R and Setting Up a File System2. The R Prompt3. Assignments and OperatorsPart 2: Kinds of Objects4. Modes of Objects5. Classes of ObjectsPart 3: Functions6. Packaged Functions7. User Created Functions8. How to Use a FunctionPart 4: I/O and Manipulating Objects9. Importing/Creating Data10. Exporting from R11. Descriptive Functions and Manipulating ObjectsPart 5: Flow control12. Flow Control13. Examples of Flow Control14. The Functions ifelse() and switch()Part 6: Some Common Functions, Packages and Techniques15. Some Common Functions16. The Packages base, stats and graphics17. The Tricks of the Trade

Read more less

Book SynopsisQuickly find solutions to dozens of common programming problemsencountered while building Java applications, with recipes presented in the popular problem-solution format. Look up the programming problem that you want to resolve. Read the solution. Apply the solution directly in your own code. Problem solved!Java 17 Recipes is updated to reflect changes in specification and implementation since the Java 9 edition of this book. Java 17 is the next long-term support release (LTS) of the core Java Standard Edition (SE) version 17 which also includes some of the features from previous short term support (STS) releases of Java 16 and previous versions.This new edition covers of some of the newest features, APIs, and more such as pattern matching for switch, Restore Always-Strict-Floating-Point-Semantics, enhanced pseudo-random number generators, the vector API, sealed classes, and enhancements in the use of String. Source code for all recipes is available in a dedicated GitHub repository. Table of Contents1. Getting Started with Java 172. Java 17 Enhancements3. Strings4. Numbers and Dates5. Object-Oriented Java6. Lambda Expressions7. Data Structures and Collections8. Input and Output9. Exceptions and Logging10. Concurrency11. Debugging and Unit Testing12. Unicode, Internationalization, and Currency Codes13. Working with Databases14. JavaFX Fundamentals15. Graphics with JavaFX16. Media with JavaFX17. Java Web Applications18. Nashorn and Scripting19. E-mail20. JSON and XML Processing21. Networking22. Java Modularity

Read more less

Book SynopsisDiscover what's new in C# and .NET for Windows programming. This book isa condensed code and syntax reference to the C# programming language, updated with the latest features of version 10 for .NET 6.You'll review the essential C# 10 and earlier syntax, not previously covered, in a well-organized format that can be used as a handy reference. Specifically, unions, generic attributes, CallerArgumentExpression, params span, Records,Init only setters,Top-level statements,Pattern matching enhancements,Native sized integers,Function pointers and more. You'll find a concise reference to the C# language syntax: short, simple, and focused code examples; a well laid out table of contents; and a comprehensive index allowing easy review. You won't find any technical jargon, bloated samples, drawn-out history lessons, or witty stories. What you will find is a language reference that is to the point and highly accessible.The book is a must-have for any C# programmer. What You Will LearnEmploy nuTable of Contents1. Hello World2. Compile and Run3. Variables4. Operators5. Strings6. Arrays7. Conditionals8. Loops9. Methods10. Class11. Inheritance12. Redefining Members13. Access Levels14. Static15. Properties16. Indexers17. Interfaces18. Abstract19. Namespaces20. Enum21. Exception Handling22. Operator Overloading23. Custom Conversions24. Struct25. Preprocessors26. Delegates27. Events28. Generics29. Constants30. Asynchronous Methods

Read more less

Book SynopsisTake advantage of Python to automate complex systems with readable code. This new edition will help you move from operations/system administration into easy-to-learn coding.You''ll start by writing command-line scripts and automating simple DevOps-style tasks followed by creating reliable and fast unit tests designed to avoid incidents caused by buggy automation. You''ll then move on to more advanced cases, like using Jupyter as an auditable remote-control panel and writing Ansible and Salt extensions.The updated information in this book covers best practices for deploying and updating Python applications. This includes Docker, modern Python packaging, and internal Python package repositories. You''ll also see how to use the AWS API, and the Kubernetes API, and how to automate Docker container image building and running. Finally, you''ll work with Terraform from Python to allow more flexible templating and customTable of ContentsChapter 1 (Installing Python) Different ways to install Python: • Compiling from source • OS packages • pyenv Chapter 2 (Packaging) (31 pages – 11 new pages) How pip works and how to build packages. The following sections need to change Section about pip (adds 4 pages) • Add explanation about how the resolver works • Explain pip-compile Poetry and pipenv (changes 2 pages, adds 2 pages) • Needs to be separated into two sections• Poetry section updated to reflect changes in Poetry • Pipenv section updated to reflect changes in Pipenv 4setup.py and wheel (rewritten, changes 1 page, adds 2 pages) • python -m build and setup.cfg • Add details about binary wheels and manylinux • Show a complete example Chapter 3: Interactive usage How to use the interactive interpreter, other text-mode interactive consoles, and Jupyter. Chapter 4: OS Automation (16 pages – 4 new pages) Automating OS-related things like files and processes. Section about files (2 pages added)• Cover using struct to parse binary data • Cover pathlib New section: low-level networking (2 pages) Cover socket, socket options, and how it relates to TCP networking. 5 Chapter 5: Testing (30 pages – 10 new pages) Writing unit tests for DevOps code. Section about testing files (4 pages added) • Improve performance of file testing using tmpfs and preloading libraries • Add information about temporary directory context manager Section about testing networking (4 pages added) • Show how to test httpx with the WSGI support • Show how to test low-level socket networking with DI Section about testing processes (2 pages changed) • Mention run and Popen • Show how to write tests with DI on run and Popen 6 Chapter 6: Text manipulation How to work with text: searching, modifiying, formatting, etc. Chapter 7: Requests -> httpx (rewritten – 10 new pages) • Focus on httpx instead • Cover async usage Chapter 8: Cryptography Symmetric and asymmetric encryption and digital signatures, and how to use them in DevOps code. Chapter 9: Paramiko Using paramiko to automate SSH use. Chapter 10: Salt Stack Using salt stack and writing new modules. Chapter 11: Ansible Using ansible and writing new modules. Chapter 12: Docker (5 new pages) • Clean up examples – they are hard to read • Show complete example of layering, not just talk in theory • Show complete example of running, not just talk in theory • Add section about how to build containers for Python applications Chapter 13: AWS Automating AWS using the boto3 library. New: Chapter 14: Kubernetes (10 pages) Chapter goal: Learn how to automate k8s with Python and how to run Python applications on k8s • Packaging Python applications for kubernetes – Using secrets – Thinking in Pods • Automating k8s from Python using the REST API • Writing k8s operators with Python New: Chapter 15: Terraform (5 pages) • Using the Terraform Python CDK • Generating Terraform JSON from Python

Read more less

Book SynopsisCovering all the essential components of Unix/Linux, including process management, concurrent programming, timer and time service, file systems and network programming, this textbook emphasizes programming practice in the Unix/Linux environment. Systems Programming in Unix/Linux is intended as a textbook for systems programming courses in technically-oriented Computer Science/Engineering curricula that emphasize both theory and programming practice. The book contains many detailed working example programs with complete source code. It is also suitable for self-study by advanced programmers and computer enthusiasts.Systems programming is an indispensable part of Computer Science/Engineering education. After taking an introductory programming course, this book is meant to further knowledge by detailing how dynamic data structures are used in practice, using programming exercises and programming projects on such topics as C structures, pointers, link lists and trees.This book provides a wide range of knowledge about computer systemsoftware and advanced programming skills, allowing readers to interface with operatingsystem kernel, make efficient use of system resources and develop application software.It also prepares readers with the needed background to pursue advanced studies inComputer Science/Engineering, such as operating systems, embedded systems, databasesystems, data mining, artificial intelligence, computer networks, network security,distributed and parallel computing.Table of ContentsChapter 1. Introduction to Unix/Linux.- Chapter 2. Programming Background.- Chapter 3 Process Management in Unix/Linux.- Chapter 4 Concurrent Programming.- Chapter 5 Timers and Time Service.- Chapter 6 Signals and Signal Processing.- Chapter 7 File Operations.- Chapter 8 System Calls for File Operations.- Chapter 9 Library I/O FunctionsChapter 10 Sh Programming.- Chapter 11 EXT2 File System.- Chapter 12. Block Device I/O and Buffer Management.- Chapter 13 TCP/IP and Network Programming.

Read more less

Book SynopsisThis book provides readers with a single-source reference to static-single assignment(SSA)-based compiler design. It is the first (and up to now only) book that coversin a deep and comprehensive way how an optimizing compiler can be designed usingthe SSA form. After introducing vanilla SSA and its main properties, the authorsdescribe several compiler analyses and optimizations under this form. They illustratehow compiler design can be made simpler and more efficient, thanks to the SSA form.This book also serves as a valuable text/reference for lecturers, making the teaching ofcompilers simpler and more effective. Coverage also includes advanced topics, such ascode generation, aliasing, predication and more, making this book a valuable referencefor advanced students and practicing engineers. Table of Contents1. Introduction 2. Properties and flavors3. Standard Construction and Destruction Algorithms4. Advanced Construction Algorithms for SSA5. SSA Reconstruction6. Functional Representations of SSA7. Introduction8. Propagating Information using SSA9. Liveness10. Loop Tree and Induction Variables11. Redundancy Elimination12. Introduction13. Static Single Information form 14. Graphs and Gating Functions 15. Psi-SSA Form 16. Hashed SSA form: HSSA 17. Array SSA Form 18. SSA Form and Code Generation 19. Instruction Code Selection 20. If-Conversion 21. SSA Destruction for Machine Code 22. Register Allocation 23. Hardware Compilation using SSA 24. Building SSA in a Compiler for PHP

Read more less

Book SynopsisThis textbook is about learning Android and developing native apps using the Java programming language. It follows Java and Object-Oriented (OO) programmers’ experiences and expectations and thus enables them to easily map Android concepts to familiar ones. Each chapter of the book is dedicated to one or more Android development topics and has one or more illustrating apps. The topics covered include activities and transitions between activities, Android user interfaces and widgets, activity layouts, Android debugging and testing, fragments, shared preferences, SQLite and firebase databases, XML and JSON processing, the content provider, services, message broadcasting, async task and threading, the media player, sensors, Android Google maps, etc. The book is intended for introductory or advanced Android courses to be taught in one or two semesters at universities and colleges. It uses code samples and exercises extensively to explain and clarify Android coding and concepts. It is written for students and programmers who have no prior Android programming knowledge as well as those who already have some Android programming skills and are excited to study more advanced concepts or acquire a deeper knowledge and understanding of Android programming. All the apps in the book are native Android apps and do not need to use or include third-party technologies to run.Table of Contents1. Java Review.- 2. Getting Started with Android.- 3. Your First Android Application.- 4. Debugging and Testing Using Junit, Espresso, and Mockito Frameworks.- 5. Activity Lifecycle and Passing Objects Between Screens Using Parcelable Interface.- 6. User Interface Essential Classes, Layouts, Styles, Themes, and Dimensions.- 7. ListView, ScrollList, Date and Time Pickers, and RecyclerView.- 8. Toolbar, Menu, Dialog Boxes, Shared Preferences, Implicit Intent, and Directory Structure.- 9. Fragments, Dynamic Binding, Inheritance, Pinching, and Screen Swiping.- 10. Parsing Remote XML and JSON Files, Using HTTPUrlConnection, XmlPullParser, and AsyncTask.- 11. Android SQLite, Firebase, and Room Databases.- 12. Content Provider, Service, Message Broadcasting, and Multimedia Player.- 13. Sensors, Location-Based Service, and Google Maps.

Read more less

Book SynopsisThis book constitutes the proceedings of the 27th International Conference on Formal Methods for Industrial Critical Systems, FMICS 2022, which took place in Warsaw, Poland, in September 2022. The 13 full papers included in this book were carefully reviewed and selected from 22 submissions. They were organized in topical sections as follows: Certification; industrial use cases; testing and monitoring; and methodology.Table of ContentsInvited Keynote Talks.- Reinforcement Learning with Guarantees That Hold for Ever.- Supporting Railway Innovations with Formal Modelling and Verification.- Certification.- Formal Monotony Analysis of Neural Networks with Mixed Inputs: An asset for certification.- Generating Domain-specific Interactive Validation Documents.- Deductive Verification of Smart Contracts with Dafny.- Industrial use cases.- Towards Reusable Formal Models for Custom Real-time Operating Systems.- Formal verification of an industrial UML-like model using mCRL2.- Chemical Case Studies in KeYmaera X.- Analysing Capacity Bottlenecks in Rail Infrastructure by Episode Mining.- Testing and monitoring.- Test Suite Augmentation for Recon gurable PLC Software in the Internet of Production.- Monitoring of Spatio-Temporal Properties with nonlinear SAT solvers.- Model-Based Testing of Internet of Things Protocols.- Methodology.- Formally Verifying Decompositions of Stochastic Specifications.- Verification of Behavior Trees using Linear Constrained Horn Clauses.- A Multi-level Methodology for Behavioral Comparison of SoftwareIntensive Systems.

Read more less

Book SynopsisThis book constitutes the refereed proceedings of the 5th International Conference on Logic and Argumentation, CLAR 2023, held in Hangzhou, China, during September 10-12, 2023. The 11 full papers, one short paper and one invited paper presented in this book were carefully reviewed and selected from 20 submissions. The papers focus on topics such as: ​logic and automated deduction; abstract and structured argumentation; dialogues, games and practical reasoning; and quantitative argumentation.Table of Contents​Logic and Automated Deduction.- Dynamic Modal Logic with Counting: when Reduction Axioms Work and Fail.- Solving Modal Logic Problems by Translation to Higher-order Logic.- Formalizing the Unexpected Hanging Paradox: a Classical Surprise.- Abstract and Structured Argumentation.- Weakest Link in Formal Argumentation: Lookahead and Principle-based Analysis.- A Logical Encoding for k-m-Realization of Extensions in Abstract Argumentation.- Topological Conditions and Solutions for Repairing Argumentation Frameworks.- Dialogues, Games and Practical Reasoning.- Providing personalized Explanations: a Conversational Approach.- Audience irrelevance in Strategic Argumentation Games.- A Structured Bipolar Argumentation Theory for Providing Explanations in Practical Reasoning.- Quantitative Argumentation.- A Filtering-based General Approach to Learning Rational Constraints of Epistemic Graphs.- Fuzzy Labeling Semantics for Quantitative Argumentation.- A Logic for Preference Lifting under Uncertainty and its Decidability.

Read more less

Book SynopsisThis book constitutes the revised selected papers of the 8th Summer School, CEFP 2019, held in Budapest, Hungary, during June 2019.The 7 full papers and the 4 short papers included in this volume were carefully reviewed and selected. The lectures cover various programming subjects with a focus on composability, comprehensibility, and correctness of working software.Table of ContentsMain Lectures.- PhD Workshop.

Read more less

Book SynopsisThis book constitutes the proceedings of the 16th International Conference on Informatics in Schools: Situation, Evolution and Perspectives, ISSEP 2023, held in Lausanne, Switzerland, during October 23–25, 2023. The 14 full papers presented in this book were carefully reviewed and selected from 47 submissions. They are organized in four topical sections named: artificial intelligence and its applications; competitions, problem solving, and computational; robotics and unplugged modalities; and curricula and computer science concepts. This is an open access book.Table of ContentsEducation and Awareness for Artificial Intelligence.- What is AI-PACK? Outline of AI competencies for teaching with DPACK.- Implementing a Portable Learning Lab on Artificial Intelligence: It's AI in a Box!.- Investigating the Role of ChatGPT in Supporting Text-Based Programming Education for Students and Teachers.- All Green: How Different Age Groups Solved the Same Bebras Task.- Effects of the COVID-19 pandemic on the Bebras Computational Thinking Challenge: Comparing numbers, examining reasons and investigating recommendations.- The Function of Note-Taking in Problem Solving in the Computer Science Escape Game Room.- An Exploratory Investigation on High-School Students’ Understanding of Threads.- Combining Models to Orchestrate an Instructional Scenario Fostering Computational Thinking in Educational Robotics.- Teachers' Knowledge in Informatics---Exploring Educational Robotics Resources Through the Lens of Textual Data Analysis.- Reshaping Unplugged Computer Science Workshops for Primary School Education.- Evaluating the New Secondary CS Curriculum in the Netherlands - The Teachers’ Perspective.- Navigating the Implementation of the Curriculum Digital Education in Austrian Secondary Schools: Challenges and Teacher Perspectives.- Bridging the Gap: Infusing Natural Science Classes with Computer Science Concepts and Skills.

Read more less

Book SynopsisCovering all the essential components of Unix/Linux, including process management, concurrent programming, timer and time service, file systems and network programming, this textbook emphasizes programming practice in the Unix/Linux environment. Systems Programming in Unix/Linux is intended as a textbook for systems programming courses in technically-oriented Computer Science/Engineering curricula that emphasize both theory and programming practice. The book contains many detailed working example programs with complete source code. It is also suitable for self-study by advanced programmers and computer enthusiasts.Systems programming is an indispensable part of Computer Science/Engineering education. After taking an introductory programming course, this book is meant to further knowledge by detailing how dynamic data structures are used in practice, using programming exercises and programming projects on such topics as C structures, pointers, link lists and trees.This book provides a wide range of knowledge about computer systemsoftware and advanced programming skills, allowing readers to interface with operatingsystem kernel, make efficient use of system resources and develop application software.It also prepares readers with the needed background to pursue advanced studies inComputer Science/Engineering, such as operating systems, embedded systems, databasesystems, data mining, artificial intelligence, computer networks, network security,distributed and parallel computing.Table of ContentsChapter 1. Introduction to Unix/Linux.- Chapter 2. Programming Background.- Chapter 3 Process Management in Unix/Linux.- Chapter 4 Concurrent Programming.- Chapter 5 Timers and Time Service.- Chapter 6 Signals and Signal Processing.- Chapter 7 File Operations.- Chapter 8 System Calls for File Operations.- Chapter 9 Library I/O FunctionsChapter 10 Sh Programming.- Chapter 11 EXT2 File System.- Chapter 12. Block Device I/O and Buffer Management.- Chapter 13 TCP/IP and Network Programming.

Read more less

Book SynopsisMit diesem Buch schlagen Sie drei Fliegen mit einer Klappe: Sie lernen HTML und JavaScript und zugleich die Kunst des Programmierens. Man benötigt nur einen Editor und einen Browser und schon kann man mit den ersten Beispielen starten. Das Buch regt mit vielen praxisnahen Aufgaben zum eigenen Programmieren an. Es enthält viele Aufgaben, die anhand der Beispielprogramme gelöst werden können. Schrittweise treten Sie damit in die faszinierende Welt des Webdesigns ein. Beispiele, Lösungen und Ergänzungen lassen sich aus dem Internet problemlos herunterladen.Table of ContentsTextgestaltung.- Protokolle, Verweise und Bilder.- Listen und Tabellen.- Formatvorlagen (CCS).- Formulare und Ereignisse.- Grundlagen von JavaScript.- Operatoren.- Ablaufkontrolle.- Objekte und Arrays.- Rahmen und Fenster.- Funktionen.

Read more less

Book SynopsisLernen Sie Programmieren mit Freude. Zahlreiche Beispiele machen den Einstieg in schwierige Themen einfach. Datenstrukturen und Algorithmen werden so in ihrem vollen Umfang anschaulich dargestellt. Anhand vieler Übungsaufgaben kann das Erlernte direkt ausprobiert werden. Ausführliche Lösungen erleichtern das Selbststudium und sichern den Lernerfolg. Table of ContentsEinführung in die objektorientierte Programmierung - Darstellung von Daten - Das NET-Framework - Vordefinierte Datentypen - Arrays - Operationen und Ausdrücke - Statische Methoden und Variablen - Programmsteuerung - Klassen und Objekte

Read more less

Book Synopsis0 Einleitung und Notationen.- 0.1 Historische Entwicklung.- 0.2 Einführende Beispiele.- 0.3 Schreibweisen.- 0.4 Testfragen.- 1 Einfache Datentypen und Ein/Ausgabe.- 1.1 AufZählungstypen und Unterbereichstypen.- 1.2 CHAR, siehe A.2.2.- 1.3 BOOLEAN, siehe A.2.2.- 1.4 Ordinale und Simple Typen.- 1.5 Zahlbezeichnungen.- 1.6 INTEGER, siehe A.2.2.- 1.7 REAL, siehe A.2.2.- 1.8 String, vgl. 5.3.- 1.9 Einfache Ein/Ausgabe mit READ, WRITE.- 1.10 Testfragen.- 2 Einfacher Programmaufbau.- 2.1 Verfügbarmachung externer Dateien, vgl. 8.- 2.2 Vereinbarungen.- 2.3 Testfragen.- 3 Ausdrücke.- 3.1 Primärausdrücke.- 3.2 Ausdrücke, allgemein.- 3.3 Testfragen.- 4 Anweisungen.- 4.1 Assignment Statement.- 4.2 Empty Statement.- 4.3 IF Statement.- 4.4 CASE Statement.- 4.5 Schleifen.- 4.6 Folgen von Anweisungen (compound statement).- 4.7 Label, GOTO Statement.- 4.8 Testfragen.- 5 Reihung (Array) und Mengenbildung (SET).- 5.1 Reihungstyp, Komponente.- 5.2 PACKED, vgl. A.2.5.2.- 5.3 String, vgl. 1.8.- 5.4 Potenzmengentyp, Mengen-Aggregat.- 5.5 Testfragen.- 6 Zeiger und Verbund.- 6.1 Zeiger (^ Symbol).- 6.2 Verbund (RECORD).- 6.3 Testfragen.- 7 Unterprogramme.- 7.1 Unterprogramm-Technik.- 7.2 Parameterübergabe.- 7.3 Konforme Reihungsschemata (level 1 implementation).- 7.4 Prozedur (PROCEDURE).- 7.5 Funktion (FUNCTION).- 7.6 Rundreise-Problem.- 7.7 Bereichsschachtelung.- 7.8 Testfragen.- 8 Datei (File).- 8.l Sequentieller Dateityp, Modus, Komponente.- 8.2 Text-Datei (TEXT), siehe A.2.2/5/6.- 8.3 Testfragen.- A Anhang.- A. l Syntax-Diagramme.- A.2 Standard-Bibliothek (Vordefinierte Vereinbarungen).- A.2.1 Standard-Konstanten.- A.2.2 Standard-Typen.- A.2.3 Standard-Operationen.- A.2.3.1 Arithmetic Operations.- A.2.3.2 Relational Operations.- A.2.3.3 Boolean Operations.- A.2.3.4 Set Operations.-A.2.3.5 Other Operations'.- A.2.4 Standard-Funktionen.- A.2.4.1 Arithmetic Functions.- A.2.4.2 Boolean Functions (Predicates).- A.2.4.3 Transfer Functions.- A.2.4.4 Further Standard Functions.- A.2.5 Standard-Prozeduren.- A.2.5.1 Dynamic Allocation Procedures.- A.2.5.2 Data Transfer Procedures.- A.2.5.3 File Handling Procedures.- A.2.5.4 Input- Procedures READ and READLN.- A.2.5.5 Output-Procedures WRITE and WRITELN.- A.2.6 Standard-Dateien INPUT, OUTPUT.- Übg Übungsaufgaben.- Geordnet nach dem ACM-Index.- Lit Literaturverzeichnis.- Lit. l Lehrbücher.- Lit.2 Anwendungen.- Ind Alphabetischer Index.- Fachausdrücke, deutsch/englisch.Table of Contents0 Einleitung und Notationen.- 0.1 Historische Entwicklung.- 0.2 Einführende Beispiele.- 0.2.1 Anzahl der Buchstaben E/e in einem Satz.- 0.2.2 Turm von Hanoi, rekursive Lösung.- 0.3 Schreibweisen.- 0.3.1 Quelltext-Zeichen und lexikalische Symbole.- 0.3.2 Verwendung des Syntax-Diagramms, siehe A.1.- 0.3.3 Kommentar.- 0.4 Testfragen.- 1 Einfache Datentypen und Ein/Ausgabe.- 1.1 AufZählungstypen und Unterbereichstypen.- 1.2 CHAR, siehe A.2.2.- 1.3 BOOLEAN, siehe A.2.2.- 1.4 Ordinale und Simple Typen.- 1.5 Zahlbezeichnungen.- 1.6 INTEGER, siehe A.2.2.- 1.7 REAL, siehe A.2.2.- 1.8 String, vgl. 5.3.- 1.9 Einfache Ein/Ausgabe mit READ, WRITE.- 1.10 Testfragen.- 2 Einfacher Programmaufbau.- 2.1 Verfügbarmachung externer Dateien, vgl. 8.- 2.2 Vereinbarungen.- 2.2.1 Zielvereinbarung (LABEL).- 2.2.2 Konstantenvereinbarung (CONST).- 2.2.3 Typvereinbarung (TYPE).- 2.2.4 Variablenvereinbarung (VAR).- 2.3 Testfragen.- 3 Ausdrücke.- 3.1 Primärausdrücke.- 3.1.1 Aufrufe von Standard-Funktionen, siehe A.2.4.- 3.1.2 Rundung ROUND, Abschneiden TRUNC.- 3.2 Ausdrücke, allgemein.- 3.2.1 Prioritäten von Operatoren.- 3.2.2 Ganzahlige Division DIV, Rest MOD.- 3.3 Testfragen.- 4 Anweisungen.- 4.1 Assignment Statement.- 4.2 Empty Statement.- 4.3 IF Statement.- 4.4 CASE Statement.- 4.5 Schleifen.- 4.5.1 FOR Statement.- 4.5.2 WHILE Statement.- 4.5.3 REPEAT Statement.- 4.6 Folgen von Anweisungen (compound statement).- 4.7 Label, GOTO Statement.- 4.8 Testfragen.- 5 Reihung (Array) und Mengenbildung (SET).- 5.1 Reihungstyp, Komponente.- 5.2 PACKED, vgl. A.2.5.2.- 5.3 String, vgl. 1.8.- 5.4 Potenzmengentyp, Mengen-Aggregat.- 5.5 Testfragen.- 6 Zeiger und Verbund.- 6.1 Zeiger (^ Symbol).- 6.1.1 Zeigertyp, Allokation, Selektor.- 6.2 Verbund (RECORD).- 6.2.1 Verbundtyp, Komponente, Selektor.- 6.2.2 Namensabkürzung für Komponenten (WITH).- 6.3 Testfragen.- 7 Unterprogramme.- 7.1 Unterprogramm-Technik.- 7.1.1 Unterprogramm-Vereinbarung, FORWARD- Spezifikation.- 7.1.2 Unterprogramm-Aufruf, Rekursion.- 7.2 Parameterübergabe.- 7.2.1 Wert-Parameter.- 7.2.2 VAR -Parameter.- 7.2.3 Unterprogramm-Parameter.- 7.3 Konforme Reihungsschemata (level 1 implementation).- 7.4 Prozedur (PROCEDURE).- 7.5 Funktion (FUNCTION).- 7.6 Rundreise-Problem.- 7.7 Bereichsschachtelung.- 7.7.1 Vereinbart / nicht vereinbart.- 7.7.2 Lokal / global.- 7.7.3 Erzeugt / nicht erzeugt, Ausnahmen.- 7.7.4 Aufrufbar / unterdrückt.- 7.7.5 Bereichsfreie Größen, Speicherbereinigung,u.a.m..- 7.8 Testfragen.- 8 Datei (File).- 8.l Sequentieller Dateityp, Modus, Komponente.- 8.2 Text-Datei (TEXT), siehe A.2.2/5/6.- 8.3 Testfragen.- A Anhang.- A. l Syntax-Diagramme.- A.2 Standard-Bibliothek (Vordefinierte Vereinbarungen).- A.2.1 Standard-Konstanten.- A.2.2 Standard-Typen.- A.2.3 Standard-Operationen.- A.2.3.1 Arithmetic Operations.- A.2.3.2 Relational Operations.- A.2.3.3 Boolean Operations.- A.2.3.4 Set Operations.- A.2.3.5 Other ‘Operations’.- A.2.4 Standard-Funktionen.- A.2.4.1 Arithmetic Functions.- A.2.4.2 Boolean Functions (Predicates).- A.2.4.3 Transfer Functions.- A.2.4.4 Further Standard Functions.- A.2.5 Standard-Prozeduren.- A.2.5.1 Dynamic Allocation Procedures.- A.2.5.2 Data Transfer Procedures.- A.2.5.3 File Handling Procedures.- A.2.5.4 Input- Procedures READ and READLN.- A.2.5.5 Output-Procedures WRITE and WRITELN.- A.2.6 Standard-Dateien INPUT, OUTPUT.- Übg Übungsaufgaben.- Geordnet nach dem ACM-Index.- Lit Literaturverzeichnis.- Lit. l Lehrbücher.- Lit.2 Anwendungen.- Ind Alphabetischer Index.- Fachausdrücke, deutsch/englisch.

Read more less

Book SynopsisParts of this text were used for several years by students in a one~term under­ graduate course in computer science. The students had to prepare projects in small groups (2~4 students).1 This book emphasizes practical experience with image processing. It offers a comprehensive study of • image processing and image analysis, • basics of speech processing, • object~oriented programming, • software design, • and programming in C++. The book is divided into four parts. In the first part we introduce image processing, image analysis, programming tools, and the basics of C++. In the second part we describe object~oriented programming in general and the possible applications of object~oriented concepts in C++. Several appli­ cations of object~oriented programming for image processing are discussed as well. The new features of C++ are introduced entirely through the use of examples. We cover the proper representation of the data that is a result of pattern analysis as well. The third part describes a complete system for image segmentation. Some of the material covered refers to the exercises found in the first and second parts: this verifies our belief that an image segmentation system of programs can be developed while simultaneously acquainting others to C++. We combine the data representation described in the second part with the algorithms that use and manipulate them here in the third part.Table of ContentsI Introductions.- 1 Pattern Recognition.- 1.1 Images and Sound.- 1.2 Applications of Pattern Recognition.- 1.3 Environment, Problem Domain, and Patterns.- 1.4 Characterization of Pattern Recognition.- 1.5 Recording of Speech Signals.- 1.6 Video Cameras and Projections.- 1.7 From Continuous to Digital Signals.- 1.8 Sampling Theorem in Practice.- 1.9 Visualization and Sound Generation.- 2 From C to C++.- 2.1 Syntax Notation.- 2.2 Principle of C++ Compilation.- 2.3 Function Calls and Arguments.- 2.4 Declaration and Definition of Variables.- 2.5 Unix-File Access via Standard Functions.- 2.6 Formatted Input and Output.- 2.7 Main Program.- 2.8 Preprocessor Directives.- 2.9 Conditional Compilation.- 3 Software Development.- 3.1 Software for Pattern Recognition.- 3.2 Principles of Software Development.- 3.3 Modular and Structured Programming.- 3.4 Comments and Program Layout.- 3.5 Documentation.- 3.6 Teamwork.- 3.7 Efficiency.- 3.8 Tools for Software Development with Unix.- 3.9 PUMA.- 4 Expressions, Statements, Functions.- 4.1 Instructions and Expressions.- 4.2 Logical Values and Conditionals.- 4.3 Function Definition.- 4.4 Loops.- 4.5 Declarations and Scope.- 4.6 Switches.- 4.7 Linkage.- 4.8 Programming with Modules.- 4.9 Control Structures.- 5 Classification and Pattern Analysis.- 5.1 Classification.- 5.2 Preprocessing.- 5.3 Feature Extraction.- 5.4 Analysis.- 5.5 Image Segmentation.- 5.6 Speech Segmentation.- 5.7 Pattern Understanding.- 5.8 Active Vision and Real Time Processing.- 5.9 Top-Level Loop for Speech Analysis.- 6 Arrays and Pointers.- 6.1 Vectors and Matrices.- 6.2 Pointers.- 6.3 Vectors vs. Pointers.- 6.4 Vector Initialization.- 6.5 Strings.- 6.6 Pointers Operations and Allocation.- 6.7 Pointer and Array Arguments.- 6.8 Pointer to Pointer.- 6.9 Main Function Arguments.- 7 Statistics for Pattern Recognition.- 7.1 Axioms.- 7.2 Discrete Random Variables.- 7.3 Continuous Random Variables.- 7.4 Mean and Variance.- 7.5 Moments of a Distribution.- 7.6 Random Vectors.- 7.7 Statistical Features and Entropy.- 7.8 Signal-to-Noise Ratio.- 7.9 Histograms.- 8 C++ as a better C.- 8.1 Type Declaration.- 8.2 Type Conversion for Pointers.- 8.3 Bit- and Shift-Operations.- 8.4 Type Specifiers and Variable Declaration.- 8.5 Type-Safe Linkage.- 8.6 Overloaded Function Names.- 8.7 Return Value and Arguments.- 8.8 Macros and Inline Functions.- 8.9 Function Pointers.- II Object-Oriented Pattern Analysis.- 9 Object-Oriented Programming.- 9.1 Object-Oriented Software Techniques.- 9.2 Basic Concepts.- 9.3 Data Abstraction and Modules.- 9.4 Inheritance.- 9.5 Abstract Classes.- 9.6 Object-Oriented Classification.- 9.7 Polymorphism.- 9.8 Other Object-Oriented Concepts.- 9.9 Class Libraries.- 10 Classes in C++.- 10.1 Structures.- 10.2 Methods and ADT’s.- 10.3 Class Declarations.- 10.4 Object Construction.- 10.5 Destruction of Objects.- 10.6 Overloaded Operators.- 10.7 Advanced Methods and Constructors.- 10.8 Vector Class.- 10.9 Class Design.- 11 Intensity Images.- 11.1 Array Class.- 11.2 Templates in C++.- 11.3 Images.- 11.4 External Data Formats.- 11.5 Binary Images.- 11.6 Color Images.- 11.7 Sub Images.- 11.8 Image Transformation and Registration.- 11.9 Neighborhood.- 12 Inheritance in C++-Classes.- 12.1 Motivation and Syntax.- 12.2 Base Class Access.- 12.3 Construction and Destruction.- 12.4 Pointer to Objects.- 12.5 Virtual Functions.- 12.6 Abstract Classes.- 12.7 Image Class Hierarchy.- 12.8 Multiple Inheritance.- 12.9 Implementation Issues.- 13 Edge Detection and Edge Images.- 13.1 Motivation.- 13.2 Strategies.- 13.3 Discrete Derivative of the Intensity.- 13.4 Sobel and Prewitt Operator.- 13.5 Bit Fields in C++.- 13.6 Unions in C++.- 13.7 Edge Class.- 13.8 Edge Images.- 13.9 Color Edge Operators.- 14 Class Libraries.- 14.1 Stream Input and Output.- 14.2 NIH Class Library.- 14.3 Dynamic Class Descriptions.- 14.4 Static Class Members.- 14.5 Input and Output for Objects.- 14.6 Strings.- 14.7 Container Classes.- 14.8 Time and Date.- 14.9 More Classes.- 15 Hierarchy of Picture Processing Objects.- 15.1 General Structure.- 15.2 Hippos Object.- 15.3 Images and Matrices.- 15.4 Chain Code Class.- 15.5 Enumerations and Scope Resolution.- 15.6 Polygonal Representation.- 15.7 Atomic Objects.- 15.8 Segmentation Objects.- 15.9 External Representation.- 16 Spectral Features and Speech Processing.- 16.1 Fourier Series and Fourier Transform.- 16.2 Discrete Fourier Transform.- 16.3 Fast Fourier Transform.- 16.4 2D Fourier Transform.- 16.5 Short time Fourier analysis.- 16.6 Linear Predictive Coding.- 16.7 Dynamic Time Warping.- 16.8 Hidden Markov Models.- 16.9 Different Types of Hidden Markov Modells.- III Pattern Recognition Algorithms.- 17 An Image Analysis System.- 17.1 Data Flow.- 17.2 Design of ANIMALS.- 17.3 XDR.- 17.4 Display and Capture.- 17.5 Graphical User Interfaces.- 17.6 Geometric Distortions.- 17.7 Polymorphic image processing.- 17.8 Efficiency.- 17.9 Image Segmentation Program.- 18 Synthetic Signals and Images.- 18.1 Synthetic Sound.- 18.2 Geometric Patterns.- 18.3 Pixel Noise.- 18.4 Gaussian Noise.- 18.5 Salt-and-Pepper Noise.- 18.6 Different Views of a 3D Polyhedral Object.- 18.7 Digits and Letters.- 18.8 Single Stereo Images.- 18.9 Spectrogram.- 19 Filtering and Smoothing Signals.- 19.1 Mean-Filter and Gaussian-Filter.- 19.2 Median-Filter.- 19.3 Smoothed Median-Filter.- 19.4 Edge Preserving Smoothing.- 19.5 K-Nearest Neighbor Averaging.- 19.6 Conditional Average Filter.- 19.7 Linear Reconstruction.- 19.8 Elimination of Noisy Image Rows.- 19.9 Resolution Hierarchies.- 20 Histogram Algorithms.- 20.1 Discriminant and Least Squares Threshold.- 20.2 Histogram Entropy Thresholding.- 20.3 Multithresholding.- 20.4 Local Histogram Equalization.- 20.5 Lookup Table Transformation.- 20.6 A Class for Histograms.- 21 Edge Images.- 21.1 Robert’s Cross.- 21.2 Second Derivative.- 21.3 Edge Model Masks.- 21.4 Alternative Methods.- 21.5 Thinning of Edge Images.- 21.6 Edge Thresholding.- 21.7 Non Maxima Suppression.- 21.8 Non Maxima Absorption.- 21.9 Class Edge Revisited.- 22 Line Detection Algorithms.- 22.1 Line Detection.- 22.2 Local Connectivity.- 22.3 Hysteresis Thresholds.- 22.4 Closing of Gaps.- 22.5 Zero crossings in Laplace-Images.- 22.6 Hough Transform.- 22.7 Canny Line Detection.- 22.8 Shen and Castan.- 22.9 Representation as Segmentation Objects.- 23 Chain Codes.- 23.1 Length of a Chain.- 23.2 Smoothing.- 23.3 Digital Linear Lines.- 23.4 Similarity.- 23.5 Intersections.- 23.6 Rotation.- 23.7 Conversion.- IV Appendix.- A Basics of C++.- A.1 History.- A.2 Identifier and Constants.- A.3 Basis Data Types in C and C++.- B Software Development Tools.- B.1 Groups and ID’s with Unix.- B.2 Program Building with make.- B.3 The Use of Libraries.- B.4 Version and Access Control with rcs.- C Source Codes and Tools.- C.1 List of Tools.- C.2 How to get the sources.- C.3 X11.- C.4 Slides.- C.5 Addresses.- C.6 Headers and Source Files.- C.7 Dummy Definitions.- C.7.1 Listing of animals/dummy/Dictionary.h.- C.7.2 Listing of animals/dummy/OIOxdr.h.- C.7.3 Listing of animals/ dummy/Represent.h.- C.7.4 Listing of animals/dummy/SeqCltn.h.- C.7.5 Listing of animals/dummy/Set.h.- C.7.6 Listing of animals/dummy/dummies. C.- References.- Figures.- Tables.- Index for Exercises.

Read more less

Book SynopsisDie Entwicklungsumgebung.- Komponenten für die Benutzeroberfläche.- Elementare Datentypen und Anweisungen.- Einige Klassen der Standardbibliothek.- Funktionen.- Objektorientierte Programmierung.- Exception-Handling.- Die Bibliothek der visuellen Komponenten (VCL).- Templates und die STL.- Verschiedenes.

Read more less

Book SynopsisThis book provides precise descriptions and instructions which enable users, students and consultants to understand Microsoft Dynamics AX rapidly. Microsoft offers Dynamics AX as its premium ERP solution, supporting large and mid-sized organizations with a complete business management solution which is easy to use. Going through a simple but comprehensive case study, this book provides the required knowledge to handle all basic business processes in Dynamics AX. Exercises are there to train the processes and functionality, also making this book a good choice for self-study.Table of ContentsBasics and Technology – Navigation and User Interface – Supply Chain Management – Trade and Logistics – Advanced Warehouse Management – Manufacturing – Financial Management.

Read more less