Programming and scripting languages: general Books

Book Synopsis

Read more less

Book SynopsisThis practically-focused textbook presents a concise tutorial on data structures and algorithms using the object-functional language Scala. The material builds upon the foundation established in the title Programming with Scala: Language Exploration by the same author, which can be treated as a companion text for those less familiar with Scala.Topics and features: discusses data structures and algorithms in the form of design patterns; covers key topics on arrays, lists, stacks, queues, hash tables, binary trees, sorting, searching, and graphs; describes examples of complete and running applications for each topic; presents a functional approach to implementations for data structures and algorithms (excepting arrays); provides numerous challenge exercises (with solutions), encouraging the reader to take existing solutions and improve upon them; offers insights from the author’s extensive industrial experience; includes a glossary, and an appendix supplying an overview of discrete mathematics.Highlighting the techniques and skills necessary to quickly derive solutions to applied problems, this accessible text will prove invaluable to time-pressured students and professional software engineers.Table of ContentsFoundational Components Fundamental Algorithms Arrays Lists Stacks Queues Hash Tables Binary Trees Sorting Searching Graphs Appendix A: Solutions for Selected Exercises Appendix B: Review of Discrete Mathematical Topics

Read more less

Book SynopsisThis textbook explains Deep Learning Architecture, with applications to various NLP Tasks, including Document Classification, Machine Translation, Language Modeling, and Speech Recognition. With the widespread adoption of deep learning, natural language processing (NLP),and speech applications in many areas (including Finance, Healthcare, and Government) there is a growing need for one comprehensive resource that maps deep learning techniques to NLP and speech and provides insights into using the tools and libraries for real-world applications. Deep Learning for NLP and Speech Recognition explains recent deep learning methods applicable to NLP and speech, provides state-of-the-art approaches, and offers real-world case studies with code to provide hands-on experience. Many books focus on deep learning theory or deep learning for NLP-specific tasks while others are cookbooks for tools and libraries, but the constant flux of new algorithms, tools, frameworks, and libraries in a rapidly evolving landscape means that there are few available texts that offer the material in this book. The book is organized into three parts, aligning to different groups of readers and their expertise. The three parts are: Machine Learning, NLP, and Speech Introduction The first part has three chapters that introduce readers to the fields of NLP, speech recognition, deep learning and machine learning with basic theory and hands-on case studies using Python-based tools and libraries. Deep Learning Basics The five chapters in the second part introduce deep learning and various topics that are crucial for speech and text processing, including word embeddings, convolutional neural networks, recurrent neural networks and speech recognition basics. Theory, practical tips, state-of-the-art methods, experimentations and analysis in using the methods discussed in theory on real-world tasks. Advanced Deep Learning Techniques for Text and Speech The third part has five chapters that discuss the latest and cutting-edge research in the areas of deep learning that intersect with NLP and speech. Topics including attention mechanisms, memory augmented networks, transfer learning, multi-task learning, domain adaptation, reinforcement learning, and end-to-end deep learning for speech recognition are covered using case studies. Table of ContentsNotation xv.- Part 1: Machine Learning, NLP, and Speech Introduction.- Chapter 1 Introduction 1.- Chapter 2 Basics of Machine Learning 2.- Chapter 3 Text and Speech Basics 49.- Part 2: Deep Learning Basics.- Chapter 4 Basics of Deep Learning 105.- Chapter 5 Distributed Representations 213.- Chapter 6 Convolutional Neural Networks 275.- Chapter 7 Recurrent Neural Networks 329.- Chapter 8 Automatic Speech Recognition 387.- Part 3: Advance Deep Learning Techniques for Text and Speech.- Chapter 9 Attention and Memory Augmented Networks 429.- Chapter 10 Transfer learning: Scenarios, Self-Taught Learning, and Multitask Learning 485.- Chapter 11 Transfer Learning: Domain Adaptation 515.- Chapter 12 End-to-end Speech Recognition 559.- Chapter 13 Deep Reinforcement Learning for Text and Speech 601.- Future Outlook 647.

Read more less

Book SynopsisJava is now well-established as one of the world’s major programming languages, used in everything from desktop applications to web-hosted applications, enterprise systems and mobile devices. Java applications cover cloud-based services, the Internet of Things, self-driving cars, animation, game development, big data analysis and many more domains.The second edition of Foundational Java: Key Elements and Practical Programming presents a detailed guide to the core features of Java – and some more recent innovations – enabling the reader to build their skills and confidence though tried-and-trusted stages, supported by exercises that reinforce the key learning points. All the most useful and commonly applied Java syntax and libraries are introduced, along with many example programs that can provide the basis for more substantial applications. Use of the Eclipse Integrated Development Environment (IDE) and the JUnit testing framework is integral to the book, ensuring maximum productivity and code quality when learning Java, although to ensure that skills are not confined to one environment the fundamentals of the Java compiler and run time are also explained. Additionally, coverage of the Ant tool will equip the reader with the skills to automatically build, test and deploy applications independent of an IDE.Topics and features:• Presents the most up-to-date information on Java, including Java 14• Examines the key theme of unit testing, introducing the JUnit 5 testing framework to emphasize the importance of unit testing in modern software development• Describes the Eclipse IDE, the most popular open source Java IDE and explains how Java can be run from the command line• Includes coverage of the Ant build tool• Contains numerous code examples and exercises throughout• Provides downloadable source code, self-test questions, PowerPoint slides and other supplementary material at the website http://www.foundjava.comThis hands-on, classroom-tested textbook/reference is ideal for undergraduate students on introductory and intermediate courses on programming with Java. Professional software developers will also find this an excellent self-study guide/refresher on the topic.Dr. David Parsons is National Postgraduate Director at The Mind Lab, Auckland, New Zealand. He has been teaching programming in both academia and industry since the 1980s and writing about it since the 1990s.Table of ContentsThe Java StoryCompiling and Running Java ProgramsData Types, Arithmetic and ArraysControl StructuresCreating ObjectsCreating Domain ClassesObjects Working Together: Association, Aggregation and CompositionInheritance, Polymorphism and InterfacesException HandlingUnit Testing With JUnitExploring the Java LibrariesThe Collections Framework and GenericsInput and Output StreamsAutomatic Building and Testing with AntJava and the Database (JDBC)MultithreadingBuilding GUIs with the JFC Swing LibraryEvent Driven ProgrammingDialogs and Menus, Models and ViewsJava Web Start and Applets

Read more less

Book SynopsisThis book teaches algebra and geometry. The authors dedicate chapters to the key issues of matrices, linear equations, matrix algorithms, vector spaces, lines, planes, second-order curves, and elliptic curves. The text is supported throughout with problems, and the authors have included source code in Python in the book. The book is suitable for advanced undergraduate and graduate students in computer science. Trade Review“It is most interesting to combine a classical mathematical topic with a new evolving programming language and exactly this is obtained by this book. … This material is used as a case study for their implementation for solving problems in theoretical and practical cryptography. The ‘roadmap’ of the content of this also quite interesting.” (Panayiotis Vlamos, zbMATH 1480.00002, 2022)Table of ContentsMatrices and Matrix Algorithms.- Matrix Algebra.- Systems of Linear Equations.- Complex Numbers and Matrices.- Vector Spaces.- Vectors in a Three-Dimensional Space.- Equation of a Straight Line on a Plane.- Equation of a Plane in Space.- Equation of a Line in Space.- Bilinear and Quadratic Forms.- Curves of the Second-Order.- Elliptic Curves.- Appendix A, Basic Operators in Python and C.- Appendix B, Trigonometric Formulae.- Appendix C, The Greek Alphabet.- References.- Name Index.- Subject Index.

Read more less

