Programming and scripting languages: general Books

Book SynopsisDelivers absolutely everything you will ever need to know to become a master Django programmer About This Book * Gain a complete understanding of Django-the most popular, Python-based web framework in the world * Gain the skills to successfully designing, developing, and deploying your app * This book is packaged with fully described code so you can learn the fundamentals and the advanced topics to get a complete understanding of all of Django's core functions Who This Book Is For This book assumes you have a basic understanding of the Internet and programming. Experience with Python or Django would be an advantage, but is not necessary. It is ideal for beginner to intermediate programmers looking for a fast, secure, scalable, and maintainable alternative web development platform to those based on PHP, Java, and dotNET. What You Will Learn * Use Django to access user-submitted form data, validate it, and work with it * Get to know advanced URLconf tips and tricks * Extend Django's template system with custom code * Define models and use the database API to create, retrieve, update, and delete records * Fully extend and customize the default implementation as per your project's needs * Test and deploy your Django application * Get to know more about Django's session, cache Framework, and middleware In Detail Mastering Django: Core is a completely revised and updated version of the original Django Book, written by Adrian Holovaty and Jacob Kaplan-Moss - the creators of Django. The main goal of this book is to make you a Django expert. By reading this book, you'll learn the skills needed to develop powerful websites quickly, with code that is clean and easy to maintain. This book is also a programmer's manual that provides complete coverage of the current Long Term Support (LTS) version of Django. For developers creating applications for commercial and business critical deployments, Mastering Django: Core provides a complete, up-to-date resource for Django 1.8LTS with a stable code-base, security fixes and support out to 2018. Style and approach This comprehensive step-by-step practical guide offers a thorough understanding of all the web development concepts related to Django. In addition to explaining the features of Django, this book provides real-world experience on how these features fit together to build extraordinary apps.

Read more less

Book SynopsisStart with the basics of reinforcement learning and explore deep learning concepts such as deep Q-learning, deep recurrent Q-networks, and policy-based methods with this practical guideKey Features Use TensorFlow to write reinforcement learning agents for performing challenging tasks Learn how to solve finite Markov decision problems Train models to understand popular video games like Breakout Book DescriptionVarious intelligent applications such as video games, inventory management software, warehouse robots, and translation tools use reinforcement learning (RL) to make decisions and perform actions that maximize the probability of the desired outcome. This book will help you to get to grips with the techniques and the algorithms for implementing RL in your machine learning models.Starting with an introduction to RL, you’ll be guided through different RL environments and frameworks. You’ll learn how to implement your own custom environments and use OpenAI baselines to run RL algorithms. Once you’ve explored classic RL techniques such as Dynamic Programming, Monte Carlo, and TD Learning, you’ll understand when to apply the different deep learning methods in RL and advance to deep Q-learning. The book will even help you understand the different stages of machine-based problem-solving by using DARQN on a popular video game Breakout. Finally, you’ll find out when to use a policy-based method to tackle an RL problem.By the end of The Reinforcement Learning Workshop, you’ll be equipped with the knowledge and skills needed to solve challenging problems using reinforcement learning.What you will learn Use OpenAI Gym as a framework to implement RL environments Find out how to define and implement reward function Explore Markov chain, Markov decision process, and the Bellman equation Distinguish between Dynamic Programming, Monte Carlo, and Temporal Difference Learning Understand the multi-armed bandit problem and explore various strategies to solve it Build a deep Q model network for playing the video game Breakout Who this book is forIf you are a data scientist, machine learning enthusiast, or a Python developer who wants to learn basic to advanced deep reinforcement learning algorithms, this workshop is for you. A basic understanding of the Python language is necessary.Table of ContentsTable of Contents Introduction to Reinforcement Learning Markov Decision Processes and Bellman Equations Deep Learning in Practice with TensorFlow 2 Getting Started with OpenAI and TensorFlow for Reinforcement Learning Dynamic Programming Monte Carlo Methods Temporal Difference Learning The Multi-Armed Bandit Problem What Is Deep Q Learning? Playing an Atari Game with Deep Recurrent Q Networks Policy-Based Methods for Reinforcement Learning Evolutionary Strategies for RL

Read more less

Book SynopsisUnderstand how to use the Fyne toolkit to build exciting apps for a range of devices and deploy them effectivelyKey Features Learn how to use standard widgets, dialogs, and layouts as well as how to build your own Understand how to develop an app and package and distribute it to different operating systems and app stores Explore the design principles and vision of the Fyne toolkit and how that may align with your project Book DescriptionThe history of graphical application development is long and complicated, with various development challenges that persist to this day. The mix of technologies involved and the need to use different programming languages led to a very steep learning curve for developers looking to build applications across multiple platforms. In Building Cross-Platform GUI Applications with Fyne, you'll understand how the Go language, when paired with a modern graphical toolkit such as Fyne, can overcome these issues and make application development much easier. To provide an easy-to-use framework for cross-platform app development, the Fyne project offers many graphical concepts and design principles that are outlined throughout this book. By working through five example projects, you'll learn how to build apps effectively, focusing on each of the main areas, including the canvas, layouts, file handling, widgets, data binding, and themes. The book will also show you how the completed applications can then be run on your desktop computer, laptop, and smartphone. After completing these projects, you will discover how to prepare applications for release and distribute them to platform marketplaces and app stores. By the end of this book, you'll be able to create cross-platform graphical applications with visually appealing user interfaces and concise code.What you will learn Become well-versed with the history of GUI development and how Fyne and the Golang programming language make it easier Explore how the Fyne toolkit is architected and the various modules are provided Discover how Fyne apps can be tested and constructed using best practices Construct five complete applications and deploy them to your devices Customize the design of your apps by extending widgets and themes Understand the separation and presentation of data and how to test and build applications that present dynamic data Who this book is forThis Fyne-Golang GUI book is for developers from any background who are looking to build cross-platform applications with a modern toolkit. It will also be useful for Go developers who are looking to explore graphical apps and GUI developers looking for a new toolkit for cross-platform development. Basic knowledge of Graphical User Interface (GUI) development is assumed (although a brief history is also included in the book). The book also features a short introduction to the Go language as a quick refresher.Table of ContentsTable of Contents A Brief History of GUI Toolkits and Cross-Platform Development The Future According to Fyne Window, Canvas, and Drawing Layout and File handling Widget Library and Themes Data Binding and Storage Building Custom Widgets and Themes Project Structure and Best Practices Bundling Resources and Preparing for Release Distribution - App Stores and Beyond Appendix A: Developer Tool Installation Appendix B: Installation of Mobile Build Tools Appendix C: Cross-Compiling

Read more less

Book SynopsisCreate end-to-end systems that can power robots with artificial vision and deep learning techniquesKey Features Study ROS, the main development framework for robotics, in detail Learn all about convolutional neural networks, recurrent neural networks, and robotics Create a chatbot to interact with the robot Book DescriptionArtificial Vision and Language Processing for Robotics begins by discussing the theory behind robots. You'll compare different methods used to work with robots and explore computer vision, its algorithms, and limits. You'll then learn how to control the robot with natural language processing commands. You'll study Word2Vec and GloVe embedding techniques, non-numeric data, recurrent neural network (RNNs), and their advanced models. You'll create a simple Word2Vec model with Keras, as well as build a convolutional neural network (CNN) and improve it with data augmentation and transfer learning. You'll study the ROS and build a conversational agent to manage your robot. You'll also integrate your agent with the ROS and convert an image to text and text to speech. You'll learn to build an object recognition system using a video.By the end of this book, you'll have the skills you need to build a functional application that can integrate with a ROS to extract useful information about your environment.What you will learn Explore the ROS and build a basic robotic system Understand the architecture of neural networks Identify conversation intents with NLP techniques Learn and use the embedding with Word2Vec and GloVe Build a basic CNN and improve it using generative models Use deep learning to implement artificial intelligence(AI)and object recognition Develop a simple object recognition system using CNNs Integrate AI with ROS to enable your robot to recognize objects Who this book is forArtificial Vision and Language Processing for Robotics is for robotics engineers who want to learn how to integrate computer vision and deep learning techniques to create complete robotic systems. It will prove beneficial to you if you have working knowledge of Python and a background in deep learning. Knowledge of the ROS is a plus.Table of ContentsTable of Contents Fundamentals of Robotics Introduction to Computer Vision Fundamentals of Natural Language Processing Neural Networks with NLP Convolutional Neural Networks Robot Operating System Build a Conventional Agent to Manage the Robot Object Recognition to Guide a Robot Using CNNs Computer Vision for Robotics

Read more less

Book SynopsisNew edition of the bestselling guide to building an effective mobile app architecture with Xamarin.Forms 4 that maximizes the overall quality of apps.Key Features Updated for Xamarin.Forms 4 Packed with real-world scenarios and solutions to help you build professional grade mobile apps with Xamarin.Forms Includes design patterns and best practice techniques that every mobile developer should know Book DescriptionDiscover how to extend and build upon the components of the most recent version of Xamarin.Forms to develop an effective, robust mobile app architecture. This new edition features Xamarin.Forms 4 updates, including CollectionView and RefreshView, new coverage of client-side validation, and updates on how to implement user authentication.Mastering Xamarin.Forms, Third Edition is one of the few Xamarin books structured around the development of a simple app from start to finish, beginning with a basic Xamarin.Forms app and going step by step through several advanced topics to create a solution architecture rich with the benefits of good design patterns and best practices.This book introduces a core separation between the app's user interface and the app's business logic by applying the MVVM pattern and data binding, and then focuses on building a layer of plugin-like services that handle platform-specific utilities such as navigation and geo-location, as well as how to loosely use these services in the app with inversion of control and dependency injection. You’ll connect the app to a live web-based API and set up offline synchronization before testing the app logic through unit testing. Finally, you will learn how to add monitoring to your Xamarin.Forms projects to track crashes and analytics and gain a proactive edge on quality.What you will learn Find out how, when, and why to use architecture patterns and best practices with Xamarin.Forms Implement the Model-View-ViewModel (MVVM) pattern and data binding in Xamarin.Forms mobile apps Incorporate client-side validation in Xamarin.Forms mobile apps Extend the Xamarin.Forms navigation API with a custom ViewModel-centric navigation service Leverage the inversion of control and dependency injection patterns in Xamarin.Forms mobile apps Work with online and offline data in Xamarin.Forms mobile apps Use platform-specific APIs to build rich custom user interfaces in Xamarin.Forms mobile apps Explore how to monitor mobile app quality using Visual Studio App Center Who this book is forThis book is intended for .NET developers who are familiar with Xamarin mobile application development and the open source Xamarin.Forms toolkit. If you have already started working with Xamarin.Forms and want to take your app to the next level, making it more maintainable, testable and flexible, then this book is for you.Table of ContentsTable of Contents Getting Started MVVM and Data Binding Navigation Platform-Specific Services and Dependency Injection User Interface API Data Access Authentication Testing App Monitoring

Read more less