Book SynopsisThis book provides a full presentation of the current concepts and available techniques to make “machine learning” systems more explainable. The approaches presented can be applied to almost all the current “machine learning” models: linear and logistic regression, deep learning neural networks, natural language processing and image recognition, among the others.Progress in Machine Learning is increasing the use of artificial agents to perform critical tasks previously handled by humans (healthcare, legal and finance, among others). While the principles that guide the design of these agents are understood, most of the current deep-learning models are "opaque" to human understanding. Explainable AI with Python fills the current gap in literature on this emerging topic by taking both a theoretical and a practical perspective, making the reader quickly capable of working with tools and code for Explainable AI.Beginning with examples of what Explainable AI (XAI) is and why it is needed in the field, the book details different approaches to XAI depending on specific context and need. Hands-on work on interpretable models with specific examples leveraging Python are then presented, showing how intrinsic interpretable models can be interpreted and how to produce “human understandable” explanations. Model-agnostic methods for XAI are shown to produce explanations without relying on ML models internals that are “opaque.” Using examples from Computer Vision, the authors then look at explainable models for Deep Learning and prospective methods for the future. Taking a practical perspective, the authors demonstrate how to effectively use ML and XAI in science. The final chapter explains Adversarial Machine Learning and how to do XAI with adversarial examples.Table of ContentsContents1. The Landscape1.1 Examples of what Explainable AI is1.1.1 Learning Phase1.1.2 Knowledge Discovery1.1.3 Reliability and Robustness1.1.4 What have we learnt from the 3 examples1.2 Machine Learning and XAI1.2.1 Machine Learning tassonomy1.2.2 Common Myths1.3 The need for Explainable AI1.4 Explainability and Interpretability: different words to say the same thing or not?1.4.1 From World to Humans1.4.2 Correlation is not causation1.4.3 So what is the difference between interpretability and explainability?1.5 Making Machine Learning systems explainable1.5.1 The XAI flow1.5.2 The big picture1.6 Do we really need to make Machine Learning Models explainable?1.7 Summary1.8 References2. Explainable AI: needs, opportunities and challenges2.1 Human in the loop2.1.1 Centaur XAI systems2.1.2 XAI evaluation from “Human in The Loop perspective”2.2 How to make Machine Learning models explainable2.2.1 Intrinsic Explanations2.2.2 Post-Hoc Explanations2.2.3 Global or Local Explainability2.3 Properties of Explanations2.4 Summary2.5 References3 Intrinsic Explainable Models3.1.Loss Function3.2.Linear Regression3.3.Logistic Regression3.4.Decision Trees3.5.K-Nearest Neighbors (KNN)3.6.Summary3.7 References4. Model-agnostic methods for XAI4.1 Global Explanations: permutation Importance and Partial Dependence Plot4.1.1 Ranking features by Permutation Importance4.1.2 Permutation Importance on the train set4.1.3 Partial Dependence Plot4.1.4 Properties of Explanations4.2 Local Explanations: XAI with Shapley Additive explanations4.2.1 Shapley Values: a game-theoretical approach4.2.2 The first use of SHAP4.2.3 Properties of Explanations4.3 The road to KernelSHAP4.3.1 The Shapley formula4.3.2 How to calculate Shapley values4.3.3 Local Linear Surrogate Models (LIME)4.3.4 KernelSHAP is a unique form of LIME4.4 Kernel SHAP and interactions4.4.1 The NewYork Cab scenario4.4.2 Train the Model with preliminary analysis4.4.3 Making the model explainable with KernelShap4.4.4 Interactions of features4.5 A faster SHAP for boosted trees4.5.1 Using TreeShap4.5.2 Providing explanations4.6 A naïve criticism to SHAP4.7 Summary4.8 References5. Explaining Deep Learning Models5.1 Agnostic Approach5.1.1 Adversarial Features5.1.2 Augmentations5.1.3 Occlusions as augmentations5.1.4 Occlusions as an Agnostic XAI Method5.2 Neural Networks5.2.1 The neural network structure5.2.2 Why the neural network is Deep? (vs shallow)5.2.3 Rectified activations (and Batch Normalization)5.2.4 Saliency Maps5.3 Opening Deep Networks5.3.1 Different layer explanation5.3.2 CAM (Class Activation Maps) and Grad-CAM5.3.3 DeepShap / DeepLift5.4 A critic of Saliency Methods5.4.1 What the network sees5.4.2 Explainability batch normalizing layer by layer5.5 Unsupervised Methods5.5.1 Unsupervised Dimensional Reduction5.5.2 Dimensional reduction of convolutional filters5.5.3 Activation Atlases: How to tell a wok from a pan5.6 Summary5.7 References6. Making science with Machine Learning and XAI6.1 Scientific method in the age of data6.2 Ladder of Causation6.3 Discovering physics concepts with ML and XAI6.3.1 The magic of autoencoders6.3.2 Discover the physics of damped pendulum with ML and XAI6.3.3 Climbing the ladder of causation6.4 Science in the age of ML and XAI6.5 Summary6.6 References7. Adversarial Machine Learning and Explainability7.1 Adversarial Examples (AE) crash course7.1.2 Hands-on Adversarial Examples7.2 Doing XAI with Adversarial Examples7.3 Defending against Adversarial Attacks with XAI7.4 Summary7.5 References8. A proposal for a sustainable model of Explainable AI8.1 The XAI "fil rouge"8.2 XAI and GDPR8.2.1 FAST XAI8.3 Conclusions8.4 Summary8.5 ReferencesIndex

Read more less

Book SynopsisThis book provides a solid foundation in the Python programming language, numerical methods, and data analysis, all embedded within the context of astronomy and astrophysics. It not only enables students to learn programming with the aid of examples from these fields but also provides ample motivation for engagement in independent research. The book opens by outlining the importance of computational methods and programming algorithms in contemporary astronomical and astrophysical research, showing why programming in Python is a good choice for beginners. The performance of basic calculations with Python is then explained with reference to, for example, Kepler’s laws of planetary motion and gravitational and tidal forces. Here, essential background knowledge is provided as necessary. Subsequent chapters are designed to teach the reader to define and use important functions in Python and to utilize numerical methods to solve differential equations and landmark dynamical problems in astrophysics. Finally, the analysis of astronomical data is discussed, with various hands-on examples as well as guidance on astronomical image analysis and applications of artificial neural networks.Table of ContentsChapter 1. Introduction.- Chapter 2. Getting Started with Python.- Chapter 3. Computing and Displaying Data.- Chapter 4. Functions and Numerical Methods.- Chapter 5. Solving Differential Equations.- Chapter 6. Astronomical Data Analysis.

Read more less

Book SynopsisThe main goal of this book is to teach fundamental programming principles to beginners using Julia, one of the fastest growing programming languages today. Julia can be classified as a "modern" language, possessing many features not available in more popular languages like C and Java. The book is organized in 10 chapters. Chapter 1 gives an overview of the programming process. It shows how to write a first Julia program and introduces some of the basic building blocks needed to write programs. Chapter 2 is all about numbers—integers, floating-point, operators, expressions—how to work with them and how to print them. Chapter 3 shows how to write programs which can make decisions. It explains how to use if and if…else statements. Chapter 4 explains the notion of ‘looping’, implemented using for and while statements. It also explains how to read data from a file and write results to a file. Chapter 5 formally treats with functions, enabling a (large) program to be broken up into smaller manageable units which work together to solve a given problem. Chapter 6 is devoted to characters and strings. In Julia, we can work with them as seamlessly as we do with numbers. Chapter 7 tackles array processing, which is significantly easier in Julia than other languages. Chapter 8 is about sorting and searching techniques. Sorting puts data in an order that can be searched more quickly/easily, and makes it more palatable for human consumption. Chapter 9 introduces structures, enabling us to group data in a form that can be manipulated more easily as a unit. Chapter 10 deals with two useful data structures—dictionaries and sets. These enable us to solve certain kinds of problems more easily and conveniently than we can without them. This book is intended for anyone who is learning programming for the first time. The presentation is based on the fact that many students (though not all) have difficulties in learning programming. To overcome this, the book uses an approach which provides clear examples, detailed explanations of very basic concepts and numerous interesting problems (not just artificial exercises whose only purpose is to illustrate some language feature).Table of Contents1. Elementary Concepts.- 2. Numbers.- 3. Selection Logic.- 4. The for and while Statements.- 5. Functions.- 6. Characters & Strings.- 7. Arrays.- 8. Searching, Sorting and Merging.- 9. Structures.- 10. Dictionaries & Sets.

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 assumes very little knowledge of programming so whether you have dabbled with a little JavaScript, played with a bit of Python, written Java or have virtually no programming experience at all you will find that it is for you.The first part of the book introduces Kotlin program structures as well as conditional flow of control features such as if and when expressions as well as iteration loops such as for, while and do-while. Subsequent chapters explain how functions are implemented in Kotlin and introduce concepts from functional programming such as higher order functions and curried functions.The second part focusses on object oriented programming techniques, these include classes, inheritance, abstraction and interfaces. The third part presents container data types such as Arrays, and collections including Lists, Sets and Maps and the fourth part considers concurrency and parallelism using Kotlin coroutines. The book concludes with an introduction to Android mobile application development using Kotlin.Clear steps are provided explaining how to set up your environment and get started writing your own Kotlin programs.An important aspect of the book is teaching by example and there are many examples presented throughout the chapters. These examples are supported by a public GitHub repository that provides complete working code as well as sample solutions to the chapter exercises. This helps illustrate how to write well structured, clear, idiomatic Kotlin to build real applications.Table of ContentsIntroduction.- Part 1: Kotlin Programming.- A First Kotlin Program.- Flow of Control.- Number Guessing Game.- Functions in Kotlin.- Higher Order Functions.- Curried Functions.- Part 2: Object Oriented Kotlin.- Kotlin Classes.- Objects and Companion Objects,- Further Kotlin Properties.- Scope and Conditional Functions.- Class Inheritance.- Abstract Classes.- Interfaces, Delegation and Enumerated Types.- Packages.- Nested and Inner Types.- Data Classes.- Sealed and Inline Classes and Typealias.- Operator Overloading.- Error and Exception Handling.- Extension Functions and Properties.- Part 3: Data Containers.- Arrays.- Collections.- Lists.- Sets.- Maps.- Pairs and Triples.- Generic Types.- Functional Programming and Containers.- Part 4: Concurrent Kotlin.- Coroutines.- Coroutine Channel Communications.- Part 5: Android Development.- Android Overview.- Applications and Activities.- Android Layouts and Events.- Android Tic Tac Toe.

Read more less

Book SynopsisThis book compiles and presents a complete package of open-access Python software code for luminescence signal analysis in the areas of radiation dosimetry, luminescence dosimetry, and luminescence dating. Featuring more than 90 detailed worked examples of Python code, fully integrated into the text, 16 chapters summarize the theory and equations behind the subject matter, while presenting the practical Python codes used to analyze experimental data and extract the various parameters that mathematically describe the luminescence signals. Several examples are provided of how researchers can use and modify the available codes for different practical situations. Types of luminescence signals analyzed in the book are thermoluminescence (TL), isothermal luminescence (ITL), optically stimulated luminescence (OSL), infrared stimulated luminescence (IRSL), timeresolved luminescence (TR) and dose response of dosimetric materials. The open-access Python codes are available at GitHub.The book is well suited to the broader scientific audience using the tools of luminescence dosimetry: physicists, geologists, archaeologists, solid-state physicists, medical physicists, and all scientists using luminescence dosimetry in their research. The detailed code provided allows both students and researchers to be trained quickly and efficiently on the practical aspects of their work, while also providing an overview of the theory behind the analytical equations.Table of ContentsTL Signals from Delocalized Transitions: Models.- Analysis of TL Signals from Delocalized Transitions.- TL from Quantum Tunneling Processes: Models.- Analysis of TL from Quantum Tunneling Processes.- Isothermal Luminescene (ITL) Signals: Models and Analysis.- TL Signals from Localized Transitions: Models and Analysis.- OSL from Delocalized Transitions: Models.- Analysis of OSL from Delocalized Transitions.- Infrared Stimulated Luminescene Signals: Models.- Analysis of IRSL Signals.- Time-Resolved Luminescene: Models.- Analysis of Time-Resolved Luminescene Signals L.- Dose Response of Dosimetric Materials: Models.- Analysis of Dose Response of Luminescene Signals.- Radiofluorescene Signals: Models and Analysis.- Radiophotoluminescene Signals: Models and Analysis

Read more less

Book SynopsisThis book is about the harmonious synthesis of functional programming and numerical computation. It shows how the expressiveness of OCaml allows for fast and safe development of data science applications. Step by step, the authors build up to use cases drawn from many areas of Data Science, Machine Learning, and AI, and then delve into how to deploy at scale, using parallel, distributed, and accelerated frameworks to gain all the advantages of cloud computing environments.To this end, the book is divided into three parts, each focusing on a different area. Part I begins by introducing how basic numerical techniques are performed in OCaml, including classical mathematical topics (interpolation and quadrature), statistics, and linear algebra. It moves on from using only scalar values to multi-dimensional arrays, introducing the tensor and Ndarray, core data types in any numerical computing system. It concludes with two more classical numerical computing topics, the solution of Ordinary Differential Equations (ODEs) and Signal Processing, as well as introducing the visualization module we use throughout this book. Part II is dedicated to advanced optimization techniques that are core to most current popular data science fields. We do not focus only on applications but also on the basic building blocks, starting with Algorithmic Differentiation, the most crucial building block that in turn enables Deep Neural Networks. We follow this with chapters on Optimization and Regression, also used in building Deep Neural Networks. We then introduce Deep Neural Networks as well as topic modelling in Natural Language Processing (NLP), two advanced and currently very active fields in both industry and academia. Part III collects a range of case studies demonstrating how you can build a complete numerical application quickly from scratch using Owl. The cases presented include computer vision and recommender systems. This book aims at anyone with a basic knowledge of functional programming and a desire to explore the world of scientific computing, whether to generally explore the field in the round, to build applications for particular topics, or to deep-dive into how numerical systems are constructed. It does not assume strict ordering in reading – readers can simply jump to the topic that interests them most. Table of ContentsPart I: Numerical Techniques.- 1. Introduction.- 2. Numerical Algorithms.- 3. Statistics.- 4. Linear Algebra.- 5. N-Dimensional Arrays.- 6. Ordinary Differential Equations.- 7. Signal Processing.- Part II: Advanced Data Analysis Techniques.- 8. Algorithmic Differentiation.- 9. Optimisation.- 10. Regression.- 11. Neural Network.- 12. Vector Space Modelling.- Part III: Use Cases.- 13. Case Study: Image Recognition.- 14. Case Study: Instance Segmentation.- 15. Case Study: Neural Style Transfer.- 16. Case Study: Recommender System.

Read more less

Book SynopsisThis textbook provides an in-depth introduction to software design, with a focus on object-oriented design, and using the Java programming language. Its goal is to help readers learn software design by discovering the experience of the design process. To this end, the text follows a continuous narrative that introduces each element of design know-how in context, and explores alternative solutions in that context. This narrative is complemented by hundreds of code fragments and design diagrams. The first chapter is a general introduction to software design and the subsequent chapters cover design concepts and techniques. The concepts and techniques covered include interfaces, encapsulation, inheritance, design patterns, composition, functional-style design, unit testing, and many more. A major emphasis is placed on coding and experimentation as a necessary complement to reading the text. To support this aspect of the learning process, a companion website with practice exercises is provided, as well as two complete sample applications. Guidance on these sample applications is provided in “Code Exploration” insets throughout the book. Although the Java language is used as a means of conveying design-related ideas, the book’s main goal is to address concepts and techniques that are applicable in a host of technologies. This second edition covers additional design techniques such as input validation and dependency injection. It also provides extended and revised treatment of many core subjects, including polymorphic copying, unit testing, the Observer pattern, and functional-style programming. This book is intended for readers who have a minimum of programming experience and want to move from writing small programs and scripts to tackling the development of larger systems. This audience naturally includes students in university-level computer science and software engineering programs. As the prerequisites to specific computing concepts are kept to a minimum, the content is also accessible to programmers with no previous background in computing. In a similar vein, understanding the code fragments requires only a minimal grasp of the Java language, such as would be taught in an introductory programming course.Table of Contents1. Introduction.- 2. Encapsulation.- 3. Types and Interfaces.- 4. Object State.- 5. Unit Testing.- 6. Composition.- 7. Inheritance.- 8. Inversion of Control.- 9. Functional Design.

Read more less

Book SynopsisThis open access book constitutes the proceedings of the 31st European Symposium on Programming, ESOP 2022, which was held during April 5-7, 2022, in Munich, Germany, as part of the European Joint Conferences on Theory and Practice of Software, ETAPS 2022. The 21 regular papers presented in this volume were carefully reviewed and selected from 64 submissions. They deal with fundamental issues in the specification, design, analysis, and implementation of programming languages and systems. Table of ContentsCategorical Foundation of Gradient-Based Learning.- Compiling Universal Probabilistic Programming Languages with Efficient Parallel Sequential Monte Carlo Inference.- Foundations for Entailment Checking in Quantitative Separation Logic.- Extracting total Amb programs from proofs.- Why3-do: The Way of Harmonious Distributed System Proofs.- Relaxed virtual memory in Armv8-A.- Verified Security for the Morello Capability-enhanced Prototype Arm Architecture.- The Trusted Computing Base of the CompCert Verified Compiler.- View-Based Owicki-Gries Reasoning for Persistent x86-TSO.- Abstraction for Crash-Resilient Objects.- Static Race Detection for Periodic Programs.- Probabilistic Total Store Ordering.- Linearity and Uniqueness: An Entente Cordiale.- A Framework for Substructural Type Systems.- A Dependent Dependency Calculus.- Polarized Subtyping.- Structured Handling of Scoped Effects.- Region-based Resource Management and Lexical Exception Handlers in Continuation-Passing Style.- A Predicate Transformer for Choreographies.- Comparing the expressiveness of the -calculus and CCS.- Concurrent NetKAT.

Read more less

Book SynopsisEdited in collaboration with FoLLI, the Association of Logic, Language and Information this book constitutes the refereed proceedings of the 28th Workshop on Logic, Language, Information and Computation, WoLLIC 2022, Iasi, Romania, in September 2022. The 25 full papers presented included with 8 extra abstracts, 5 invited talks and 3 tutorials were fully reviewed and selected from 46 submissions. The conference aims fostering interdisciplinary research in pure and applied logic.Table of ContentsProof theory,.- Model theory.- Modal and temporal logics.- Automated reasoning.-Constraint and logic programming.- Constructive mathematics.- Equational logic and rewriting.- Finite Model Theory.- Descriptive complexity,.- Higher order logic.- Programming logic.- Model checking.- Type theory.- Lambda calculus.- Semantics of programming languages.- Computational linguistics.-Language and computation.- Logic and language.

Read more less

Book SynopsisA basic understanding of the key techniques in computer graphics can open the door to this exciting field and its many applications, including for video games and for augmented and virtual reality.This easy-to-follow textbook and reference introduces the fundamental concepts of computer graphics, integrating both technical background and theory with practical examples and applications throughout. Thoroughly revised and updated, this new edition continues to present a user-friendly approach to creating images and animations, complementing the expanded coverage of topics with usage of example programs and exercises.Topics and features: Contains pedagogical tools, including easy-to-understand example programs and end-of-chapter exercises Presents a practical guide to basic computer graphics programming using the Open Graphics Library (OpenGL) and the widely used Java programming language Includes new and expanded content on the OpenGL graphics pipelines, shader programming, drawing basic objects using the OpenGL, three-dimensional modelling, quaternions, rasterisation, antialiasing and more Supplies complete Java project examples as supplementary material This reader-friendly textbook is an essential tool for second-year undergraduate students and above, providing clear and concise explanations of the basic concepts of computer graphics. It will enable readers to immediately implement these concepts using the OpenGL and Java (with only elementary knowledge of the programming language).Prof. Dr.-Ing. Karsten Lehn works at the Faculty of Information Technology at Fachhochschule Dortmund, University of Applied Sciences and Arts. Prof. Dr. Merijam Gotzes is teaching at Hamm-Lippstadt University of Applied Sciences. Prof. Dr. Frank Klawonn is head of the Data Analysis and Pattern Recognition Laboratory at the Ostfalia University of Applied Sciences and heads the Biostatistics Research Group at the Helmholtz Centre for Infection Research.Table of Contents

Read more less

Book SynopsisThis book constitutes the refereed proceedings of the 26th European Conference on Genetic Programming, EuroGP 2023, held as part of EvoStar 2023, in Brno, Czech Republic, during April 12–14, 2023, and co-located with the EvoStar events, EvoCOP, EvoMUSART, and EvoApplications. The 14 revised full papers and 8 short papers presented in this book were carefully reviewed and selected from 38 submissions. The wide range of topics in this volume reflects the current state of research in the field. The collection of papers cover topics including developing new variants of GP algorithms for both optimization and machine learning problems as well as exploring GP to address complex real-world problems.

Read more less

Book SynopsisThis textbook is aimed at readers who have little or no knowledge of computer programming but want to learn to program in Python. It starts from the very basics including how to install your Python environment, how to write a very simple program and run it, what a variable is, what an if statement is, how iteration works using for and while loops as well as important key concepts such as functions, classes and modules. Each subject area is prefaced with an introductory chapter, before continuing with how these ideas work in Python. The second edition has been completely updated for the latest versions of Python including Python 3.11 and Python 3.12. New chapters have been added such as those that consider where and how Python is used, the use of Frozensets, how data can be sorted, enumerated types in Python, structural pattern matching and how (and why) Python Virtual Environments are configured. A new chapter ‘The Python Bites back’ is introduced to present the fourteen most common / biggest gotchas for someone new to Python. Other sections have been updated with new features such as Exception Groups, string operations and dictionary operations. A Beginners Guide to Python 3 Programming second Edition provides all you need to know about Python, with numerous examples provided throughout including several larger worked case studies illustrating the ideas presented in the previous chapters.Table of ContentsIntroduction.- Where is Python Used.- Setting up the Python Environment.- A First Python Program.- Python Strings.- Numbers, Booleans and None.- Flow of Control using if statements.- Number Guessing Game.- Recursion.- Introduction to Structured Analysis.- Functions in Python.- Implementing a Calculator using Functions.- Introduction to Functional Programming.- Curried Functions.- Introduction to Object Orientation.- Class Side and Static Behaviour.- Why Bother with Object Orientation?.- Operator Overloading.- Error and Exception Handling.- Python Modules and Packages.- Abstract Base Classes.- Error and Exception Handling.- Python Modules and Packages.- Protocols, Polymorphism and Descriptors.- Decorators.- Iterables and Iterators.- Generators and Coroutines.- Collections Tuples and Lists.- Sets.- Dictionaries.- Frozensets.- Collection Related Modules.- ADTs, Queues and Stacks.- Map, Filter and Reduce.- Sorting and Higher Order Functions.- Python Enumerated Values, Structural Pattern Making.- Python Virtual Environments.- Monkey Patching.- Attribute Lookup.- The Python Bites Back.- TicTacToe Game.