Book SynopsisA recent survey stated that 52% of embedded projects are late by 4-5 months. This book can help get those projects in on-time with design patterns. The author carefully takes into account the special concerns found in designing and developing embedded applications specifically concurrency, communication, speed, and memory usage. Patterns are given in UML (Unified Modeling Language) with examples including ANSI C for direct and practical application to C code. A basic C knowledge is a prerequisite for the book while UML notation and terminology is included. General C programming books do not include discussion of the contraints found within embedded system design. The practical examples give the reader an understanding of the use of UML and OO (Object Oriented) designs in a resource-limited environment. Also included are two chapters on state machines. The beauty of this book is that it can help you today. .Table of ContentsChapter 1: What Is Embedded Programming? Chapter 2: Embedded Programming with the Harmony/Embedded Development Process Chapter 3: Design Patterns for Accessing the Hardware Chapter 4: Design Patterns for Embedding Concurrency Chapter 5: Design Patterns for Embedding Distribution Chapter 6: Design Patterns for Memory Chapter 7: Design Patterns for State Machines I: Implementing State Machines Chapter 8: Design Patterns for State Machines II: Optimizing State Machines Appendix A: UML Notation

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 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 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 SynopsisIntroduction.- Packages, Interfaces and Abstract Datatypes - Locks - Semaphores - The Baton Algorithm - Universal Critical Sections - Fairness - Deadlocks - Monitors - Universal Monitors - Message Passing - Comparison of the Previous Language Constructs - Netwide Message Passing - Universal Far Monitors - Networks as Graphs - Heartbeat Algorithms - Traversing Algorithms - Leader Election Algorithms.

Read more less

Book Synopsis

Read more less

Book SynopsisBuilds a strong foundation in digital image processing, covering essential topics from basics to advanced techniques. Includes practical exercises to master Python programming and essential libraries like OpenCV and NumPy for image manipulation tasks.

Read more less

Book Synopsis

Read more less

Book SynopsisThis book takes young readers on an exciting adventure with a child named Kai. One day, Kai wakes up trapped inside a giant robot. He can't talk to anyone outside, and the only way to communicate is through the robot.Inside the robot, Kai finds many books and documents written in a strange languageit's the robot's language, which is Python. Kai realizes he needs to learn this language to control the robot and talk to the outside world. In each chapter in this book, we will join Kai on a new adventure to learn something that helps us control the robot better and communicate with the real world. This fun and interactive book is designed to introduce young minds to the basics of programming while encouraging creativity and problem-solving skills. In the introductory chapters, readers discover Python as a friendly and accessible programming language. The book guides them through setting up their programming environment and crafting their initial lines of code, laying the foundation for an exciting coding adventure. As the exploration unfolds, it delves into fundamental programming concepts essential for any budding coder. From variables and data types to loops and conditionals, these building blocks empower readers to create their programs, fostering a solid understanding of the core principles of coding. It seamlessly integrates these concepts with previously learned fundamentals, providing a comprehensive view of Python's capabilities. Fueling creativity, it inspires readers to unleash their imagination through engaging projects. From crafting games to developing useful applications, young coders learn to apply their programming skills in innovative ways, transforming abstract coding concepts into real and interactive projects. With a focus on accessibility, engagement, and real-world application, this book paves the way for the next generation of Python enthusiasts. What you will learn:Understand Python programming fundamentals, including syntax, variables, data types, loops, conditionals, lists, functions, and handling files. Learn to break down complex problems into smaller, manageable tasks and apply coding concepts to find creative solutions. How to create their interactive coding projects using Python. Understand strategies for debugging and troubleshooting common programming problems, which are essential skills for any programmerWho this book is for:This book caters primarily for high school students and individuals keen on delving into programming with minimal or zero coding background. It's structured to be both accessible and captivating for young readers, immersing them in the realm of coding through entertaining and interactive journeys. Moreover, it extends its reach to educators and coding enthusiasts alike.

Read more less