Read more less

Book SynopsisThis book provides a unique tour of university mathematics with the help of Python. Written in the spirit of mathematical exploration and investigation, the book enables students to utilise Python to enrich their understanding of mathematics through: Calculation: performing complex calculations and numerical simulations instantly Visualisation: demonstrating key theorems with graphs, interactive plots and animations Extension: using numerical findings as inspiration for making deeper, more general conjectures. This book is for all learners of mathematics, with the primary audience being mathematics undergraduates who are curious to see how Python can enhance their understanding of core university material. The topics chosen represent a mathematical overview of what students typically study in the first and second years at university, namely analysis, calculus, vector calculus and geometry, differential equations and dynamical systems, linear algebra, abstract algebra and number theory, probability and statistics. As such, it can also serve as a preview of university mathematics for high-school students. The prerequisites for reading the book are a familiarity with standard A-Level mathematics (or equivalent senior high-school curricula) and a willingness to learn programming. For mathematics lecturers and teachers, this book is a useful resource on how Python can be seamlessly incorporated into the mathematics syllabus, assuming only basic knowledge of programming.Table of Contents1 Analysis.- 2 Calculus.- 3 Vector Calculus and Geometry.- 4 Differential Equations and Dynamical Systems.- 5 Linear Algebra.- 6 Abstract Algebra and Number Theory.- 7 Probability.- 8 Statistics.- Appendix A: Python 101.

Read more less

Book SynopsisThis book introduces computing and programming with undergraduate engineering students in mind. It uses Python (Version 3) as the programming language, chosen for its simplicity, readability, wide applicability and large collection of libraries. After introducing engineering-related Python libraries, such as NumPy, Pandas, Matplotlib, Sci-kit, Programming with Python for Engineers shows how Python can be used to implement methods common in a wide spectrum of engineering-related problems drawn from (for example): design, control, decision-making, scheduling and planning. Important features of the book include the following: The book contains interactive content for illustration of important concepts, where the user can provide input and by clicking buttons, trace through the steps. Each chapter is also accessible as a Jupyter Notebook page and every code piece is executable. This allows the readers to run code examples in chapters immediately, to make changes and gain a better grasp of the concepts presented. The coverage of topics is complemented by illustrative examples and exercises. For instructors adopting the textbook, a solutions manual is provided athttps://sites.google.com/springernature.com/extramaterial/lecturer-material.

Read more less

Book Synopsis

Read more less

Book SynopsisThis volume, the third of a series, consists of applications of Mathematica® to a potpourri of more advanced topics. These include differential geometry of curves and surfaces, differential equations and special functions and complex analysis. Some of the newest features of Mathematica® are demonstrated and explained and some problems with the current implementation pointed out and possible future improvements suggested. Contains a large number of worked out examples. Explains some of the most recent mathematical features of Mathematica®. Considers topics discussed rarely or not at all in the context of Mathematica®. Can be used to supplement several different courses. Based on actual university courses.

Read more less

Book SynopsisIntroduces students to appropriate use of computer programming within the scientific disciplines using Python. Discusses several common applications of programming and implementation using real world examples and hands on programming exercises. Students learn how to model situations such as image recognition, medical diagnosis, spread of disease, and others. The text could be used by students and lecturers for courses in Python, Numerical Methods, or as a first course in Data Science.

Read more less

Book SynopsisThis book uses a functional programming language (F#) as a metalanguage to present all concepts and examples, and thus has an operational flavour, enabling practical experiments and exercises. It includes basic concepts such as abstract syntax, interpretation, stack machines, compilation, type checking, garbage collection, and real machine code. Also included are more advanced topics on polymorphic types, type inference using unification, co- and contravariant types, continuations, and backwards code generation with on-the-fly peephole optimization. This second edition includes two new chapters. One describes compilation and type checking of a full functional language, tying together the previous chapters. The other describes how to compile a C subset to real (x86) hardware, as a smooth extension of the previously presented compilers.The examples present several interpreters and compilers for toy languages, including compilers for a small but usable subset of C, abstract machines, a garbage collector, and ML-style polymorphic type inference. Each chapter has exercises. Programming Language Concepts covers practical construction of lexers and parsers, but not regular expressions, automata and grammars, which are well covered already. It discusses the design and technology of Java and C# to strengthen students’ understanding of these widely used languages.Table of ContentsIntroduction.- Interpreters and Compilers.- From Concrete Syntax to Abstract Syntax.- A First-Order Functional Language.- Higher-Order Functions.- Polymorphic Types.- Imperative Languages.- Compiling Micro-C.- Real-World Abstract Machines.- Garbage Collection.- Continuations.- A Locally Optimizing Compiler.- Compiling Micro-SML.- Real Machine Code.- A Crash Course in F#.

Read more less

Book SynopsisMaking extensive use of examples, this textbook on Java programming teaches the fundamental skills for getting started in a command-line environment. Meant to be used for a one-semester course to build solid foundations in Java, Fundamentals of Java Programming eschews second-semester content to concentrate on over 180 code examples and 250 exercises.Key object classes (String, Scanner, PrintStream, Arrays, and File) are included to get started in Java programming. The programs are explained with almost line-by-line descriptions, also with chapter-by-chapter coding exercises.Teaching resources include solutions to the exercises, as well as digital lecture slides.Table of Contents1) Programming Basics 1 a) Java and the Java Virtual Machine 3 1.1 Computers and Their Programs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.1.1 The computer programs in your machine . . . . . . . . . . . . . . . . . . . . 3 1.1.2 Java Virtual Machines - JVM . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.1.3 Code editing and code compiling . . . . . . . . . . . . . . . . . . . . . . . . . 6 b) Our First Programs 13 2.1 The First Program, “Hello, World!” . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 2.1.1 Method declaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.1.2 Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.1.3 System.out.println and System.out.print . . . . . . . . . . . . . . . . . . 17 2.1.4 Spacing in the source code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.2 Commenting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19 2.3 Errors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.4 Using Multiple Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 • println versus print revisited . . . . . . . . . . . . . . . . . . . . . . . . . . 23 • Printing multiple-line texts on the screen . . . . . . . . . . . . . . . . . . . . 25 2.4.3 Escaping characters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 2.4.4 Printing shapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29 c) Using Data for Computation 39 3.1 Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.1.1 Data and their taxonomy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 3.1.2 Literals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40 3.1.3 Variable declarations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42 3.1.4 Naming variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 3.1.5 Value assignments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 3.2 The primitive data types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45 3.2.1 Quarterbacks program again . . . . . . . . . . . . . . . . . . . . . . . . . . . 48 3.3 Using Variables for Computation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 3.3.1 Number arithmetics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 3.3.2 Formula evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 3.3.3 Our first calculation program . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 3.3.4 Mixing different number types . . . . . . . . . . . . . . . . . . . . . . . . . . 57 3.3.5 Computing the Body-Mass Index . . . . . . . . . . . . . . . . . . . . . . . . . 59 3.3.6 Sum of integers from 1 to 100 `a la Gauss . . . . . . . . . . . . . . . . . . . . 61 3.3.7 Simplified expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 3.4 An Introduction to String Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 3.4.1 String objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 3.4.2 String additions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 3.4.3 Escaping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 3.4.4 Connection with other types . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 4 Reading Keyboard Input 83 4.1 The Class Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 4.2 Reading input with a Scanner . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 5 Decomposing Code into Components 99 5.1 Code Decomposition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.1.1 Printing rectangles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.1.2 Quadrangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 5.1.3 Old MacDonald Had a Farm . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 5.1.4 The benefits of code decomposition . . . . . . . . . . . . . . . . . . . . . . . . 114 5.2 Using Multiple Program Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 6 Passing Values to and from Methods 123 6.1 Passing Values to Methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 6.1.1 Methods that work with parameters . . . . . . . . . . . . . . . . . . . . . . . 123 6.1.2 Method overloading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 6.2 Receiving a Value from a Method . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 6.3 Class Math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137 6.3.1 Mathematical functions in Java . . . . . . . . . . . . . . . . . . . . . . . . . . 137 6.3.2 Application using Math methods . . . . . . . . . . . . . . . . . . . . . . . . . 146 2) Loops and Conditional Execution 157 7 For-Loops 159 7.1 Repetitive Code Execution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 7.2 Iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 7.2.1 Simple iteration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 7.2.2 Iteration with an auxiliary variable . . . . . . . . . . . . . . . . . . . . . . . . 173 7.3 Double For-Loops . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 8 Using Conditions to Control the Flow 187 8.1 Condition and its evaluation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 8.2 The If Statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 8.2.1 If . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 8.2.2 Else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 8.2.3 Special conditional evaluation rules . . . . . . . . . . . . . . . . . . . . . . . . 209 8.3 Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 8.3.1 Computing max and min in a series of numbers . . . . . . . . . . . . . . . . . 211 8.3.2 A betting game . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214 9 Formatted Printing using printf 225 9.1 Formatted Printing of Strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225 9.2 Formatted Printing of Integers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228 9.3 Formatted Printing of Floating Point Numbers . . . . . . . . . . . . . . . . . . . . . 229 10 String Methods for Text Processing 237 10.1 String Methods for Information Extraction . . . . . . . . . . . . . . . . . . . . . . . 237 10.2 String Methods for Comparison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 10.3 String methods for Pattern Search . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 10.4 String methods for creating new String objects . . . . . . . . . . . . . . . . . . . . 246 10.5 Class StringBuilder . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 11 Branching Using Switch Statements 259 11.1 Switch Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 11.2 Switching on a Char or a String Value . . . . . . . . . . . . . . . . . . . . . . . . . . 266 12 While and Do-while Loops 277 12.1 The While Loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 12.1.1 What is a while-loop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 12.1.2 Collect numbers until the total reaches a target . . . . . . . . . . . . . . . . . 279 12.1.3 Integer overflow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 12.1.4 Vending machines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 12.1.5 The Collatz Conjecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285 12.1.6 From decimal to binary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289 12.2 Do-while statements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 12.2.1 Do-while versus while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 12.2.2 Waiting for Godot . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294 12.2.3 Converting to binary, again . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295 12.3 Terminating a Scanner of Keyboard . . . . . . . . . . . . . . . . . . . . . . . . . . . 296 12.4 Approximating the Square Root . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301 III Arrays 311 13 Arrays 313 13.1 Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 13.1.1 What is an array? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 13.1.2 Counting the number of occurrences . . . . . . . . . . . . . . . . . . . . . . . 314 13.2 Offset Indexing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322 13.2.1 Offset indexing to avoid wasteful use of array elements . . . . . . . . . . . . . 322 13.2.2 Offset indexing for BMI calculation . . . . . . . . . . . . . . . . . . . . . . . . 323 13.2.3 Character occurrence counting . . . . . . . . . . . . . . . . . . . . . . . . . . 325 13.2.4 Negative offset indexing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330 13.3 Primality Testing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332 13.4 Using Multiple Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 13.5 ArrayIndexOutOfBoundsException . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 14 Class Arrays, Resizing Arrays, and Arrays with Capacity 347 14.1 Class Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347 14.2 Coordinated Array Modifications with Sustained Length . . . . . . . . . . . . . . . . 351 14.2.1 Reversing element order . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354 14.2.2 Cyclic shifting . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356 14.3 Modifications That Require Resizing . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 14.3.1 Insertion and deletion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360 14.3.2 Merging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367 14.4 args - the Argument Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368 14.5 Searching in an Array . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 14.5.1 Sequential search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369 14.5.2 Sequential search in an array with elements in order . . . . . . . . . . . . . . 370 14.5.3 Binary search . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371 14.6 Arrays with Capacity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372 15 Multidimensional Arrays 385 15.1 Two-dimensional Rectangular Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 15.1.1 Multi-dimensional arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 385 15.1.2 Summation of over subsequences . . . . . . . . . . . . . . . . . . . . . . . . . 386 15.2 Matrix multiplication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 15.2.1 Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390 15.2.2 Two dimensional rotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391 15.3 Jagged Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395 IV Object Classes 401 16 Class File 403 16.1 An Introduction to Object Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 16.2 File Access . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403 16.3 File methods . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405 16.3.1 List of File methods we may use . . . . . . . . . . . . . . . . . . . . . . . . . 405 16.3.2 Error handling . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407 16.3.3 Listing of File objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 417 16.4 Scanner of a File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 16.5 Writing to Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427 17 Designing Object Classes 435 17.1 Using Object Classes for Packaging Data Elements . . . . . . . . . . . . . . . . . . . 435 17.1.1 The position of a game piece . . . . . . . . . . . . . . . . . . . . . . . . . . . 435 17.1.2 Private instance variables and the toString method . . . . . . . . . . . . . . 440 17.1.3 Using constants in an object class . . . . . . . . . . . . . . . . . . . . . . . . 442 17.1.4 Information hiding . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447 17.2 Bank Account . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453 17.3 Array with Capacity (as an Object Class) . . . . . . . . . . . . . . . . . . . . . . . . 461 18 Interfaces, Subclasses, Inheritance, and Polymorphism 471 18.1 Interface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471 18.1.1 Interface as a template . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471 18.1.2 A simple pizza application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472 18.1.3 The “simple” pizza collection class . . . . . . . . . . . . . . . . . . . . . . . . 473 18.1.4 The pizza collection main class . . . . . . . . . . . . . . . . . . . . . . . . . . 478 18.2 Subclasses and Superclasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480 18.2.1 Extending existing classes and interfaces . . . . . . . . . . . . . . . . . . . . . 480 18.2.2 Writing extensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482 18.3 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490 18.4 Interface Comparable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493 V Advanced Concepts 499 19 Cumulative Algorithms 501 19.1 What is a Cumulative Algorithm? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 501 19.2 Computing Recurrences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503 19.3 Computing the Factorial Function . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506 20 Recursive Algorithms 513 20.1 The Factorial Again . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513 20.2 GCD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516 20.3 The Tower of Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521

Read more less

Book SynopsisThis easy-to-follow textbook teaches Java programming from first principles, as well as covering design and testing methodologies. The text is divided into two parts. Each part supports a one-semester module, the first part addressing fundamental programming concepts, and the second part building on this foundation, teaching the skills required to develop more advanced applications.This fully updated and greatly enhanced fourth edition covers the key developments introduced in Java 8, including material on JavaFX, lambda expressions and the Stream API.Topics and features: begins by introducing fundamental programming concepts such as declaration of variables, control structures, methods and arrays; goes on to cover the fundamental object-oriented concepts of classes and objects, inheritance and polymorphism; uses JavaFX throughout for constructing event-driven graphical interfaces; includes advanced topics such as interfaces and lambda expressions, generics, collection classes and exceptions; explains file-handling techniques, packages, multi-threaded programs, socket programming, remote database access and processing collections using streams; includes self-test questions and programming exercises at the end of each chapter, as well as two illuminating case studies; provides additional resources at its associated website (simply go to springer.com and search for "Java in Two Semesters"), including a guide on how to install and use the NetBeans™ Java IDE.Offering a gentle introduction to the field, assuming no prior knowledge of the subject, Java in Two Semesters is the ideal companion to undergraduate modules in software development or programming.Table of ContentsPart I: Semester One The First Step Building Blocks Selection Iteration Methods Arrays Classes and Objects Implementing Classes Inheritance Introducing JavaFX Case Study – Part 1 Case Study – Part 2 Part II: Semester Two Interfaces and Lambda Expressions Exceptions The Java Collections Framework Advanced JavaFX JavaFX: Interacting with the User Working with Files Packages Multi-Threaded Programs Advanced Case Study The Stream API Working with Sockets Java in Context

Read more less

Book Synopsis

Read more less

Book SynopsisTable of Contents1 Einleitung.- 1.1 Zur Entstehung von PostScript.- 1.2 Die Seitenbeschreibungssprache PostScript.- 1.3 Zielrichtung dieses Buches.- 2 Grundlagen.- 2.1 Der Stack und einfache Arithmetik.- 2.2 Weitere arithmetische Befehle.- 2.3 Koordinatensystem und aktueller Punkt.- 2.4 Einfache Textausgabe.- 2.4.1 Das Font.- 2.4.2 Strings und der Befehl »show«.- 2.4.3 Programm-Struktur.- 2.5 Linien.- 2.6 Spezielle Befehle für die Stackverwaltung.- 3 Variablen, Prozeduren und Schleifen.- 3.1 Variablen.- 3.2 Aufbau von Namen und Zahlen.- 3.3 Prozeduren.- 3.4 Schleifen.- 3.4.1 Der Befehl »loop«.- 3.4.2 Der Befehl »repeat«.- 3.4.3 Der Befehl »for«.- 4 Füllen.- 4.1 Graue Flächen und Linien.- 4.2 Die Befehle »gsave« und »grestore«.- 4.3 Die Füllregeln.- 4.3.1 Die »Non-Zero-Winding-Rule«.- 4.3.2 Die »Even-Odd-Rule«.- 5 Kurven.- 5.1 Kreise.- 5.2 Bezier-Kurven.- 5.3 Abgerundete Ecken.- 6 Arrays, Dictionaries und Strings.- 6.1 Die Arrays.- 6.1.1 Der Befehl »setdash«.- 6.1.2 Spezielle Befehle für Arrays.- 6.1.3 Spezielle Befehle für Markierungen.- 6.2 Die Dictionaries.- 6.3 Eintragungen in Dictionaries.- 6.4 Spezielle Befehle für Strings.- 6.4.1 Die Befehle »string« und »cvs«.- 6.4.2 Der Suchbefehl »search«.- 6.5 Gemeinsame Befehle für Arrays, Dictionaries und Strings.- 6.5.1 Der Befehl »put«.- 6.5.2 Der Befehl »get«.- 6.5.3 Der Befehl »length«.- 6.5.4 Der Befehl »copy«.- 6.5.5 Die Befehle »putinterval« und »getinterval«.- 6.5.6 Der Befehl »forall«.- 6.6 Zugriffsrechte.- 7 Abfragen in PostScript.- 7.1 Die Vergleichsoperationen.- 7.2 Verknüpfung von logischen Werten.- 7.3 Die Befehle »if« und »ifelse«.- 8 Fonts.- 8.1 Die Organisation der Fonts.- 8.2 Ausgabe einer Liste aller verfügbaren Fonts.- 8.3 Aktivierung von Umlauten in PostScript.- 8.4 Outline-Fonts.- 8.5 Userfonts.- 8.5.1 Ein einfaches Userfont.- 8.5.2 Ein vollwertiges Userfont.- 8.5.3 Spezialitäten mit Userfonts.- 9 Transformationen.- 9.1 Der Befehl »translate«.- 9.2 Der Befehl »scale«.- 9.3 Rotation.- 9.4 Der Aufbau der Transformationsmatrix.- 9.5 Die Befehle »transform« und »itransform«.- 9.6 Transformation eines Fonts.- 10 Clipping.- 11 Bildverarbeitung.- 11.1 Aufbau des Bildes.- 11.2 Der Befehl »image«.- 11.3 Der Befehl »imagemask«.- 11.4 Rasterzellen.- 11.5 Der Aufbau der Rasterzelle.- 11.6 Die Transferfunktion.- 12 Ein- und Ausgaben in PostScript.- 12.1 Lesen von Daten aus Datenströmen.- 12.2 Ausgabe von Daten auf Datenströme.- 12.3 Ausführung einer Datei.- 12.4 Erweiterungen für die Dateienverwaltung.- 13 Druckerspezifische Befehle.- 13.1 Allgemeine Druckereinstellungen.- 13.2 Spezielle Befehle für Laserdrucker.- 13.3 Spezielle Befehle für Belichter.- 14 Speicherverwaltung und Programmausführung.- 14.1 Der Befehl »bind« und die Funktion »//«.- 14.2 Die Speicherverwaltung.- 14.3 Die Befehle »exec« und »execstack«.- 14.4 Die Befehle »stop« und »stopped«.- 14.5 Zusammenfassung der PostScript-Typen.- 15 Der graphische Status.- 16 Fehlerbehandlung.- 16.1 Fehler und ihre möglichen Ursachen.- 17 Kommentar-Konventionen.- A ASCII-Tabellen.- B Zahlensysteme.- C Lösungen zu den Aufgaben.- D Literaturverzeichnis.- E Sachwortverzeichnis.

Read more less

Book SynopsisDieses Lehrbuch gibt eine Einführung in das Gebiet der parallelen Programmierung und richtet sich vor allem an Studenten der Informatik im Hauptstudium. Nach den Grundlagen folgen die Gebiete der "konventionellen" asynchronen parallelen Programmierung und der synchronen "massiv parallelen" oder daten-parallelen Programmierung mit tausend oder mehr Prozessoren. Den Abschluß bilden weitere parallele Modelle, die nicht einem dieser beiden Gebiete zugeordnet werden können, die automatische Parallelisierung und Vektorisierung sowie Leistungsbetrachtungen. Das Buch entstand aus dem Skript zur gleichnamigen Vorlesung, die vom Autor an der Universität Stuttgart gehalten wurde. Begleitende Praktika und Seminar ergänzten den Themenbereich, an denen sich die Übungen zu den jeweiligen Kapiteln orientieren.Table of ContentsGrundlagen: Klassifikationen, Parallele Operationen, Parallelrechneraufbau - Grobkörnige Parallelität (Aufbau eines MIMD-Rechners, Softwarestruktur, Synchronisation und Kommunikation, Vektorisierung, Programmiersprachen, Parallele Algorithmen) - Massive Parallelität (Aufbau eines SIMD-Rechners, Softwarestruktur, Programmiersprachen, Neuronale Netze) - Programmierumgebungen und Effizienz.

Read more less

Book SynopsisCOBOL dürfte die am meisten angewendete Programmiersprache seit ihrer ersten Veröffentlichung im Jahre 1960 sein. Man schätzt, daß etwa 40% aller geschriebenen Programme in COBOL abgefaßt worden sind, wobei der Trend eher als zunehmend zu beurteilen ist. Der Grund für dieses gesteigerte Interesse liegt vor allem in der ständig zu­ nehmenden Aufbereitung und Verarbeitung von Massendaten aus allen wirtschaftlich orientierten Bereichen, wofür COBOL hervorragend ge­ eignet ist. Da die anwenderbezogenen Anforderungen an die Verar­ beitung dieser Daten einer ständigen Entwicklung unterliegen, muß auch COBOL dieser Entwicklung gerecht werden. Seit 1968 hat das American National Standards Institute (ANS I) , dem auch ein inter­ nationaler Beraterkreis angehört, die Standardisierung der COBOL­ Entwicklung übernommen. Dadurch wurde der Grundstein für die Kompatibilität der Sprache gelegt. Heute sind alle publizierten COBOL­ Versionen aufwärtskompatibel. Das heißt, daß auch Programme, die in älteren Versionen geschrieben wurden, beim Einsatz neuer Compiler­ Versionen unter geringfügigen Quell-Code-Änderungen läuffähig bleiben. Damit ist COBOL zu einer lebendigen Programmiersprache geworden, die eine zukünftige Entwicklung bereits in sich trägt und universell einsetzbar ist. Da COBOL für die Verarbeitung großer Datenmengen geschaffen wurde, war ihr Einsatz in der Vergangenheit auf Großrechner be­ schränkt. Durch die rasche Hardware-Entwicklung, die vor allem durch immer schnellere Rechner und größere Speicherkapazitäten auf kleinstem Raum zum Ausdruck kommt, können COBOL-Programme auch zunehmend auf mittleren und Kleinanlagen eingesetzt werden. Die Computer-Hersteller haben dieser Entwicklung Rechnung getragen und eine Reihe sehr guter Compiler entwickelt, die auf dem PC einsetzbar sind.Table of Contents1 Entwicklung von COBOL.- 2 COBOL-Notation (Syntax).- 3 Die COBOL-Programmstruktur.- 3.1 Die Divisions.- 3.2 Der COBOL-Zeichenvorrat.- 3.3 COBOL-Zeichenfolgen.- 3.3.1 COBOL-Wortarten.- 3.3.1.1 Programmierer-Wörter.- 3.3.1.2 Systemnamen.- 3.3.1.3 Reservierte Wörter.- 3.3.2 Literate.- 3.3.2.1 Numerische Literate.- 3.3.2.2 Nichtnumerische Literate.- 3.3.3 PICTURE-Zeichenfolgen.- 3.4 Das Standard-COBOL-Format.- 3.4.1 Zeilenfortsetzung.- 3.4.1.1 Trennen von Wörtern und numerischen Literaten.- 3.4.1.2 Trennen von nichtnumerischen Literaten.- 3.4.2 Kommentarzeilen.- 3.4.3 Leerzeilen.- 3.5 Das COBOL-Quellprogramm.- 4 Identification Division.- 4.1 Der Paragraph PROGRAM-ID.- 4.2 Die wahlfreien Paragraphen.- 5 Environment Division.- 5.1 Configuration Section.- 5.1.1 Der Paragraph SOURCE-COMPUTER.- 5.1.1.1 WITH DEBUGGING MODE-Klausel.- 5.1.2 Der Paragraph OBJECT-COMPUTER.- 5.1.2.1 MEMORY SIZE-Klausel.- 5.1.2.2 SEGMENT-LIMIT-Klausel.- 5.1.2.3 PROGRAM COLLATING SEQUENCE-Klausel.- 5.1.3 Der Paragraph SPECIAL-NAMES.- 5.1.3.1 Funktionsname-1 IS Merkname-Klausel.- 5.1.3.2 Funktionsname-2 IS Merkname-Klausel.- 5.1.3.3 ALPHABET Alphabetname-Klausel.- 5.1.3.4 CURRENCY SIGN-Klausel.- 5.1.3.5 DECIMAL-POINT IS COMMA-Klausel.- 5.1.3.6 CLASS-Klausel.- 5.2 Input-Output Section.- 5.2.1 Dateiorganisationsformen und Zugriffsmethoden.- 5.2.1.1 Sequentielle Organisationsform.- 5.2.1.2 Indizierte Organisationsform.- 5.2.1.3 Relative Organisationsform.- 5.2.1.4 Sequentieller Zugriff.- 5.2.1.5 Wahlfreier Zugriff.- 5.2.1.6 Dynamischer Zugriff.- 5.3 Der Paragraph FILE-CONTROL.- 5.3.1 SELECT-Klausel.- 5.3.2 ASSIGN-Klausel.- 5.3.3 RESERVE-Klausel.- 5.3.4 ORGANIZATION-Klausel.- 5.3.5 ACCESS MODE-Klausel.- 5.3.6 PADDING CHARACTER-Klausel.- 5.3.7 RECORD DELIMITER-Klausel.- 5.3.8 RECORD KEY-Klausel.- 5.3.9 ALTERNATE RECORD KEY-Klausel.- 5.3.10 FILE STATUS-Klausel.- 5.4 Der Paragraph I-O-CONTROL.- 5.4.1 RERUN-Klausel.- 5.4.2 SAME AREA-Klausel.- 5.4.3 MULTIPLE FILE TAPE-Klausel.- 5.4.4 APPLY WRITE ONLY-Klausel.- 6 Data Division.- 6.1 File Section.- 6.1.1 BLOCK CONTAINS-Klausel.- 6.1.2 RECORD CONTAINS-Klausel.- 6.1.3 LABEL RECORD-Klausel.- 6.1.4 VALUE OF-Klausel.- 6.1.5 DATA RECORDS-Klausel.- 6.1.6 LINAGE-Klausel.- 6.1.7 RECORDING MODE-Klausel.- 6.1.8 CODE SET-Klausel.- 6.2 Datenbeschreibung.- 6.2.1 Stufennummern.- 6.2.1.1 Stufennummern für die Satzbeschreibung.- 6.2.1.2 Spezielle Stufennummern.- 6.3 Datenerklärung.- 6.3.1 Datennamen.- 6.3.1.1 Die Feldbezeichnung FILLER.- 6.3.2 PICTURE-Klausel.- 6.3.2.1 Datenklassen und Datenkategorien.- 6.3.2.2 Alphabetische Datenelemente.- 6.3.2.3 Numerische Datenelemente.- 6.3.2.4 Alphanumerische Datenelemente.- 6.3.2.5 Aufbau der PICTURE-Zeichenfolge.- 6.3.2.6 PICTURE-Symbole für die Druckaufbereitung.- 6.3.2.7 Mindestlange der PICTURE-Zeichenfolge.- 6.3.3 SIGN-Klausel.- 6.3.4 REDEFINES-Klausel.- 6.3.4.1 Implizite Redefinition (FILE SECTION).- 6.3.4.2 Explizite Redefinition.- 6.3.4.3 Mehrmalige Redefinition eines Datenbereichs.- 6.3.4.4 Redefinition von Einzelfeldern.- 6.3.4.5 Datenübertragungen in redefinierte und redefinierende Felder.- 6.3.5 BLANK WHEN ZERO-Klausel.- 6.3.6 JUSTIFIED RIGHT-Klausel.- 6.3.7 OCCURS-Klausel.- 6.3.8 SYNCHRONIZED-Klausel.- 6.3.8.1 Einfügung von Füll-Bytes durch den Compiler.- 6.3.8.2 Einfügung von Füll-Bytes durch den Programmierer.- 6.3.9 USAGE-Klausel.- 6.3.9.1 Usage Is Display.- 6.3.9.2 Usage Is Binary.- 6.3.9.3 Usage Is Computational (COMP).- 6.3.9.4 Usage Is Index.- 6.3.9.5 Usage Is Packed-Decimal.- 6.3.9.6 Vorzeichenverarbeitung unter VS COBOL II.- 6.3.9.7 Einfluß des Datenformats auf die Effizienz arithmetischer Operationen.- 6.3.10 VALUE-Klausel.- 6.3.11 RENAMES-Klausel.- 6.3.12 Stufennummer 88.- 7 Procedure Division.- 7.1 Die Struktur der PROCEDURE DIVISION.- 7.1.1 Der selbstdefinierte Dateistatus.- 7.2 Datenübertragungen.- 7.2.1 ACCEPT-Anweisung.- 7.2.1.1 Übertragung von Daten.- 7.2.1.2 Übertragung von Systeminformationen.- 7.2.2 DISPLAY-Anweisung.- 7.2.3 MOVE-Anweisung.- 7.2.4 MOVE CORRESPONDING-Anweisung.- 7.2.5 STRING-Anweisung.- 7.2.6 UNSTRING-Anweisung.- 7.2.7 INSPECT-Anweisung.- 7.2.8 INITIALIZE-Anweisung.- 7.2.8.1 Initialisierung von Tabellen.- 7.3 Arithmetische Ausdrücke.- 7.3.1 Arithmetische Operatoren.- 7.4 Bedingungen.- 7.4.1 Einfache Bedingungen.- 7.4.1.1 Klassenbedingungen.- 7.4.1.2 Vorzeichenbedingungen.- 7.4.1.3 Vergleichsbedingungen.- 7.4.1.4 Bedingungsnamen-Bedingungen.- 7.4.2 Zusammengesetzte Bedingungen.- 7.5 Bedingte Anweisungen.- 7.5.1 IF-Anweisung.- 7.5.1.1 Geschachtelte IF-Anweisungen.- 7.5.1.2 IF-Anweisungen mit Leerzweigen.- 7.5.2 CONTINUE-Anweisung.- 7.5.3 EVALUATE-Anweisung.- 7.5.3.1 Verarbeitung von Entscheidungstabellen.- 7.6 Arithmetische Anweisungen.- 7.6.1 ROUNDED-Angabe.- 7.6.2 ON SIZE ERROR-Angabe.- 7.6.3 NOT ON SIZE ERROR-Angabe.- 7.6.4 END-Begrenzungen.- 7.6.5 ADD-Anweisung.- 7.6.6 SUBTRACT-Anweisung.- 7.6.7 MULTIPLY-Anweisung.- 7.6.8 DIVIDE-Anweisung.- 7.6.9 COMPUTE-Anweisung.- 7.7 Eingabe-/Ausgabeanweisungen.- 7.7.1 OPEN-Anweisung.- 7.7.2 CLOSE-Anweisung.- 7.7.3 READ-Anweisung.- 7.7.4 WRITE-Anweisung.- 7.7.5 REWRITE-Anweisung.- 7.7.6 START-Anweisung.- 7.7.7 DELETE-Anweisung.- 7.8 Programmverzweigungen.- 7.8.1 PERFORM-Anweisung.- 7.8.1.1 Tabellverarbeitung mit PERFORM VARYING.- 7.8.1.2 Geschachtelte PERFORM-Anweisungen.- 7.8.2 EXIT-Anweisung.- 7.8.3 GO TO-Anweisung.- 7.8.4 GO TO ... DEPENDING ON-Anweisung.- 7.8.5 STOP-Anweisung.- 7.8.6 ALTER-Anweisung.- 7.9 Tabellenverarbeitung.- 7.9.1 OCCURS-Klausel.- 7.9.1.1 Normalindizierung (Subscripting).- 7.9.1.2 Spezialindizierung (Indexing).- 7.9.1.3 Mehrdimensionale Tabellen.- 7.9.2 SET-Anweisung.- 7.9.3 SEARCH-Anweisung.- 7.9.3.1 Sequentielles Durchsuchen einer Tabelle.- 7.9.3.2 Binares Durchsuchen einer Tabelle.- 7.10 Änderung von Quell-Text.- 7.10.1 COPY-Anweisung.- 7.10.2 REPLACING-Anweisung.- 7.10.3 BASIS-Anweisung.- 8 Externe Unterprogramme.- 8.1 CALL-Anweisung.- 8.1.1 USING-Zusatz.- 8.1.1.1 Using by Reference/Content.- 8.2 USING-Zusatz in der PROCEDURE DIVISION des Unterprogramms.- 8.3 LINKAGE SECTION.- 8.4 EXIT PROGRAM-Anweisung.- 8.5 CANCEL-Anweisung.- 8.6 ENTRY-Anweisung.- 9 Sortieren und Mischen.- 9.1 Sortieren von Dateien (SORT).- 9.1.1 SELECT/ASSIGN-Klausel.- 9.1.2 SD-Eintragung.- 9.1.3 SORT-Anweisung.- 9.1.4 RELEASE-Anweisung.- 9.1.5 RETURN-Anweisung.- 9.2 Mischen von Dateien (MERGE).- 9.2.1 MERGE-Anweisung.- 9.3 Das IBM-Dienstprogramm DFSORT.- 9.3.1 Die IBM-Sonderregister.- 10 Declaratives.- 10.1 USE-Anweisung.- 11 Dialog-orientierte Programmierung.- 11.1 Menü-Technik mit MS-COBOL.- 11.1.1 Positionierung des Cursors.- 11.1.1.1 Cursor-Klausel (CURSOR IS daten-name).- 11.1.2 Löschen des Bildschirms.- 11.1.3 Struktur der Aus- und Eingabebereiche.- 11.2 Menü-Technik mit den Mitteln des ANSI-Standards unter VS COBOL II.- 12 Grundlagen der strukturierten Programmierung.- 12.1 Der logische Aufbau eines strukturierten Programms.- 12.1.1 Der Haupt-Modul.- 12.2 COBOL-Tools für die strukturierte Programmierung.- 12.3 Allgemeine Regeln und Empfehlungen zur Erstellung eines strukturierten Programms.- 12.3.1 Maßnahmen zur Verbesserung der Lesbarkeit des Quell-Programms.- 12.3.2 Kennzeichnung der Paragraphen-Namen.- 12.3.3 Der eingeschränkte Gebrauch von GO TO.- 12.3.4 Der Programmentwurf im Strukturtext.- 12.4 Struktogramm-Technik.- 12.4.1 Einfacher Strukturblock.- 12.4.2 Bedingungs-Strukturblock.- 12.4.3 CASE-Strukturblock.- 12.4.4 CYCLE-Strukturblock.- 12.4.4.1 Realisierung eines CYCLE-Blocks durch das IN-LINE-PERFORM.- 12.4.5 Prozeduraufruf-Strukturblock.- 12.4.6 BREAK-Strukturblock.- 12.4.7 Klammer-Strukturblock.- Anhang 1: ASCII-Sortierfolge (8-Bit-Code).- Anhang 2: EBCDIC-Sortierfolge (IBM-Standard U.S.).- Anhang 3: Liste der reservierten COBOL-Wörter.- Sachwortverzeichnis.

Read more less

Book SynopsisDas Buch ist eine Einführung in die Programmiersprache Java. In den ersten Kapiteln werden die Grundlagen behandelt: Klassen, Objekte, Interfaces und Pakete. Weitere Kapitel befassen sich mit Benutzeroberflächen, der Ausnahmebehandlung, der Threadprogrammierung, mit Client/Server-Implementierung, Javas Sicherheitsmechanismen und dem Aufruf entfernter Methoden. Alle Sprachkonstrukte und die verwendeten Klassen der Java-Standardbibliothek werden an Beispielen verdeutlicht. An die einzelnen Kapitel schließt sich eine Reihe von Übungsaufgaben an. Die kompletten Beispielprogramme und Lösungen zu den Übungen befinden sich auf der beiliegenden CD-ROM.In der 4. Auflage wurde die Behandlung des IO-Frameworks um das New IO API (NIO), das seit JDK 1.4 neben das streambasierte API tritt, erweitert. Einige Client/Server-Beispiele wurden auf NIO umgestellt. Bei der Ausnahmebehandlung wurde das neue Java-Sprachkonstrukt der Zusicherungen (assertions) ergänzt.Table of Contents1 Einleitung.- 1.1 Erste Beispiele.- 1.2 Die Ausführung von Java-Programmen.- 1.3 Übungsaufgaben.- 2 Lexikalische Konventionen.- 2.1 Lexikalische Elemente.- 2.2 Kommentare.- 2.3 Bezeichner.- 2.4 Schlüsselwörter.- 2.5 Interpunktionszeichen.- 2.6 Operatoren.- 2.7 Syntaxnotation.- 2.8 Übungsaufgabe.- 3 Typen und Werte.- 3.1 Datentypen.- 3.2 Wertebereiche.- 4 Konstanten und Variablen.- 4.1 Ganzzahlige Konstanten.- 4.2 Gleitpunktkonstanten.- 4.3 Zeichenkonstanten.- 4.4 Zeichenkettenkonstanten.- 4.5 Die Nullreferenz.- 4.6 Variablen.- 4.7 Symbolische Konstanten.- 4.8 Die Initialisierung von Variablen.- 4.9 Übungsaufgaben.- 5 Typumwandlungen, Ausdrücke und Operatoren.- 5.1 Typumwandlungen.- 5.1.1 Elementare Typvergrößerungen.- 5.1.2 Elementare Typverkleinerungen.- 5.1.3 Vergrößerungen von Referenztypen.- 5.1.4 Verkleinerungen von Referenztypen.- 5.1.5 Typumwandlungen nach String.- 5.2 Konversionskontexte.- 5.2.1 Zuweisungskonversionen.- 5.2.2 Methodenaufruf-Konversionen.- 5.2.3 String-Konversionen.- 5.2.4 Numerische Typangleichungen.- 5.3 Explizite Casts.- 5.4 Ausdrücke und Operatoren.- 5.4.1 Elementare Ausdrücke und Namen.- 5.4.2 Postfix-Inkrement und Dekrement.- 5.4.3 Einstellige Operatoren.- 5.4.4 Multiplikative Operatoren.- 5.4.5 Additive Operatoren.- 5.4.6 Shift-Operatoren.- 5.4.7 Relationale Operatoren.- 5.4.8 Gleichheitsoperatoren.- 5.4.9 Bit-Operatoren und logische Operatoren.- 5.4.10 Boolesche Operatoren.- 5.4.11 Der Konditional-Operator.- 5.4.12 Zuweisungsoperatoren.- 5.4.13 Konstante Ausdrücke.- 5.4.14 Zuweisungen und Initialisierungen.- 5.5 Übungsaufgaben.- 6 Anweisungen.- 6.1 Lokale Variablen.- 6.1.1 final lokale Variablen.- 6.2 Leeranweisungen.- 6.3 Ausdrucksanweisungen.- 6.4 Auswahlanweisungen.- 6.4.1 Die if-Anweisung.- 6.4.2 Die switch-Anweisung.- 6.5 Wiederholungsanweisungen.- 6.5.1 Die while-Anweisung.- 6.5.2 Die do-Anweisung.- 6.5.3 Die for-Anweisung.- 6.6 Markierte Anweisungen.- 6.7 Die break-Anweisung.- 6.8 Die continue-Anweisung.- 6.9 Weitere Java-Anweisungen.- 6.10 Übungsaufgaben.- 7 Felder.- 7.1 Feldvariablen.- 7.2 Die Erzeugung von Feldern.- 7.3 Der Zugriff auf Feldkomponenten.- 7.4 Mehrdimensionale Felder.- 7.5 Felder als Objekte.- 7.6 Typumwandlungen.- 7.7 Felder und Zeichenketten.- 7.8 Übungsaufgaben.- 8 Klassen und Objekte.- 8.1 Klassendeklarationen.- 8.2 Der Zugriff auf Klassenelemente.- 8.3 Instanz- und Klassenvariablen.- 8.4 Die Initialisierung von Variablen.- 8.5 Konstante Klassenelemente.- 8.6 Methoden.- 8.6.1 Methodendeklaration.- 8.6.2 Methodenaufruf.- 8.6.3 Die return-Anweisung.- 8.7 Instanz- und Klassenmethoden.- 8.8 Überladene Methoden.- 8.9 Die Konstruktion von Objekten.- 8.10 static Initialisierer.- 8.11 Objektzerstörung.- 8.12 Übungsaufgaben.- 9 Subklassen, Superklassen und Vererbung.- 9.1 Vererbung.- 9.2 Verdeckte Variablen.- 9.3 Umwandlungen von Referenztypen.- 9.4 Überschriebene Methoden.- 9.4.1 static Methoden.- 9.4.2 Methodenaufrufe mittels super.- 9.5 final Methoden und Klassen.- 9.6 Die Konstruktion von Objekten.- 9.7 Abstrakte Methoden und Klassen.- 9.8 Typinformationen zur Laufzeit.- 9.9 Übungsaufgaben.- 10 Pakete, Geltungsbereiche und Zugreifbarkeit.- 10.1 Pakete.- 10.2 Geltungsbereiche.- 10.3 Zugriffsrechte.- 10.3.1 Zugriffsrechte und Vererbung.- 10.4 Import-Deklarationen.- 10.5 Die Suche nach class-Dateien.- 10.6 Java-Archive.- 10.7 Bibliotheken und Projekte.- 10.8 Übungsaufgaben.- 11 Interfaces.- 11.1 Interfacedeklarationen.- 11.2 Interfaceelemente.- 11.2.1 Interfacemethoden.- 11.2.2 Interfacevariablen.- 11.3 Die Implementation von Interfaces.- 11.4 Sub- und Superinterfaces.- 11.5 Mehrdeutigkeiten.- 11.6 Interfaces aus der Java-Bibliothek.- 11.7 Übungsaufgaben.- 12 Eingebettete Klassendeklarationen.- 12.1 Innere Klassen.- 12.2 Anonyme Klassen.- 12.3 Eingebettete static Klassen.- 12.4 Übungsaufgaben.- 13 Aufbau von Benutzeroberflächen (Teil I).- 13.1 Ein erstes Beispiel.- 13.2 Grundkomponenten.- 13.2.1 Ränder, Farben, Fonts.- 13.2.2 Labels und Icons.- 13.2.3 Buttons.- 13.2.4 Listen und Auswahlkomponenten.- 13.2.5 Einfache Textkomponenten.- 13.3 Layout-Manager.- 13.3.1 Das FlowLayout.- 13.3.2 Das BorderLayout.- 13.3.3 Das OverlayLayout.- 13.3.4 Das GridLayout.- 13.3.5 Das BoxLayout und der Box-Container.- 13.3.6 Das CardLayout und JTabbedPane.- 13.3.7 Layout mittels Container-Schachtelung.- 13.4 Container.- 13.4.1 JDialog-Objekte.- 13.4.2 JInternalFrames.- 13.4.3 Applets.- 13.4.4 Applets und Fenster.- 13.4.5 Eingebettete Container.- 13.5 Menüs und Toolbars.- 13.5.1 Pulldown-Menüs.- 13.5.2 Popup-Menüs.- 13.5.3 Toolbars.- 13.6 Swing-Interna.- 13.6.1 Low-level Ereignisse.- 13.6.2 Die Darstellung von Komponenten.- 13.7 Übungsaufgaben.- 14 Grundlegende Klassen.- 14.1 Zeichenketten.- 14.2 Zeichenketten-Puffer.- 14.3 Suchen in Zeichenketten mit regulären Ausdrücken.- 14.4 Hüllklassen für elementare Datentypen.- 14.5 Zeitpunkte und Kalender.- 14.6 Text-Formatierung von Zahlen, Zeitpunkten und Nachrichten.- 14.6.1 Text-Formatierung von Zahlen.- 14.6.2 Text-Formatierung von Zeitpunkten.- 14.6.3 Text-Formatierung von Nachrichten.- 14.7 Sprach- und länderspezifische Einstellungen.- 14.7.1 Internationalisierung von Standard-Komponenten.- 14.7.2 Applikationsspezifische Internationalisierung.- 14.7.3 Explizite Auswahl von Sprache und Land.- 14.8 Mengen, Listen und Zuordnungen.- 14.8.1 Mengen.- 14.8.2 Geordnete Mengen.- 14.8.3 Listen.- 14.8.4 Zuordnungen.- 14.9 Elementare mathematische Funktionen.- 14.10 Zugriffe auf das System.- 14.11 Übungsaufgaben.- 15 Ausnahmebehandlung.- 15.1 Einleitung.- 15.2 Ausnahmetypen.- 15.3 Die Behandlung von Ausnahmen.- 15.4 Die throws-Klausel.- 15.5 Ausnahmen explizit auswerfen.- 15.6 Überschriebene Methoden und throws-Klauseln.- 15.7 Zusicherungen.- 15.8 Übungsaufgaben.- 16 Ein- und Ausgabe.- 16.1 Einleitung.- 16.2 Ein- und Ausgabeströme für Bytes.- 16.3 Ein- und Ausgabeströme für elementare Datentypen.- 16.4 Ein- und Ausgabeströme für Zeichen und Strings.- 16.4.1 Zeichensätze.- 16.4.2 Lesen und Schreiben von Zeichenströmen.- 16.4.3 Die Codierung von Java-Sourcecode.- 16.5 Lesen und Schreiben von Dateien mit Streams.- 16.5.1 Zugriffe auf das Dateisystem.- 16.5.2 Lesen und Schreiben von Dateiströmen.- 16.5.3 Lesen und Schreiben mittels RandomAccessFile.- 16.6 Puffer.- 16.7 Ein-/Ausgabekanäle für Bytes und elementare Datentypen.- 16.8 Ein-/Ausgabekanäle für Zeichen und Strings.- 16.9 Das Serialisieren von Objekten.- 16.9.1 Persistenz durch Erreichbarkeit.- 16.9.2 Klassenspezifische Versionen von writeObject und readObject.- 16.10 Ausgabe von Log-Nachrichten.- 16.11 Übungsaufgaben.- 17 Threads und Prozesse.- 17.1 Threads.- 17.2 Eigenschaften eines Thread-Objekts.- 17.3 Thread-Scheduling, Thread-Prioritäten.- 17.4 Threadgruppen.- 17.5 Thread-Synchronisation.- 17.6 Die Kommunikation zwischen Threads.- 17.7 Threads und Applets.- 17.8 Systemprozesse.- 17.9 Übungsaufgaben.- 18 Aufbau von Benutzeroberflächen (Teil II).- 18.1 Dateiauswahl-Dialoge.- 18.2 Tabellen.- 18.2.1 Einfache Tabellen für Felder.- 18.2.2 Das TableModel.- 18.3 Höhere Textkomponenten.- 18.3.1 Die Klasse JEditorPane.- 18.3.2 Die Klasse JTextPane.- 18.4 Übungsaufgaben.- 19 Netzwerke, Client/Server-Programmierung.- 19.1 Zugriffe auf den DNS.- 19.2 TCP/IP-Verbindungen.- 19.2.1 Client-Sockets.- 19.2.2 Server-Sockets.- 19.2.3 Server mit mehreren Clients.- 19.2.4 Ein einfaches Anwendungsprotokoll über TCP/IP.- 19.3 Datenübertragung mittels UDP/IP.- 19.4 Zugriffe auf Netzressourcen über die Klasse URL.- 19.4.1 Die Bestandteile eines URIs.- 19.4.2 Das Lesen von Ressourcen.- 19.5 Servlets und dynamisch erzeugte HTML-Seiten.- 19.6 JavaServer Pages.- 19.6.1 Skriptlets.- 19.6.2 Taglibs.- 19.6.3 Arbeiten mit Objekten.- 19.7 Übungsaufgaben.- 20 Java-Sicherheit.- 20.1 Applet-Restriktionen und policy-Dateien.- 20.2 Zugriffsrechte.- 20.3 Stand-alone Anwendungen und SecurityManager.- 20.4 Digitale Signaturen.- 20.4.1 Signierte Applets.- 20.4.2 Signierte Anwendungen.- 20.5 Übungsaufgaben.- 21 Methodenaufrufe für entfernte Objekte (RMI).- 21.1 Methodenaufrufe für entfernte Objekte.- 21.2 Das Starten der Registry innerhalb des Servers.- 21.3 Kopien und Referenzen für entfernte Objekte.- 21.4 Callbacks.- 21.5 Netzwerkmethoden in Applets.- 21.6 Übungsaufgaben.- A Die Java-Syntaxregeln.- B ASCII—Tabelle.- C Konversionen von Referenztypen.- D Operatorprioritäten.- E GUI-Ereignisse und -Listener.- F Serialisierbare Klassen.- G Locale-Konstanten.- H Wichtige HTML-Markierungen.- I Einbinden von Applets in HTML.

Read more less

Book Synopsis

Read more less