Book SynopsisSpringboard your journey into web application development and discover how much fun building web applications with Ruby on Rails can be. This book has been revised to cover what''s new in Rails 6 including features such as WebPack, advanced JavaScript integration, Action Mailbox, Action Text, system and parallel testing, Action Cable testing, and more.  Beginning Rails 6 gently guides you through designing your application, writing tests for the application, and then writing the code to make your application work as expected. It is a book that will guide you from never having programmed with Ruby, to having a Rails 6 application built and deployed to the web.   After reading and using this book, you''ll have the know-how and the freely available source code to get started with your own Rails-based web development in days.   What You Will Learn Create Ruby on Rails 6 web applications froTable of Contents1. Introducing the Rails Framework2. Getting Started3. Getting Something Running4. Introduction to the Ruby Language5. Working with a Database: Active Record6. Advanced Active Record: Enhancing Your Models7. Action Pack: Working with the View and the Controller8. Advanced Action Pack9. JavaScript and CSS10. Sending and Receiving Email11. Testing Your Application12. Internationalization13. Deploying Your Rails ApplicationsA. Databases 101B. The Rails CommunityC. Git NOTES below: for Planned Revisions for Beginning Rails 6 Chapter 1: Introducing the Rails Framework The majority of chapter 1 is still relevant, needing only minor, superficial changes. This may also be a good place to address the “is rails dead?” question. In short, no -- Rails is not dead, it’s mature. Chapter 2: Getting StartedThis chapter needs to be updated to include more recent installation instructions and screenshots for more recent versions of technologies involved. The general idea is the same, though.Chapter 3: Getting Something Running This chapter needs minor updates to:Reflect the new directory structure created by RailsReflect that Rails 6 now uses webpack instead of the asset pipelineChapter 4: Introduction to the Ruby LanguageThis chapter needs little, if any revision, as the basics of Ruby which it covers haven’t changed much.Chapter 5: Working with a Database: Active RecordThis chapter needs little, if any revision.Chapter 6: Advanced Active Record: Enhancing Your ModelsThis chapter seems like it would need only minor revisions. It is a dense chapter, though, with lots of code samples that need to be verified.Chapter 6.5: ActiveModelWe could add this chapter, showing readers how they can create objects very similar to ActiveRecord models described in the previous chapter, but which aren’t directly backed by the database. We would explain why this can be useful, and include an example of usage that fits in with the sample application being developed throughout the app.Chapter 7: Action Pack: Working with the View and the Controller Like the previous chapter, this chapter is still mostly relevant, but has a lot of code samples and screenshots which need verification and updating.Also, the following sections have some changes in Rails 6 that should be updated:“Using Form Helpers” (`form_with` was added, and is the preferred way going forward.)“Rendering a Collection of Partials” ( Rails 6 has a newer, more performant way of rendering a collection of partials which should be described)Also, a section on Caching could be added, though it’s not new, and may not be appropriate for a “Beginning” book.Chapter 7.5: ActionTextIn this chapter, we would introduce ActionText, which gives the developer a simple path for adding a WYSIWYG editor to their application. This would be a short chapter, and we would show how to add a WYSIWYG editor to the sample application.Chapter 8: Advanced Action PackThis section only needs minor updates to verify code samples are still correct, and to update screenshots. Chapter 8.5: ActiveStorageActiveStorage facilitates the attaching of files to records. (e.g., product images, downloadable pdfs, etc.) We would explain why this is useful, how to configure it, and then provide code samples for how to enhance the sample application with images for each article, or something like that.)Chapter 9: JavaScript and CSSThis chapter needs significant revision. The structure of the chapter is good, but the underlying technologies have changed significantly, and all code samples need to be replaced. Thankfully this is a relatively short chapter. Chapter 10: Sending and Receiving E-Mail The existing content is mostly still relevant. Hower, the following changes should be made:We could add a section on “Previewing Emails” (https://edgeguides.rubyonrails.org/action_mailer_basics.html#previewing-emails), a new feature which aids development of emails sent by a Rails app.We could add a small section on “Action Mailer Callbacks” The section on “Receiving E-Mail” should be updated to reflect the new “ActionMailbox” featureChapter 10.5: ActiveJobIn this chapter, we would explain the concept of background jobs, explain why they’re useful, and then provide a working sample which ties into the sample application. (Namely, as a way of sending the email developed in the previous chapter.)Chapter 11: Testing Your ApplicationThis chapter will need some more significant updates, as Rails 6 has changed some concepts and introduced new ones:“Parallel testing” is new, and should be introduced -- it can dramatically increase the speed of running the test suite“Functional Testing Your Controllers” needs to be revised to reflect new technology“System Testing” could be added to introduce readers to the concept of browser-based testingSmall sections for testing ActiveJob and ActionMailer, and ActionCable could be addedChapter 12: InternationalizationThis chapter is still mostly relevant, and would only need small revisions. Additionally, we could introduce the concept of “lazy lookup”, allowing developers to rely on convention to make their usage of internationalization keys throughout their code more concise.Chapter 12.5: ActionCableWe could add a chapter to introduce this concept to the reader, explaining how it could be used to add “real-time” functionality to their application. (The easiest to understand example is a chat system, where you want to see messages from another user as soon as they are submitted without having to refresh the page.)We could add sample code to add something like a chat system to the application, though it seems like a stretch. I may try to think of a more relevant feature to add to the sample application.Chapter 13: Deploying Your Rails Applications This short chapter is still mostly relevant, but needs minor revisions to reflect newer technologies and software versions.Appendix A: Databases This appendix needs little (or no) revision.Appendix B: The Rails CommunityThis appendix is mostly fine as-is; I would just want to make sure links are still valid, and that we’re not overlooking any new sources.Appendix C: GitThis appendix is still mostly relevant. I would just want to update links and references to version numbers, and make sure that example output and function listings are up-to-date.

Read more less

Book SynopsisUse the popular Spring Data project for data access and persistence using various Java-based APIs such as JDBC, JPA, MongoDB, and more.  This book shows how to easily incorporate data persistence and accessibility into your microservices, cloud-native applications, and monolithic enterprise applications. It also teaches you how to perform unit and performance testing of a component that accesses a database. And it walks you through an example of each type of SQL and NoSQL database covered.   After reading this book, you''ll be able to create an application that interacts with one or multiple types of databases, and conduct unit and performance testing to analyze possible problems. Source code is available on GitHub. What You''ll Learn Become familiar with the Spring Data project and its modules for data access and persistence Explore various SQL and NoSQL persistence types Uncover the persistence and domain models, and handle transaction management for SQL Migrate database changes and versioning for SQL Dive into NoSQL persistence with Redis, MongoDB, Neo4j, and Cassandra Handle reactive database programming and access with R2DBC and MongoDB Conduct unit, integration, and performance testing, and more Who This Book Is For Experienced Java software application developers; programmers with experience using the Spring framework or the Spring Boot micro framework Table of ContentsPart I - IntroductionChapter 1: Architecture of the ApplicationsChapter 2: Spring Basics and BeyondChapter 3: Spring Data and Persistence TypesPart II - SQL PersistenceChapter 4: Persistence and Domain ModelChapter 5: Transaction ManagementChapter 6: Versioning or Migrate the Changes of the DatabasePart III - NO-SQL PersistenceChapter 7: Redis key/value DatabaseChapter 8: MongoDB Document DatabaseChapter 9: Neo4j Graph DatabaseChapter 10: Cassandra wide-column DatabaseChapter 11: Reactive access w/R2DBC and MongoDBChapter 12: Unit/Integration TestingChapter 13: Performance TestingChapter 14: Best PracticesPart I - IntroductionThis part or section contains all the introduction about the basics of the Spring and the architecture of theapplication to use the persistence.Chapter 1: Architecture of the applicationsChapter Goal: In this chapter, the readers will see the different ways of structuring one application and thebest practices to organize all the things related to persistence like the use of DAO (repositories on Spring).• Small history of the methods of persistence (Plain query using the class of Java, ORM)• Different types of architectureso Layerso Hexagonal or onion• Persistence design patterso DAO (Repositories in Spring)o Data Transfer Object (DTO)Chapter 2: Spring basics and beyondChapter Goal: In this chapter, the readers will see the different ways of structuring one application and thebest practices to organize all the things related to persistence like the use of DAO (repositories on Spring).• Spring’s Architecture • Dependency Injection and Inversion of Control• Basic Application SetupChapter 3: Spring Data and different types of persistenceChapter Goal: This chapter will provide a full explanation about Spring Data, how it works and what this librarydoes behind the scenes.• How the Spring Data works• How the Repositories workso Using interfaceso Defining a custom implementationPart II - SQL persistenceThis part or section contains the information about different aspects of the persistence of databases whichhave a rigid schema. Also, the readers will see different strategies of deploying the changes on the schemas.Chapter 4: Persistence and domain modelChapter Goal: In this chapter, the readers will learn the basics about persistence and how it works behind thescenes. Also, the readers will see how to create validations in the schema like the size of the column and thedifferent types of relationship between entities.• JPA configuration using annotationso Entity, Ido Types of relationshipso Pre-update, pre-persist• Ways to define the querieso Using specificationso Define SQL• How validate the schema• Types of InherenceChapter 5: Transaction managementChapter Goal: In this chapter, the readers will learn the basics of the transactions and some concepts of ACID.• Definition of ACID• Isolation Levels• Transactional levelsChapter 6: Versioning or migrate the changes of the databaseChapter Goal: In this chapter the readers will see different tools or strategies to include the changes of thedatabases, e.g use Liquibase/Flyway, running the scripts manually, or using the auto-update of the Spring.Also, this chapter will include some mechanism to move the data from one column to another using featureflags.• Mechanism to migrate the changes• Tools to versioning the changeso Liquibaseo Flyway• Using Feature Flags to new featureso What is a Feature flag?o Benefits of use this approacho Common librariesPart III - NO-SQL persistenceIn this section the idea is to cover one example of each type of the databases NO-SQL like key/value,document, graph, and wide-column database. The idea is not to cover all more than one example of a type ofdatabase because most of them have certain operations similar.Chapter 7: Redis key/value databaseChapter Goal: In this chapter, the readers will see how to run a database and save the information using aspecific key. Also, this chapter will show the readers to create a serializer to persist data that is complex andsome best practices like persist the information in async mode.The last point is how to configure the TTL in the information that the readers persist in the database.• What is Redis and which are the benefits?• Connecting with multiples Redis• Persist synchronous or asynchronous• Object Mapping and ConversionChapter 8: MongoDB Document databaseChapter Goal: In this chapter, the readers will see how to run a mongo database and how to persist theinformation with the definition of the entities using the different operations that are permitted on MongoDB.• What is a document store?• Setting up a Mongo• Access using repositories• Manage transactions in a programmatic wayChapter 9: Neo4j Graph databaseChapter Goal: In this chapter, the readers will see how to run a database and how to create different types ofqueries. Also the reader will see the different aspects of the persistence of the information and the use ofreactive approach.• Modeling the problem as a Grapho Cases of usero Benefits• Persisting the domain• Manage transactionsChapter 10: Cassandra wide-column databaseChapter Goal: In this chapter, the readers will see how to configure the database on Spring and thedeclaration of the entities that need to be used to persist the information. Also, the different ways topersist or modify the information on Cassandra.The last point is how to configure the TTL in the information that the readers persist in the database.• What is Cassandra and how works?• Configuration for Cassandra• Access using repositories• Defining a TTLPart IV – Advanced, testing and best practicesThis part covers some aspects of any type of database to create different types of tests and validate theperformance of the queries. Also, this section covers some best practices to reduce the possible problems ormistakes in the applications that access a database.Chapter 11: Reactive accessChapter Goal: This chapter needs to cover how you can access and obtain the information in a reactive way.• What is reactive access?• Modifying queries to be reactiveo R2DBCo MongoDBChapter 12: Unit/Integration testingChapter Goal: This chapter needs to cover more in detail how you can write unit tests without using anexistent database but using the same motor of the database, to do this the reader will use Test Cointainerswith Junit 5 which is the standard to write unit tests.• Unit Testing with Mocks• Integration Testing with a Databaseo What is Test containers?o Test Containers vs embeddedo How you can use it?o Possible problems in the pipelineChapter 13: Performance testingChapter Goal: In this chapter the reader will use some tools like Gatling or QuickPerform to see how tocreate a performance test and analyze if the queries have some issue related with the use ofCPU/memory.• How check or analyze the performance of the queries?• Analyzing the complexity of queries• Performance test of an endpoint that access to a DBChapter 14: Best practicesChapter Goal: In this chapter the reader will know some strategies to improve the performance of thedatabase including some mechanism of cache to reduce the number of times that anyone accesses toobtain information. • Access to the information◦ Master-slave • Using cache to reduce the accessed to DB • Compress the information • Lazy Loading Issues • Pagination and ways to reduce the response

Read more less

Book Synopsis DESCRIPTION Functional programming is a deep and potentially mind-bending discipline. Fortunately, Java developers don't have to master every aspect of FP to get a big boost in the performance, readability, and maintainability of their applications. By learning a few core FP principles, they can write code that's less prone to side effects and unwanted dependencies and which is much better suited to the parallel processing required by modern multi-core and distributed systems. Also, because units of functional code are designed to be modular and independent, FP reduces or eliminates many of the bugs development teams routinely face when managing a large codebase. Functional Programming in Java teaches Java developers how to incorporate the most powerful benefits of functional programming into new and existing Java code. Written to meet the needs of professional Java developers who want to introduce functional programming principles into new and legacy projects, this book uses examples, exercises, and illustrations to teach core FP principles such as referential transparency, immutability, persistence, and laziness. They’ll discover which of the new functionally-inspired features of Java 8 will help in applying FP principles to code—as well as which to avoid. In the end, they’ll be able to think functionally about coding tasks in Java and use FP to make their applications easier to understand, optimize, maintain, and scale. KEY FEATURES • Increases productivity • Easy to grasp examples and illustrations • Written for professional Java developers AUDIENCE Readers need to be comfortable with Java programming. No previous experience with functional programming is required. ABOUT THE TECHNOLOGY Functional programming is gaining momentum, mainly through adoption of new languages such as Scala, Clojure or Groovy, and through the new popularity of older languages such as Haskell or Erlang. And functional programming is coming to Java 8 with the addition of features such as lambda expressions, and Streams.

Read more less

Book SynopsisDenis Magda is a database engineer and former Java platform lead known for making complex data systems approachable. With two decades of building and scaling infrastructure at Sun, Oracle, and multiple startups, Denis brings practical clarity and code-first teaching to every page. He distills his Postgres expertise into concise guidance that gets developers shipping faster and smarter. 

Read more less

Book SynopsisLearn to program with Rust 2021 Edition, in an easy, step-by-step manner on Unix, the Linux shell, macOS, and the Windows command line.  As you read this book, you''ll build on the knowledge you gained in previous chapters and see what Rust has to offer.   Beginning Rust starts with the basics of Rust, including how to name objects, control execution flow, and handle primitive types. You''ll see how to do arithmetic, allocate memory, use iterators, and handle input/output. Once you have mastered these core skills, you''ll work on handling errors and using the object-oriented features of Rust to build robust Rust applications in no time.Only a basic knowledge of programming in C or C++ and familiarity with a command console are required. After reading this book, you''ll be ready to build simple Rust applications.What You Will Learn Get started programming with Rust Understand heterogeneous data structures aTable of Contents1. Introduction2. Printing on Terminal3. Doing Arithmatic4. Naming Objects5. Controlling Execution Flow6. Using Data Sequences7. Using Primitive Types8. Enumerating Cases9. Using Heterogeneous Data Structures10. Defining Functions11. Defining Generic Functions and Structs12. Allocating Memory13. Data Implementation14. Defining Closures15. Using Changeable Strings16. Ranges and Slices17. Using Iterators18. Input/Output and Error Handling19. Using Traits20. Object-Oriented Programming21. Standard Library Collections22. Drops, Moves, and Copies23. Borrowing and Lifetimes24. More about Lifetimes

Read more less

Book SynopsisWritten as an illustrated, step-by-step guide, this book will introduce you to Python with examples using the latest version of the language.  You''ll begin by learning to set up your Python environment. The next few chapters cover the basics of Python such as language classifications, Python language syntax, and how to write a program. Next, you will learn how to work with variables, basic data types, arithmetic, companion, and Boolean operators, followed by lab exercises. Further, the book covers flow control, using functions, and exception handling, as well as the principles of object-oriented programming and building an interface design. The last section explains how to develop a game by installing PyGame and how to use basic animation, and concludes with coverage of Python web development with web servers and Python web frameworks.  The Absolute Beginners Guide to Python Programming will give you the tools, confidence, and insTable of ContentsChapter 1: What is Python.Goal: About Python, what it is, how to set up the interpreter on machineSub-topicsSetting UpChapter 2: The BasicsGoal: Covers basics, syntax, writing a basic program and executing the codeSub-topicsLanguage ClassificationLow-Level LanguageHigh-Level LanguagePython Language SyntaxReserved WordsIdentifiersIndentationCommentsInputOutputEscape CharactersWriting a ProgramChapter 3: Working with DataGoal: Covers data types: integers, lists, strings, etc, etc , variables, operatorsSub-topicsVariablesLocal VariablesGlobal VariablesBasic Data TypesIntegersFloating Point NumbersStringsListsTwo Dimensional ListsSetsTuplesDictionariesCasting Data TypesArithmetic OperatorsOperator PrecedencePerforming ArithmeticComparison OperatorsBoolean OperatorsBitwise OperatorsLab ExercisesChapter 4: Flow ControlGoal: Explains flow control, sequence, if/elif, for/whileSub-topicsSequenceSelectionif...elseelifIteration (Loops)For loopWhile loopBreak and ContinueLab ExercisesChapter 5: Handling FilesGoal: Explains file handling, reading files, writing to files, text files, binary filesFile TypesText FileBinaryText File OperationsOpen FilesWrite to a FileRead from a FileBinary File OperationsOpen FilesWrite to a FileRead a FileRandom File AccessLab ExercisesChapter 6: Using FunctionsSub-topicsDeclaring FunctionsRecursionLab ExercisesChapter 7: Exception HandlingGoal: Covers exception and error handlingSub-topicsTypes of ExceptionCatching ExceptionsRaising your Own ExceptionsChapter 8: Object Oriented ProgrammingGoal: OOP principles, classes, objects and inheritanceSub-topicsPrinciples of OOPEncapsulationInheritancePolymorphismAbstractionClasses & ObjectsClass InheritancePolymorphic ClassesMethod OverridingChapter 9: Building an InterfaceGoal: Building an interface using tkinterSub-topicsCreating a WindowAdding WidgetsMenusThe CanvasImagesButtonsMessage BoxesText FieldListboxCheckboxLabelsLabel FrameInterface DesignChapter 10: Developing a GameSub-topicsInstalling PyGameOpening a WindowAdding an ImageThe Game LoopThe Event LoopShapesBasic AnimationChapter 11: Python Web DevelopmentSub-topicsWeb ServersExecuting a ScriptPython Web FrameworksQuick ReferenceData TypesNumeric OperatorsComparison OperatorsBoolean OperatorsString OperatorsList OperatorsDictionary OperatorsString MethodsList MethodsDictionary MethodsFunctionsFilesConditionalMulti ConditionalWhile LoopFor LoopLoop ControlModulesBuilt in FunctionsDeclare a ClassChild ClassCreate ObjectCall Object Method

Read more less

Book SynopsisLearn the C++ programming language in a structured, straightforward, and friendly manner. This book teaches the basics of the modern C++ programming language, the C++ Standard Library, and modern C++ standards, including C++23. No previous programming experience is required. C++ is a language like no other, surprising in its complexity, yet wonderfully sleek and elegant in so many ways. It is also a language that cannot be learned by guessing, one that is easy to get wrong and challenging to get right. To overcome this, each section is filled with real-world examples that gradually increase in complexity. Modern C++ for Absolute Beginners, Second Edition teaches more than just programming in C++23. It provides a solid C++ foundation to build upon. The author takes you through the C++ programming language, the Standard Library, and C++11 to C++23 standard basics. Each chapter is accompanied by the right amount of Table of Contents1. Introduction2. What is C++?3. C++ Compilers4. Our First Program5. Types6. Exercises7. Operators8. Standard Input9. Exercises10. Arrays11. Pointers12. References13. Introduction to Strings 14. Automatic Type Deduction15. Exercises16. Statements17. Constants18. Exercises19. Functions20. Exercises21. Scope and Lifetime22. Exercises23. Classes - Introduction24. Exercises25. Classes – Inheritance and Polymorphism26. Exercises27. The static Specifier28. Templates29. Enumerations30. Exercises31. Organizing code32. Exercises33. Conversions34. Exceptions35. Smart Pointers36. Exercises37. Input/Output Streams38. C++ Standard Library and Friends39. Exercises40. C++ Standards41. Projects

Read more less

Book SynopsisComputer vision is constantly evolving, and this book has been updated to reflect new topics that have emerged in the field since the first edition's publication. All code used in the book has also been fully updated. This second edition features new material covering image manipulation practices, image segmentation, feature extraction, and object identification using real-life scenarios to help reinforce each concept. These topics are essential for building advanced computer vision applications, and you'll gain a thorough understanding of them. The book's source code has been updated from TensorFlow 1.x to 2.x, and includes step-by-step examples using both OpenCV and TensorFlow with Python. Upon completing this book, you'll have the knowledge and skills to build your own computer vision applications using neural networksWhat You Will LearnUnderstand image processing, manipulation techniques, and feature extractionmethodsWork with convolutional neural networks (CNN), single-shot deteTable of Contents

Read more less

Book SynopsisLearn to write algorithms and program in the new field of quantum computing. This second edition is updated to equip you with the latest knowledge and tools needed to be a complex problem-solver in this ever-evolving landscape. The book has expanded its coverage of current and future advancements and investments by IT companies in this emerging technology. Most chapters are thoroughly revised to incorporate the latest updates to IBM Quantum's systems and offerings, such as improved algorithms, integrating hardware advancements, software enhancements, bug fixes, and more. You'll examine quantum computing in the cloud and run experiments there on a real quantum device. Along the way you'll cover game theory with the Magic Square, an example of quantum pseudo-telepathy. You'll also learn to write code using QISKit, Python SDK, and other APIs such as QASM and execute it against simulators (local or remote) or a real quantum computer. Then peek inside the inner workings of the Bell states fTable of ContentsChapter 1: Quantum Fields - The Building Blocks of Reality Enter Max Planck, the Father of Quantum MechanicsPlanck Hits the Jackpot, Einstein collects a Novel PrizeQuantum Mechanics comes in many flavors. Which is your favorite?Many Worlds InterpretationSupplementary InterpretationsFrom Quantum Mechanics to Quantum Fields: Evolution or RevolutionChapter 1 ExercisesChapter 2: Richard Feynman, Demigod of Physics, Father of the Quantum ComputerMysteries of QFT: The Plague on InfinitiesFeynman Diagrams: Formulas in DisguiseAntimatter as Time Reverse Matter and the Mirror UniverseChapter 2 ExercisesChapter 3: The Qubit Revolution is at Hand Your Friendly Neighborhood Quantum ComputerLinear Optics vs Super Conducting LoopsThe Many Flavors of QubitChapter 3 ExercisesChapter 4: Enter the IBM Quantum: A One of a Kind Platform for Quantum Computing in the Cloud Getting your feet wet with IBM QuantumOpus 1: Variations on Bell and GHZ StatesRemote Access via the REST APIChapter 4 Exercises Chapter 5: Mathematical Foundation: Time to Dust up that Linear AlgebraQubit 101: Vector, Matrices and Complex NumbersEuler’s Identity: A Wonderful MasterpieceAlgebraic Representation of the QubitChanging the State of a Qubit with Quantum GatesUniversal Quantum Computation delivers shortcuts over Classical ComputationChapter 5 ExercisesChapter 6: QISKit, Awesome SDK for Quantum Programming in PythonInstalling the QISKitYour First Quantum ProgramQuantum Assembly: The Power behind the ScenesChapter 6 Exercises Chapter 7: Start Your Engines: From Quantum Random Numbers to Teleportation, pit stop at Super Dense CodingQuantum Random Number GenerationSuper Dense CodingQuantum TeleportationChapter 8: Game Theory: With Quantum Mechanics Odds Are Always in Your FavorCounterfeit Coin PuzzleMermin-Peres Magic SquareAnswers for the Mermin-Peres Magic Square ExerciseChapter 9: Faster Search Plus Threatening the Foundation of Asymmetric Cryptography with Grover and ShorQuantum Unstructured SearchInteger Factorization with Shor’s AlgorithmChapter 10: Advanced Algorithms for Quantum ChemistryWhat in an Eigenvalue and why should I careVariational Quantum EigensolverMolecule Ground State ExperimentProtein Folding Experiment

Read more less

Book SynopsisUpdated and expanded, the third edition of Photonics Rules of Thumb represents an evolving, idiosyncratic, and eclectic toolbox intended to allow any engineer, scientist, manager, marketeer, or technician (regardless of specialty) to make rapid and accurate guesses at solutions in a wide range of topics during system design, modeling, or fabrication. This book will help any electro-optics team to make quick assessments, generally requiring no more than a calculator, so that they can quickly find the right solution for a design problem.This book has been assembled to introduce anyone working in the optics and photonics community to a wide range of critical topics through simple calculations, graphics, equations, and explanations. Useful design principles and rules, simple-to-implement calculations, and numerous graphs and tables of important basic information allow you to rapidly pinpoint trouble spots, ask the right questions at meetings, and are perfect for quick checks of last-minute specifications or performance feature additions. Offering a convenient arrangement according to specialty, this unique reference spans the spectrum of photonics. Eighteen chapters cover optics, atmospherics, radiometry, focal plane arrays, degraded visual environments, economics, and photogrammetry, as well as technologies related to security and surveillance systems, infrared, lasers, electro-optics, phenomenologies, self-driving vehicles, and many others.

Read more less

Book SynopsisThis textbook is for those who want to learn linear algebra from the basics. After a brief mathematical introduction, it provides the standard curriculum of linear algebra based on an abstract linear space. It covers, among other aspects: linear mappings and their matrix representations, basis, and dimension; matrix invariants, inner products, and norms; eigenvalues and eigenvectors; and Jordan normal forms. Detailed and self-contained proofs as well as descriptions are given for all theorems, formulas, and algorithms. A unified overview of linear structures is presented by developing linear algebra from the perspective of functional analysis. Advanced topics such as function space are taken up, along with Fourier analysis, the Perron–Frobenius theorem, linear differential equations, the state transition matrix and the generalized inverse matrix, singular value decomposition, tensor products, and linear regression models. These all provide a bridge to more specialized theories based on linear algebra in mathematics, physics, engineering, economics, and social sciences. Python is used throughout the book to explain linear algebra. Learning with Python interactively, readers will naturally become accustomed to Python coding. By using Python’s libraries NumPy, Matplotlib, VPython, and SymPy, readers can easily perform large-scale matrix calculations, visualization of calculation results, and symbolic computations. All the codes in this book can be executed on both Windows and macOS and also on Raspberry Pi.Table of ContentsMathematics and Python.- Linear Spaces and Linear Mappings.- Basis and Dimension.- Matrices.- Elementary Operations and Matrix Invariants.- Inner Product and Fourier Expansion.- Eigenvalues and Eigenvectors.- Jordan Normal Form and Spectrum.- Dynamical Systems.- Applications and Development of Linear Algebra.

Read more less

Book SynopsisUnit Testing: Principles, Patterns and Practices shows you how to refine your existing unit tests by implementing modern best practices. You’ll learn to spot which tests are performing, which need refactoring, and which need to be deleted entirely! Upgrade your testing suite with new testing styles, good patterns, and reliable automated testing. Unit Testing: Principles, Practices and Patterns is a practical guide to modern unit testing best practices. Microsoft MVP Vladimir Khorikov takes you hands-on with examples of the ideal unit test and unit testing practices, building your skills step by step on a solid foundation. Key Features · A universal frame of reference by which to assess any unit test · Common anti-patterns to identify and avoid · Guidelines on how to refactor a test suite along with the · production code it covers · Using integration tests to verify the behavior of the system as a whole For readers who know the basics of unit testing and want to improve their techniques to get the best return on their efforts. Examples are in C# but apply in any language About the technology Test automation has turned unit testing into a standard practice in software development. The right unit test suite gives great outcomes and is vital to delivering quality software. Author Bio Vladimir Khorikov is an author, blogger, and Microsoft MVP. He has been developing software professionally for over ten years, and has mentored numerous teams on the ins and outs of unit testing.

Read more less

Book SynopsisThis book is designed to be used as a primary textbook in a college-level first course in computing. It takes a fairly traditional approach, emphasizing problem solving, design, and programming as the core skills of computer science. However, these ideas are illustrated using a non-traditional language, namely Python. This textbook was written with a single overarching goal: to introduce fundamental computer science concepts as simply as possible without being simplistic. Using Python is central to this goal. Traditional systems languages such as C , Ada, and Java evolved to solve problems in large-scale programming, where the primary emphasis is on structure and discipline. They were not designed to make writing small- or medium-scale programs easy. The recent rise in popularity of scripting (sometimes called “agile”) languages, such as Python, suggests an alternative approach. Python is very flexible and makes experimentation easy. Solutions to simple problems are simply and elegantly expressed. Python provides a great laboratory for the neophyte programmer. Python has a number of features that make it a near-perfect choice as a first programming language. The basic structures are simple, clean, and well designed, which allows students to focus on the primary skills of algorithmic thinking and program design without getting bogged down in arcane language details. Concepts learned in Python carry over directly to subsequent study of systems languages such as C and Java. But Python is not a “toy language.” It is a real-world production language that is freely available for virtually every programming platform and comes standard with its own easy-to-use integrated programming environment. The best part is that Python makes learning to program fun again.New to the Third EditionThe third edition continues the tradition of updating the text to reflect new technologies while maintaining a time-tested approach to teaching introductory computer science. An important change to this edition is the removal of most uses of eval and the addition of a discussion of its dangers. In our increasingly connected world, it’s never too early to begin considering computer security issues. Several new graphics examples, developed throughout chapters 4–12, have been added to introduce new features of the graphics library that support animations, including simple video game development. This brings the text up to date with the types of final projects that are often assigned in modern introductory classes. Smaller changes have been made throughout the text, including: Material on file dialogs has been added in Chapter 5. Chapter 6 has been expanded and reorganized to emphasize value-returning functions. Coverage has been streamlined and simplified to use IDLE (the standard “comes-with-Python” development environment) consistently. This makes the text more suitable for self-study as well as for use as a classroom textbook. Technology references have been updated. To further accommodate self-studiers, end-of-chapter solutions for this third edition will be freely available online. Classroom instructors wishing to use alternative exercises can request those from the publisher. Self-studiers and instructors alike will be able to visit this website to download the solutions.

Read more less

Book SynopsisSuitable for C programmers, this book takes them through the entire development cycle of a C program - designing and developing the program, writing source code, compiling the code, linking the code to create the executable programs, debugging, and deployment.Table of ContentsIntroduction. Book I: Hello, C. Chapter 1: Your Basic C Program. Chapter 2: How It All Works. Chapter 3: More Basics, Comments, and Errors. Chapter 4: Introducing Numbers and Variables. Chapter 5: More Variables and Basic I/O. Chapter 6: Decision Time. Chapter 7: Looping. Chapter 8: Using Constants. Chapter 9: Mysterious Math. Chapter 10: It’s Only Logical. Book II: Middle C. Chapter 1: Variables from Beyond Infinity. Chapter 2: The Madness of Printf( ). Chapter 3: Maniacal Math Functions. Chapter 4: Not Truly Random. Chapter 5: While Going Loopy. Chapter 6: More Decision Making. Chapter 7: The Goto Chapter. Book III: Above C Level. Chapter 1: Asking for Arrays. Chapter 2: I Sing of Strings. Chapter 3: Messing with Characters. Chapter 4: Stinkin’ Structures. Chapter 5: Creating Your Own Functions. Chapter 6: Quitting Before You’re Done. Chapter 7: More Variable Nonsense. Book IV: Advanced C. Chapter 1: Introduction to Evil Pointers. Chapter 2: Getting to the *Point. Chapter 3: Binary Bits. Chapter 4: The Myth of the Array. Chapter 5: Pointers and Strings. Chapter 6: Crazy Arrays of Pointers. Chapter 7: Functions and Pointers. Chapter 8: Structures, Pointers, and the Malloc Deity. Chapter 9: Does Anyone Have the Time? Chapter 10: Building Big Programs. Chapter 11: Help! Book V: Disk Drive C. Chapter 1: Just Your Standard I/O. Chapter 2: Interacting with the Command Line. Chapter 3: Hello, Disk! Chapter 4: More Formal File Writing and Reading. Chapter 5: Random Access Files. Chapter 6: Folder Folderol. Chapter 7: Under New File Management. Book VI: The Joy of Linked Lists. Chapter 1: Why Linked Lists? Chapter 2: Dawn of the Database. Chapter 3: Storing a Linked List on Disk. Chapter 4: The Nightmare of the Double-Linked List. Book VII: Appendixes. Appendix A: The Stuff You Need to Know before Reading Everything Else in This Book. Appendix B: ASCII Table. Appendix C: Answers to Exercises. Appendix D: C Language Keywords and Operators. Appendix E: C Language Variable Types. Appendix F: Escape Sequences. Appendix G: Conversion Characters. Index.

Read more less

Book SynopsisDescription With Kubernetes, users don't have to worry about which specific machine in their data center their application is running on. Each layer in their application is decoupled from other layers so they can scale, update, and maintain them independently. Kubernetes in Action teaches developers how to use Kubernetes to deploy self-healing scalable distributed applications. By the end, readers will be able to build and deploy applications in a proper way to take full advantage of the Kubernetes platform. Key features • Easy to follow guide • Hands-on examples • Clearly-written Audience The book is for both application developers as well as system administrators who want to learn about Kubernetes from the developer’s perspective. About the Technology Kubernetes abstracts away the hardware infrastructure and exposes your whole datacenter as a single enormous computational resource.

Read more less

Book SynopsisDaniel Chen is a graduate student in the Interdisciplinary PhD program in Genetics, Bioinformatics & Computational Biology (GBCB) at Virginia Polytechnic Institute and State University (Virginia Tech). He is involved with Software Carpentry as an instructor, Mentoring Committee Member, and currently serves as the Assessment Committee Chair. He completed his Masters in Public Health at Columbia University Mailman School of Public Health in Epidemiology with a certificate in Advanced Epidemiology and currently extending his Master's thesis work in the Social and Decision Analytics Laboratory under the Virginia Bioinformatics Institute on attitude diffusion in social networks.Table of ContentsForeword by Anne M. Brown xxiii Foreword by Jared Lander xxv Preface xxvii Changes in the Second Edition xxxix Part I: Introduction 1 Chapter 1. Pandas DataFrame Basics 3 Learning Objectives 3 1.1 Introduction 3 1.2 Load Your First Data Set 4 1.3 Look at Columns, Rows, and Cells 6 1.4 Grouped and Aggregated Calculations 23 1.5 Basic Plot 27 Conclusion 28 Chapter 2. Pandas Data Structures Basics 31 Learning Objectives 31 2.1 Create Your Own Data 31 2.2 The Series 33 2.3 The DataFrame 42 2.4 Making Changes to Series and DataFrames 45 2.5 Exporting and Importing Data 52 Conclusion 63 Chapter 3. Plotting Basics 65 Learning Objectives 65 3.1 Why Visualize Data? 65 3.2 Matplotlib Basics 66 3.3 Statistical Graphics Using matplotlib 72 3.4 Seaborn 78 3.5 Pandas Plotting Method 111 Conclusion 115 Chapter 4. Tidy Data 117 Learning Objectives 117 Note About This Chapter 117 4.1 Columns Contain Values, Not Variables 118 4.2 Columns Contain Multiple Variables 122 4.3 Variables in Both Rows and Columns 126 Conclusion 129 Chapter 5. Apply Functions 131 Learning Objectives 131 Note About This Chapter 131 5.1 Primer on Functions 131 5.2 Apply (Basics) 133 5.3 Vectorized Functions 138 5.4 Lambda Functions (Anonymous Functions) 141 Conclusion 142 Part II: Data Processing 143 Chapter 6. Data Assembly 145 Learning Objectives 145 6.1 Combine Data Sets 145 6.2 Concatenation 146 6.3 Observational Units Across Multiple Tables 154 6.4 Merge Multiple Data Sets 160 Conclusion 167 Chapter 7. Data Normalization 169 Learning Objectives 169 7.1 Multiple Observational Units in a Table (Normalization) 169 Conclusion 173 Chapter 8. Groupby Operations: Split-Apply-Combine 175 Learning Objectives 175 8.1 Aggregate 176 8.2 Transform 184 8.3 Filter 188 8.4 The pandas.core.groupby.DataFrameGroupBy object 190 8.5 Working with a MultiIndex 195 Conclusion 199 Part III: Data Types 203 Chapter 9. Missing Data 203 Learning Objectives 203 9.1 What Is a NaN Value? 203 9.2 Where Do Missing Values Come From? 205 9.3 Working with Missing Data 210 9.4 Pandas Built-In NA Missing 216 Conclusion 218 Chapter 10. Data Types 219 Learning Objectives 219 10.1 Data Types 219 10.2 Converting Types 220 10.3 Categorical Data 225 Conclusion 227 Chapter 11. Strings and Text Data 229 Introduction 229 Learning Objectives 229 11.1 Strings 229 11.2 String Methods 233 11.3 More String Methods 234 11.4 String Formatting (F-Strings) 236 11.5 Regular Expressions (RegEx) 239 11.6 The regex Library 247 Conclusion 247 Chapter 12. Dates and Times 249 Learning Objectives 249 12.1 Python's datetime Object 249 12.2 Converting to datetime 250 12.3 Loading Data That Include Dates 253 12.4 Extracting Date Components 254 12.5 Date Calculations and Timedeltas 257 12.6 Datetime Methods 259 12.7 Getting Stock Data 261 12.8 Subsetting Data Based on Dates 263 12.9 Date Ranges 266 12.10 Shifting Values 270 12.11 Resampling 276 12.12 Time Zones 278 12.13 Arrow for Better Dates and Times 280 Conclusion 280 Part IV: Data Modeling 281 Chapter 13. Linear Regression (Continuous Outcome Variable) 283 13.1 Simple Linear Regression 283 13.2 Multiple Regression 287 13.3 Models with Categorical Variables 289 13.4 One-Hot Encoding in scikit-learn with Transformer Pipelines 294 Conclusion 296 Chapter 14. Generalized Linear Models 297 About This Chapter 297 14.1 Logistic Regression (Binary Outcome Variable) 297 14.2 Poisson Regression (Count Outcome Variable) 304 14.3 More Generalized Linear Models 308 Conclusion 309 Chapter 15. Survival Analysis 311 15.1 Survival Data 311 15.2 Kaplan Meier Curves 312 15.3 Cox Proportional Hazard Model 314 Conclusion 317 Chapter 16. Model Diagnostics 319 16.1 Residuals 319 16.2 Comparing Multiple Models 324 16.3 k-Fold Cross-Validation 329 Conclusion 334 Chapter 17. Regularization 335 17.1 Why Regularize? 335 17.2 LASSO Regression 337 17.3 Ridge Regression 338 17.4 Elastic Net 340 17.5 Cross-Validation 341 Conclusion 343 Chapter 18. Clustering 345 18.1 k-Means 345 18.2 Hierarchical Clustering 351 Conclusion 356 Part V. Conclusion 357 Chapter 19. Life Outside of Pandas 359 19.1 The (Scientific) Computing Stack 359 19.2 Performance 360 19.3 Dask 360 19.4 Siuba 360 19.5 Ibis 361 19.6 Polars 361 19.7 PyJanitor 361 19.8 Pandera 361 19.9 Machine Learning 361 19.10 Publishing 362 19.11 Dashboards 362 Conclusion 362 Chapter 20. It's Dangerous To Go Alone! 363 20.1 Local Meetups 363 20.2 Conferences 363 20.3 The Carpentries 364 20.4 Podcasts 364 20.5 Other Resources 365 Conclusion 365 Appendices 367 A. Concept Maps 369B. Installation and Setup 373C. Command Line 377D. Project Templates 379E. Using Python 381F. Working Directories 383G. Environments 385H. Install Packages 389I. Importing Libraries 391J. Code Style 393K. Containers: Lists, Tuples, and Dictionaries 395L. Slice Values 399M. Loops 401N. Comprehensions 403O. Functions 405P. Ranges and Generators 409Q. Multiple Assignment 413R. Numpy ndarray 415S. Classes 417T. SettingWithCopyWarning 419U. Method Chaining 423V. Timing Code 427W. String Formatting 429X. Conditionals (if-elif-else) 433Y. New York ACS Logistic Regression Example 435Z. Replicating Results in R 443 Index 451

Read more less

Book Synopsis

Read more less

Book SynopsisIf you’re developing server-side JavaScript applications, you need Node.js! Start with the basics of the Node.js environment: installation, application structure, and modules. Then follow detailed code examples to learn about web development using frameworks like Express and Nest.js.

Read more less

Book SynopsisPush the limits of what C - and you - can do, with this high-intensity guide to the most advanced capabilities of CKey Features Make the most of C’s low-level control, flexibility, and high performance A comprehensive guide to C’s most powerful and challenging features A thought-provoking guide packed with hands-on exercises and examples Book DescriptionThere’s a lot more to C than knowing the language syntax. The industry looks for developers with a rigorous, scientific understanding of the principles and practices. Extreme C will teach you to use C’s advanced low-level power to write effective, efficient systems. This intensive, practical guide will help you become an expert C programmer.Building on your existing C knowledge, you will master preprocessor directives, macros, conditional compilation, pointers, and much more. You will gain new insight into algorithm design, functions, and structures. You will discover how C helps you squeeze maximum performance out of critical, resource-constrained applications.C still plays a critical role in 21st-century programming, remaining the core language for precision engineering, aviations, space research, and more. This book shows how C works with Unix, how to implement OO principles in C, and fully covers multi-processing.In Extreme C, Amini encourages you to think, question, apply, and experiment for yourself. The book is essential for anybody who wants to take their C to the next level.What you will learn Build advanced C knowledge on strong foundations, rooted in first principles Understand memory structures and compilation pipeline and how they work, and how to make most out of them Apply object-oriented design principles to your procedural C code Write low-level code that’s close to the hardware and squeezes maximum performance out of a computer system Master concurrency, multithreading, multi-processing, and integration with other languages Unit Testing and debugging, build systems, and inter-process communication for C programming Who this book is forExtreme C is for C programmers who want to dig deep into the language and its capabilities. It will help you make the most of the low-level control C gives you.Table of ContentsTable of Contents Essential Features From Source to Binary Object Files Process Memory Structure Stack and Heap OOP and Encapsulation Composition and Aggregation Inheritance and Polymorphism Abstraction and OOP in C++ Unix: History and Architecture System Calls and Kernels The Most Recent C Concurrency Synchronization Thread Execution Thread Synchronization Process Execution Process Synchronization Single-Host IPC and Sockets Socket Programming Integration with Other Languages Unit Testing and Debugging Build Systems

Read more less

Book SynopsisDavid Vandevoorde started programming C++ in the late 1980s. After obtaining a PhD from the Rensselaer Polytechnic Institute, he became technical lead of Hewlett-Packard's C++ compiler team. In 1999 he joined the Edison Design Group (EDG), whose C++ compiler technology is widely recognized as the industry's most advanced. He is an active member of the C++ Standard Committee and a moderator of the newsgroup comp.lang.c++.moderated (which he co-founded). He is the author of C++ Solutions, the companion to The C++ Programming Language, 3rd Edition. Nicolai M. Josuttis is well known for his best-selling de-facto standard bookThe C++ Standard Library - A Tutorial and Reference. He is an independent technical consultant who designs object-oriented software for the telecommunications, traffic, finance, and manufacturing industries. He is an active member of the C++ Standard Committee and a partner at System Bauhaus, a GermTable of ContentsPreface xxiii Acknowledgments for the Second Edition xxv Acknowledgments for the First Edition xxvii About This Book xxix Part I: The Basics 1 Chapter 1: Function Templates 3 1.1 A First Look at Function Templates 3 1.2 Template Argument Deduction 7 1.3 Multiple Template Parameters 9 1.4 Default Template Arguments 13 1.5 Overloading Function Templates 15 1.6 But, Shouldn’t We . . . ? 20 1.7 Summary 21 Chapter 2: Class Templates 23 2.1 Implementation of Class Template Stack 23 2.2 Use of Class Template Stack 27 2.3 Partial Usage of Class Templates 29 2.4 Friends 30 2.5 Specializations of Class Templates 31 2.6 Partial Specialization 33 2.7 Default Class Template Arguments 36 2.8 Type Aliases38 2.9 Class Template Argument Deduction 40 2.10 Templatized Aggregates 43 2.11 Summary 44 Chapter 3: Nontype Template Parameters 45 3.1 Nontype Class Template Parameters 45 3.2 Nontype Function Template Parameters 48 3.3 Restrictions for Nontype Template Parameters 49 3.4 Template Parameter Type auto 50 3.5 Summary 54 Chapter 4: Variadic Templates 55 4.1 Variadic Templates 55 4.2 Fold Expressions 58 4.3 Application of Variadic Templates 60 4.4 Variadic Class Templates and Variadic Expressions 61 4.5 Summary 66 Chapter 5: Tricky Basics 67 5.1 Keyword typename 67 5.2 Zero Initialization 68 5.3 Using this-> 70 5.4 Templates for Raw Arrays and String Literals 71 5.5 Member Templates 74 5.6 Variable Templates 80 5.7 Template Template Parameters 83 5.8 Summary 89 Chapter 6: Move Semantics and enable_if<> 91 6.1 Perfect Forwarding 91 6.2 Special Member Function Templates 95 6.3 Disable Templates with enable_if<> 98 6.4 Using enable_if<> 99 6.5 Using Concepts to Simplify enable_if<> Expressions 103 6.6 Summary 104 Chapter 7: By Value or by Reference? 105 7.1 Passing by Value 106 7.2 Passing by Reference 108 7.3 Using std::ref() and std::cref() 112 7.4 Dealing with String Literals and Raw Arrays 115 7.5 Dealing with Return Values 117 7.6 Recommended Template Parameter Declarations 118 7.7 Summary 121 Chapter 8: Compile-Time Programming 123 8.1 Template Metaprogramming 123 8.2 Computing with constexpr 125 8.3 Execution Path Selection with Partial Specialization 127 8.4 SFINAE (Substitution Failure Is Not An Error) 129 8.5 Compile-Time if 134 8.6 Summary 135 Chapter 9: Using Templates in Practice 137 9.1 The Inclusion Model 137 9.2 Templates and inline 140 9.3 Precompiled Headers 141 9.4 Decoding the Error Novel 143 9.5 Afternotes 149 9.6 Summary 150 Chapter 10: Basic Template Terminology 151 10.1 “Class Template” or “Template Class”? 151 10.2 Substitution, Instantiation, and Specialization 152 10.3 Declarations versus Definitions 153 10.4 The One-Definition Rule 154 10.5 Template Arguments versus Template Parameters 155 10.6 Summary 156 Chapter 11: Generic Libraries 157 11.1 Callables 157 11.2 Other Utilities to Implement Generic Libraries 164 11.3 Perfect Forwarding Temporaries 167 11.4 References as Template Parameters 167 11.5 Defer Evaluations 171 11.6 Things to Consider When Writing Generic Libraries 172 11.7 Summary 173 Part II: Templates in Depth 175 Chapter 12: Fundamentals in Depth 177 12.1 Parameterized Declarations 177 12.2 Template Parameters 185 12.3 Template Arguments 192 12.4 Variadic Templates 200 12.5 Friends 209 12.6 Afternotes 213 Chapter 13: Names in Templates 215 13.1 Name Taxonomy 215 13.2 Looking Up Names 217 13.3 Parsing Templates 224 13.4 Inheritance and Class Templates 236 13.5 Afternotes 240 Chapter 14: Instantiation 243 14.1 On-Demand Instantiation 243 14.2 Lazy Instantiation 245 14.3 The C++ Instantiation Model 249 14.4 Implementation Schemes 255 14.5 Explicit Instantiation 260 14.6 Compile-Time if Statements 263 14.7 In the Standard Library 265 14.8 Afternotes 266 Chapter 15: Template Argument Deduction 269 15.1 The Deduction Process 269 15.2 Deduced Contexts 271 15.3 Special Deduction Situations 273 15.4 Initializer Lists 274 15.5 Parameter Packs 275 15.6 Rvalue References 277 15.7 SFINAE (Substitution Failure Is Not An Error) 284 15.8 Limitations of Deduction 286 15.9 Explicit Function Template Arguments 291 15.10 Deduction from Initializers and Expressions 293 15.11 Alias Templates 312 15.12 Class Template Argument Deduction 313 15.13 Afternotes 321 Chapter 16: Specialization and Overloading 323 16.1 When “Generic Code” Doesn’t Quite Cut It 323 16.2 Overloading Function Templates 326 16.3 Explicit Specialization 338 16.4 Partial Class Template Specialization 347 16.5 Partial Variable Template Specialization 351 16.6 Afternotes 352 Chapter 17: Future Directions 353 17.1 Relaxed typename Rules 354 17.2 Generalized Nontype Template Parameters 354 17.3 Partial Specialization of Function Templates 356 17.4 Named Template Arguments 358 17.5 Overloaded Class Templates 359 17.6 Deduction for Nonfinal Pack Expansions 360 17.7 Regularization of void 361 17.8 Type Checking for Templates 361 17.9 Reflective Metaprogramming 363 17.10 Pack Facilities 365 17.11 Modules 366 Part III: Templates and Design 367 Chapter 18: The Polymorphic Power of Templates 369 18.1 Dynamic Polymorphism 369 18.2 Static Polymorphism 372 18.3 Dynamic versus Static Polymorphism 375 18.4 Using Concepts 377 18.5 New Forms of Design Patterns 379 18.6 Generic Programming 380 18.7 Afternotes 383 Chapter 19: Implementing Traits 385 19.1 An Example: Accumulating a Sequence 385 19.2 Traits versus Policies and Policy Classes 394 19.3 Type Functions 401 19.4 SFINAE-Based Traits 416 19.5 IsConvertibleT 428 19.6 Detecting Members 431 19.7 Other Traits Techniques 440 19.8 Type Classification 448 19.9 Policy Traits 458 19.10 In the Standard Library 461 19.11 Afternotes 462 Chapter 20: Overloading on Type Properties 465 20.1 Algorithm Specialization 465 20.2 Tag Dispatching 467 20.3 Enabling/Disabling Function Templates 469 20.4 Class Specialization 477 20.5 Instantiation-Safe Templates 482 20.6 In the Standard Library 487 20.7 Afternotes 488 Chapter 21: Templates and Inheritance 489 21.1 The Empty Base Class Optimization (EBCO) 489 21.2 The Curiously Recurring Template Pattern (CRTP) 495 21.3 Mixins 508 21.4 Named Template Arguments 512 21.5 Afternotes 515 Chapter 22: Bridging Static and Dynamic Polymorphism 517 22.1 Function Objects, Pointers, and std::function<> 517 22.2 Generalized Function Pointers 519 22.3 Bridge Interface 522 22.4 Type Erasure 523 22.5 Optional Bridging 525 22.6 Performance Considerations 527 22.7 Afternotes 528 Chapter 23: Metaprogramming 529 23.1 The State of Modern C++ Metaprogramming 529 23.2 The Dimensions of Reflective Metaprogramming 537 23.3 The Cost of Recursive Instantiation 539 23.4 Computational Completeness 542 23.5 Recursive Instantiation versus Recursive Template Arguments 542 23.6 Enumeration Values versus Static Constants 543 23.7 Afternotes 545 Chapter 24: Typelists 549 24.1 Anatomy of a Typelist 549 24.2 Typelist Algorithms 551 24.3 Nontype Typelists 566 24.4 Optimizing Algorithms with Pack Expansions 569 24.5 Cons-style Typelists 571 24.6 Afternotes 573 Chapter 25: Tuples 575 25.1 Basic Tuple Design 576 25.2 Basic Tuple Operations 579 25.3 Tuple Algorithms 581 25.4 Expanding Tuples 592 25.5 Optimizing Tuple 593 25.6 Tuple Subscript 599 25.7 Afternotes 601 Chapter 26: Discriminated Unions 603 26.1 Storage 604 26.2 Design 606 26.3 Value Query and Extraction 610 26.4 Element Initialization, Assignment and Destruction 611 26.5 Visitors 617 26.6 Variant Initialization and Assignment 624 26.7 Afternotes 628 Chapter 27: Expression Templates 629 27.1 Temporaries and Split Loops 630 27.2 Encoding Expressions in Template Arguments 635 27.3 Performance and Limitations of Expression Templates 646 27.4 Afternotes 647 Chapter 28: Debugging Templates 651 28.1 Shallow Instantiation 652 28.2 Static Assertions 654 28.3 Archetypes 655 28.4 Tracers 657 28.5 Oracles 662 28.6 Afternotes 662 Appendixes 663 Appendix A: The One-Definition Rule 663 A.1 Translation Units 663 A.2 Declarations and Definitions 664 A.3 The One-Definition Rule in Detail 665 Appendix B: Value Categories 673 B.1 Traditional Lvalues and Rvalues 673 B.2 Value Categories Since C++11 674 B.3 Checking Value Categories with decltype 678 B.4 Reference Types 679 Appendix C: Overload Resolution 681 C.1 When Does Overload Resolution Kick In? 681 C.2 Simplified Overload Resolution 682 C.3 Overloading Details 688 Appendix D: Standard Type Utilities 697 D.1 Using Type Traits 697 D.2 Primary and Composite Type Categories 702 D.3 Type Properties and Operations 709 D.4 Type Construction 728 D.5 Other Traits 732 D.6 Combining Type Traits 734 D.7 Other Utilities 737 Appendix E: Concepts 739 E.1 Using Concepts 739 E.2 Defining Concepts 742 E.3 Overloading on Constraints 743 E.4 Concept Tips 746 Bibliography 749 Glossary 759 Index 771

Read more less

Book SynopsisWrite code that can adapt to changes. By applying this book’s principles, you can create code that accommodates new requirements and unforeseen scenarios without significant rewrites. Gary McLean Hall describes Agile best practices, principles, and patterns for designing and writing code that can evolve more quickly and easily, with fewer errors, because it doesn’t impede change. Now revised, updated, and expanded, Adaptive Code, Second Edition adds indispensable practical insights on Kanban, dependency inversion, and creating reusable abstractions. Drawing on over a decade of Agile consulting and development experience, McLean Hall has updated his best-seller with deeper coverage of unit testing, refactoring, pure dependency injection, and more. Master powerful new ways to: • Write code that enables and complements Scrum, Kanban, or any other Agile framework • Develop code that can survive major changes in requirements • Plan for adaptability by using dependencies, layering, interfaces, and design patterns • Perform unit testing and refactoring in tandem, gaining more value from both • Use the “golden master” technique to make legacy code adaptive • Build SOLID code with single-responsibility, open/closed, and Liskov substitution principles • Create smaller interfaces to support more-diverse client and architectural needs • Leverage dependency injection best practices to improve code adaptability • Apply dependency inversion with the Stairway pattern, and avoid related anti-patterns About You This book is for programmers of all skill levels seeking more-practical insight into design patterns, SOLID principles, unit testing, refactoring, and related topics. Most readers will have programmed in C#, Java, C++, or similar object-oriented languages, and will be familiar with core procedural programming techniques.Table of Contents Chapter 1 Introduction to Scrum Chapter 2 Introduction to Kanban Chapter 3 Dependencies and layering Chapter 4 Interfaces and design patterns Chapter 5 Testing Chapter 6 Refactoring Chapter 7 The single responsibility principle Chapter 8 The open/closed principle Chapter 9 The Liskov substitution principle Chapter 10 Interface segregation Chapter 11 Dependency inversion Chapter 12 Dependency injection Chapter 13 Coupling, cohesion, and connascence

Read more less

Book SynopsisThe Elixir language blends the battle-tested power and stability of the Erlang virtual machine with an approachable and expressive syntax. Elixir in Action, Second Edition teaches you how to use the Elixir programming language to solve the practical problems of scalability, fault tolerance, and high availability. This new edition is fully updated to cover Elixir 1.6 with new and improved code examples. Key Features · Fully updated · Practical introduction to Elixir · Functional and concurrent programming idioms · Mastering the OTP framework Audience Requires no previous experience with Elixir, Erlang, or OTP. Written for readers who are familiar with another programming language like Ruby, JavaScript, or C#. Author Bio Saša Jurić is a developer with extensive experience using Elixir and Erlang in complex server-side systems.

Read more less

Book SynopsisThis book takes a deep dive into the use of text within SVG to explore the creative possibilities as well as the potential pitfalls. You'll start with SVG's text basics, and then learn methods for using SVG to generate complex layouts.

Read more less

Book SynopsisWith this practical book, you'll learn 10 easy-to-follow guidelines for delivering C# software that's easy to maintain and adapt. These guidelines have been derived from analyzing hundreds of real-world systems.

Read more less

Book SynopsisJared P. Lander is the owner of Lander Analytics, a statistical consulting firm based in New York City, the organizer of the New York Open Statistical Programming Meetup and an adjunct professor of statistics at Columbia University. He is also a tour guide for Scott's Pizza Tours and an advisor to Brewla Bars, a gourmet ice pop startup. With an M.A. from Columbia University in statistics and a B.A. from Muhlenberg College in mathematics, he has experience in both academic research and industry. His work for both large and small organizations spans politics, tech startups, fund raising, music, finance, healthcare, and humanitarian relief efforts. He specializes in data management, multilevel models, machine learning, generalized linear models, visualization, data management, and statistical computing.Table of Contents Foreword xv Preface xvii Acknowledgments xxi About the Author xxv Chapter 1: Getting R 1 1.1 Downloading R 1 1.2 R Version 2 1.3 32-bit vs. 64-bit 2 1.4 Installing 2 1.5 Microsoft R Open 14 1.6 Conclusion 14 Chapter 2: The R Environment 15 2.1 Command Line Interface 16 2.2 RStudio 17 2.3 Microsoft Visual Studio 31 2.4 Conclusion 31 Chapter 3: R Packages 33 3.1 Installing Packages 33 3.2 Loading Packages 36 3.3 Building a Package 37 3.4 Conclusion 37 Chapter 4: Basics of R 39 4.1 Basic Math 39 4.2 Variables 40 4.3 Data Types 42 4.4 Vectors 47 4.5 Calling Functions 52 4.6 Function Documentation 52 4.7 Missing Data 53 4.8 Pipes 54 4.9 Conclusion 55 Chapter 5: Advanced Data Structures 57 5.1 data.frames 57 5.2 Lists 64 5.3 Matrices 70 5.4 Arrays 73 5.5 Conclusion 74 Chapter 6: Reading Data into R 75 6.1 Reading CSVs 75 6.2 Excel Data 79 6.3 Reading from Databases 81 6.4 Data from Other Statistical Tools 84 6.5 R Binary Files 85 6.6 Data Included with R 87 6.7 Extract Data from Web Sites 88 6.8 Reading JSON Data 90 6.9 Conclusion 92 Chapter 7: Statistical Graphics 93 7.1 Base Graphics 93 7.2 ggplot2 96 7.3 Conclusion 110 Chapter 8: Writing R functions 111 8.1 Hello, World! 111 8.2 Function Arguments 112 8.3 Return Values 114 8.4 do.call 115 8.5 Conclusion 116 Chapter 9: Control Statements 117 9.1 if and else 117 9.2 switch 120 9.3 ifelse 121 9.4 Compound Tests 123 9.5 Conclusion 123 Chapter 10: Loops, the Un-R Way to Iterate 125 10.1 for Loops 125 10.2 while Loops 127 10.3 Controlling Loops 127 10.4 Conclusion 128 Chapter 11: Group Manipulation 129 11.1 Apply Family 129 11.2 aggregate 132 11.3 plyr 136 11.4 data.table 140 11.5 Conclusion 150 Chapter 12: Faster Group Manipulation with dplyr 151 12.1 Pipes 151 12.2 tbl 152 12.3 select 153 12.4 filter 161 12.5 slice 167 12.6 mutate 168 12.7 summarize 171 12.8 group_by 172 12.9 arrange 173 12.10 do 174 12.11 dplyr with Databases 176 12.12 Conclusion 178 Chapter 13: Iterating with purrr 179 13.1 map 179 13.2 map with Specified Types 181 13.3 Iterating over a data.frame 186 13.4 map with Multiple Inputs 187 13.5 Conclusion 188 Chapter 14: Data Reshaping 189 14.1 cbind and rbind 189 14.2 Joins 190 14.3 reshape2 197 14.4 Conclusion 200 Chapter 15: Reshaping Data in the Tidyverse 201 15.1 Binding Rows and Columns 201 15.2 Joins with dplyr 202 15.3 Converting Data Formats 207 15.4 Conclusion 210 Chapter 16: Manipulating Strings 211 16.1 paste 211 16.2 sprintf 212 16.3 Extracting Text 213 16.4 Regular Expressions 217 16.5 Conclusion 224 Chapter 17: Probability Distributions 225 17.1 Normal Distribution 225 17.2 Binomial Distribution 230 17.3 Poisson Distribution 235 17.4 Other Distributions 238 17.5 Conclusion 240 Chapter 18: Basic Statistics 241 18.1 Summary Statistics 241 18.2 Correlation and Covariance 244 18.3 T-Tests 252 18.4 ANOVA 260 18.5 Conclusion 263 Chapter 19: Linear Models 265 19.1 Simple Linear Regression 265 19.2 Multiple Regression 270 19.3 Conclusion 287 Chapter 20: Generalized Linear Models 289 20.1 Logistic Regression 289 20.2 Poisson Regression 293 20.3 Other Generalized Linear Models 297 20.4 Survival Analysis 297 20.5 Conclusion 302 Chapter 21: Model Diagnostics 303 21.1 Residuals 303 21.2 Comparing Models 309 21.3 Cross-Validation 313 21.4 Bootstrap 318 21.5 Stepwise Variable Selection 321 21.6 Conclusion 324 Chapter 22: Regularization and Shrinkage 325 22.1 Elastic Net 325 22.2 Bayesian Shrinkage 342 22.3 Conclusion 346 Chapter 23: Nonlinear Models 347 23.1 Nonlinear Least Squares 347 23.2 Splines 350 23.3 Generalized Additive Models 353 23.4 Decision Trees 359 23.5 Boosted Trees 361 23.6 Random Forests 364 23.7 Conclusion 366 Chapter 24: Time Series and Autocorrelation 367 24.1 Autoregressive Moving Average 367 24.2 VAR 374 24.3 GARCH 379 24.4 Conclusion 388 Chapter 25: Clustering 389 25.1 K-means 389 25.2 PAM 397 25.3 Hierarchical Clustering 403 25.4 Conclusion 407 Chapter 26: Model Fitting with Caret 409 26.1 Caret Basics 409 26.2 Caret Options 409 26.3 Tuning a Boosted Tree 411 26.4 Conclusion 415 Chapter 27: Reproducibility and Reports with knitr 417 27.1 Installing a LaTeX Program 417 27.2 LaTeX Primer 418 27.3 Using knitr with LaTeX 420 27.4 Conclusion 426 Chapter 28: Rich Documents with RMarkdown 427 28.1 Document Compilation 427 28.2 Document Header 427 28.3 Markdown Primer 429 28.4 Markdown Code Chunks 430 28.5 htmlwidgets 432 28.6 RMarkdown Slideshows 444 28.7 Conclusion 446 Chapter 29: Interactive Dashboards with Shiny 447 29.1 Shiny in RMarkdown 447 29.2 Reactive Expressions in Shiny 452 29.3 Server and UI 454 29.4 Conclusion 463 Chapter 30: Building R Packages 465 30.1 Folder Structure 465 30.2 Package Files 465 30.3 Package Documentation 472 30.4 Tests 475 30.5 Checking, Building and Installing 477 30.6 Submitting to CRAN 479 30.7 C++ Code 479 30.8 Conclusion 484 Appendix A: Real-Life Resources 485 A.1 Meetups 485 A.2 Stack Overflow 486 A.3 Twitter 487 A.4 Conferences 487 A.5 Web Sites 488 A.6 Documents 488 A.7 Books 488 A.8 Conclusion 489 Appendix B: Glossary 491 List of Figures 507 List of Tables 513 General Index 515 Index of Functions 521 Index of Packages 527 Index of People 529 Data Index 531

Read more less

Book Synopsis

Read more less

Book SynopsisMark Allen Weiss is Professor and Associate Director for the School of Computing and Information Sciences at Florida International University. He is also currently serving as both Director of Undergraduate Studies and Director of Graduate Studies. He received his Bachelor's Degree in Electrical Engineering from the Cooper Union in 1983, and his Ph.D. in Computer Science from Princeton University in 1987, working under Bob Sedgewick. He has been at FIU since 1987 and was promoted to Professor in 1996. His interests include data structures, algorithms, and education. He is most well-known for his highly-acclaimed Data Structures textbooks, which have been used for a generation by roughly a million students. Professor Weiss is the author of numerous publications in top-rated journals and was recipient of the University's Excellence in Research Award in 1994. In 1996 at FIU he was the first in the world to teach Data Structures using the Java programming language, which is now thTable of ContentsChapter 1 Programming: A General Overview 1 1.1 What’s This Book About? 1 1.2 Mathematics Review 2 1.2.1 Exponents 3 1.2.2 Logarithms 3 1.2.3 Series 4 1.2.4 Modular Arithmetic 5 1.2.5 The P Word 6 1.3 A Brief Introduction to Recursion 8 1.4 C++ Classes 12 1.4.1 Basic class Syntax 12 1.4.2 Extra Constructor Syntax and Accessors 13 1.4.3 Separation of Interface and Implementation 16 1.4.4 vector and string 19 1.5 C++ Details 21 1.5.1 Pointers 21 1.5.2 Lvalues, Rvalues, and References 23 1.5.3 Parameter Passing 25 1.5.4 Return Passing 27 1.5.5 std::swap and std::move 29 1.5.6 The Big-Five: Destructor, Copy Constructor, Move Constructor, Copy Assignment operator=, Move Assignment operator= 30 1.5.7 C-style Arrays and Strings 35 1.6 Templates 36 1.6.1 Function Templates 37 1.6.2 Class Templates 38 1.6.3 Object, Comparable, and an Example 39 1.6.4 Function Objects 41 1.6.5 Separate Compilation of Class Templates 44 1.7 Using Matrices 44 1.7.1 The Data Members, Constructor, and Basic Accessors 44 1.7.2 operator[] 45 1.7.3 Big-Five 46 Summary 46 Exercises 46 References 48 Chapter 2 Algorithm Analysis 51 2.1 Mathematical Background 51 2.2 Model 54 2.3 What to Analyze 54 2.4 Running-Time Calculations 57 2.4.1 A Simple Example 58 2.4.2 General Rules 58 2.4.3 Solutions for the Maximum Subsequence Sum Problem 60 2.4.4 Logarithms in the Running Time 66 2.4.5 Limitations of Worst Case Analysis 70 Summary 70 Exercises 71 References 76 Chapter 3 Lists, Stacks, and Queues 77 3.1 Abstract Data Types (ADTs) 77 3.2 The List ADT 78 3.2.1 Simple Array Implementation of Lists 78 3.2.2 Simple Linked Lists 79 3.3 vector and list in the STL 80 3.3.1 Iterators 82 3.3.2 Example: Using erase on a List 83 3.3.3 const_iterators 84 3.4 Implementation of vector 86 3.5 Implementation of list 91 3.6 The Stack ADT 103 3.6.1 Stack Model 103 3.6.2 Implementation of Stacks 104 3.6.3 Applications 104 3.7 The Queue ADT 112 3.7.1 Queue Model 113 3.7.2 Array Implementation of Queues 113 3.7.3 Applications of Queues 115 Summary 116 Exercises 116 Chapter 4 Trees 121 4.1 Preliminaries 121 4.1.1 Implementation of Trees 122 4.1.2 Tree Traversals with an Application 123 4.2 Binary Trees 126 4.2.1 Implementation 128 4.2.2 An Example: Expression Trees 128 4.3 The Search Tree ADT–Binary Search Trees 132 4.3.1 contains 134 4.3.2 findMin and findMax 135 4.3.3 insert 136 4.3.4 remove 139 4.3.5 Destructor and Copy Constructor 141 4.3.6 Average-Case Analysis 141 4.4 AVL Trees 144 4.4.1 Single Rotation 147 4.4.2 Double Rotation 149 4.5 Splay Trees 158 4.5.1 A Simple Idea (That Does Not Work) 158 4.5.2 Splaying 160 4.6 Tree Traversals (Revisited) 166 4.7 B-Trees 168 4.8 Sets and Maps in the Standard Library 173 4.8.1 Sets 173 4.8.2 Maps 174 4.8.3 Implementation of set and map 175 4.8.4 An Example That Uses Several Maps 176 Summary 181 Exercises 182 References 189 Chapter 5 Hashing 193 5.1 General Idea 193 5.2 Hash Function 194 5.3 Separate Chaining 196 5.4 Hash Tables without Linked Lists 201 5.4.1 Linear Probing 201 5.4.2 Quadratic Probing 202 5.4.3 Double Hashing 207 5.5 Rehashing 208 5.6 Hash Tables in the Standard Library 210 5.7 Hash Tables with Worst-Case O(1) Access 212 5.7.1 Perfect Hashing 213 5.7.2 Cuckoo Hashing 215 5.7.3 Hopscotch Hashing 224 5.8 Universal Hashing 230 5.9 Extendible Hashing 233 Summary 236 Exercises 238 References 242 Chapter 6 Priority Queues (Heaps) 245 6.1 Model 245 6.2 Simple Implementations 246 6.3 Binary Heap 247 6.3.1 Structure Property 247 6.3.2 Heap-Order Property 248 6.3.3 Basic Heap Operations 249 6.3.4 Other Heap Operations 252 6.4 Applications of Priority Queues 257 6.4.1 The Selection Problem 258 6.4.2 Event Simulation 259 6.5 d-Heaps 260 6.6 Leftist Heaps 261 6.6.1 Leftist Heap Property 261 6.6.2 Leftist Heap Operations 262 6.7 Skew Heaps 269 6.8 Binomial Queues 271 6.8.1 Binomial Queue Structure 271 6.8.2 Binomial Queue Operations 271 6.8.3 Implementation of Binomial Queues 276 6.9 Priority Queues in the Standard Library 283 Summary 283 Exercises 283 References 288 Chapter 7 Sorting 291 7.1 Preliminaries 291 7.2 Insertion Sort 292 7.2.1 The Algorithm 292 7.2.2 STL Implementation of Insertion Sort 293 7.2.3 Analysis of Insertion Sort 294 7.3 A Lower Bound for Simple Sorting Algorithms 295 7.4 Shellsort 296 7.4.1 Worst-Case Analysis of Shellsort 297 7.5 Heapsort 300 7.5.1 Analysis of Heapsort 301 7.6 Mergesort 304 7.6.1 Analysis of Mergesort 306 7.7 Quicksort 309 7.7.1 Picking the Pivot 311 7.7.2 Partitioning Strategy 313 7.7.3 Small Arrays 315 7.7.4 Actual Quicksort Routines 315 7.7.5 Analysis of Quicksort 318 7.7.6 A Linear-Expected-Time Algorithm for Selection 321 7.8 A General Lower Bound for Sorting 323 7.8.1 Decision Trees 323 7.9 Decision-Tree Lower Bounds for Selection Problems 325 7.10 Adversary Lower Bounds 328 7.11 Linear-Time Sorts: Bucket Sort and Radix Sort 331 7.12 External Sorting 336 7.12.1 Why We Need New Algorithms 336 7.12.2 Model for External Sorting 336 7.12.3 The Simple Algorithm 337 7.12.4 Multiway Merge 338 7.12.5 Polyphase Merge 339 7.12.6 Replacement Selection 340 Summary 341 Exercises 341 References 347 Chapter 8 The Disjoint Sets Class 351 8.1 Equivalence Relations 351 8.2 The Dynamic Equivalence Problem 352 8.3 Basic Data Structure 353 8.4 Smart Union Algorithms 357 8.5 Path Compression 360 8.6 Worst Case for Union-by-Rank and Path Compression 361 8.6.1 Slowly Growing Functions 362 8.6.2 An Analysis by Recursive Decomposition 362 8.6.3 An O( M log *N ) Bound 369 8.6.4 An O( M α(M, N) ) Bound 370 8.7 An Application 372 Summary 374 Exercises 375 References 376 Chapter 9 Graph Algorithms 379 9.1 Definitions 379 9.1.1 Representation of Graphs 380 9.2 Topological Sort 382 9.3 Shortest-Path Algorithms 386 9.3.1 Unweighted Shortest Paths 387 9.3.2 Dijkstra’s Algorithm 391 9.3.3 Graphs with Negative Edge Costs 400 9.3.4 Acyclic Graphs 400 9.3.5 All-Pairs Shortest Path 404 9.3.6 Shortest Path Example 404 9.4 Network Flow Problems 406 9.4.1 A Simple Maximum-Flow Algorithm 408 9.5 Minimum Spanning Tree 413 9.5.1 Prim’s Algorithm 414 9.5.2 Kruskal’s Algorithm 417 9.6 Applications of Depth-First Search 419 9.6.1 Undirected Graphs 420 9.6.2 Biconnectivity 421 9.6.3 Euler Circuits 425 9.6.4 Directed Graphs 429 9.6.5 Finding Strong Components 431 9.7 Introduction to NP-Completeness 432 9.7.1 Easy vs. Hard 433 9.7.2 The Class NP 434 9.7.3 NP-Complete Problems 434 Summary 437 Exercises 437 References 445 Chapter 10 Algorithm Design Techniques 449 10.1 Greedy Algorithms 449 10.1.1 A Simple Scheduling Problem 450 10.1.2 Huffman Codes 453 10.1.3 Approximate Bin Packing 459 10.2 Divide and Conquer 467 10.2.1 Running Time of Divide-and-Conquer Algorithms 468 10.2.2 Closest-Points Problem 470 10.2.3 The Selection Problem 475 10.2.4 Theoretical Improvements for Arithmetic Problems 478 10.3 Dynamic Programming 482 10.3.1 Using a Table Instead of Recursion 483 10.3.2 Ordering Matrix Multiplications 485 10.3.3 Optimal Binary Search Tree 487 10.3.4 All-Pairs Shortest Path 491 10.4 Randomized Algorithms 494 10.4.1 Random-Number Generators 495 10.4.2 Skip Lists 500 10.4.3 Primality Testing 503 10.5 Backtracking Algorithms 506 10.5.1 The Turnpike Reconstruction Problem 506 10.5.2 Games 511 Summary 518 Exercises 518 References 527 Chapter 11 Amortized Analysis 533 11.1 An Unrelated Puzzle 534 11.2 Binomial Queues 534 11.3 Skew Heaps 539 11.4 Fibonacci Heaps 541 11.4.1 Cutting Nodes in Leftist Heaps 542 11.4.2 Lazy Merging for Binomial Queues 544 11.4.3 The Fibonacci Heap Operations 548 11.4.4 Proof of the Time Bound 549 11.5 Splay Trees 551 Summary 555 Exercises 556 References 557 Chapter 12 Advanced Data Structures and Implementation 559 12.1 Top-Down Splay Trees 559 12.2 Red-Black Trees 566 12.2.1 Bottom-Up Insertion 567 12.2.2 Top-Down Red-Black Trees 568 12.2.3 Top-Down Deletion 570 12.3 Treaps 576 12.4 Suffix Arrays and Suffix Trees 579 12.4.1 Suffix Arrays 580 12.4.2 Suffix Trees 583 12.4.3 Linear-Time Construction of Suffix Arrays and Suffix Trees 586 12.5 k-d Trees 596 12.6 Pairing Heaps 602 Summary 606 Exercises 608 References 612 Appendix A Separate Compilation of Class Templates 615 A.1 Everything in the Header 616 A.2 Explicit Instantiation 616 Index 619

Read more less