Programming and scripting languages: general Books
John Wiley & Sons Inc Karel
Book SynopsisUsing the same format that has become so popular in Pascal, Karel the Robot has now become object-oriented. This book is intended to teach novice programmers the fundamentals of object-oriented programming. It accomplishes this goal with an analog equivalent of C++ that allows introductory computer science students to work through a programming project from start to finish.The book opens by explaining the elaborate Robot world that Karel lives in, a world filled with objects. The text continues this strong metaphor throughout. Through the metaphor, students learn the art of solving programming problems in an object-oriented paradigm.This text is suitable for any introductory or second course in computer science where C++ is used.Table of ContentsThe Robot World. Primitive Instructions and Simple Programs. Extending the Robot Programming Language. Conditionally Executing Instructions. Instructions That Repeat. Advanced Techniques for Robots. Appendices.
£72.15
John Wiley & Sons Inc Fundamentals
Book SynopsisThis book examines the solution of some of the most common problems of numerical computation. By concentrating on one effective algorithm for each basic task, it develops the fundamental theory in a brief, elementary way. There are ample exercises, and codes are provided to reduce the time otherwise required for programming and debugging.Table of ContentsErrors and Floating Point Arithmetic. Systems of Linear Equations. Interpolation. Roots of Nonlinear Equations. Numerical Integration. Ordinary Differential Equations. Appendix. Answers to Selected Exercises. Index.
£192.85
John Wiley & Sons Inc Automating Science and Engineering Laboratories
Book SynopsisWith computer technologies increasingly taking over many laboratory tasks, laboratory professionals are often faced with the dilemma of having to build customized computer applications without prior training in programming.Table of ContentsVISUAL BASIC(r) AND THE INTEGRATED DEVELOPMENT ENVIRONMENT. Background. IDE Fundamentals. A Review of the Visual Basic(r) Language. The Structure of a Visual Basic(r) Application. Object-Oriented Programming in Visual Basic(r). DEVICE COMMUNICATIONS. Introducing the Virtual Instrument. Dynamic Data Exchange. Using Dynamic Data Exchange in Visual Basic(r). RS-232 Communications. RS-232 Communications in Visual Basic(r). TCP/IP Networking. TCP/IP Networking in Visual Basic(r). File Communications. DEVICE CONTROL AND DATA HANDLING. Multithreading. Multithreading in Visual Basic(r). Concepts of State. State Machines-Implementing State Diagrams in Visual Basic(r). Parsing-Understanding Message Content. A Visual Basic(r) Parser Class. Device Monitoring and Control. Device Controllers in VB. GRAPHICAL INTERFACES AND DATA PRESENTATION. Scientific Plotting with MSChart. Tabular Data Display and Editing. Visual Basic(r) Graphics Fundamentals. Active Graphic Displays. Interactive Graphic Displays. Appendices. Index.
£52.16
John Wiley & Sons Inc Programming with Objects
Book SynopsisPROGRAMMING WITH OBJECTS Your essential comparative approach to learning C++ and Java Programming with Objects: A Comparative Presentation of Object-Oriented Programming with C++ and Java, a comparative presentation of object-oriented programming with two of the most popular programming languages of today, teaches vital skills and techniques for the Internet age. Based on highly successful courses taught by the author, this book answers the need for a comprehensive educational program on the subject of object-oriented programming. In a clear and accessible format, the author compares and contrasts both languages, from basic language constructs to how both languages are used in application-level programming, such as graphics programming, network programming, and database programming. Since both C++ and Java were born out of the same language, C, learning these two languages together has several distinct advantages: Because they have much in common aTrade Review"...a wonderful volume...a very worthwhile read...essential..." (Choice, September 2003)Table of ContentsWhy OO Programming - Some Parallels with Things at Large. Baby Steps. The Notion of a Class and Some Other Key Ideas. Strings. Using the Container Classes. The Primitive Types and Their Input/Output. Declarations, Definitions, and Initializations. Object Reference and Memory Allocation. Functions and Methods. Handling Exceptions. Classes, The Rest of the Story. Overloading Operators in C++. Generics and Templates. Modeling Diagrams for OO Programs. Extending Classes. Multiple Inheritance in C++. OO for Graphical User Interfaces, A Tour of Three Toolkits. Multithreaded Object-Oriented Programming. Network Programming. Database Programming.
£99.86
John Wiley & Sons Inc Objects Abstraction Data Structures and Design
Book SynopsisKoffman and Wolfgang introduce data structures in the context of C++ programming. They embed the design and implementation of data structures into the practice of sound software design principles that are introduced early and reinforced by 20 case studies. Data structures are introduced in the C++ STL format whenever possible. Each new data structure is introduced by describing its interface in the STL. Next, one or two simpler applications are discussed then the data structure is implemented following the interface previously introduced. Finally, additional advanced applications are covered in the case studies, and the cases use the STL. In the implementation of each data structure, the authors encourage students to perform a thorough analysis of the design approach and expected performance before actually undertaking detailed design and implementation. Students gain an understanding of why different data structures are needed, the applications they are suited for, and the advantTable of ContentsPreface iii Chapter P A C++ Primer 1 P.1 The C++ Environment 2 P.2 Preprocessor Directives and Macros 7 P.3 C++ Control Statements 12 P.4 Primitive Data Types and Class Types 16 P.5 Objects, Pointers, and References 23 P.6 Functions 29 P.7 Arrays and C Strings 33 P.8 The string Class 38 P.9 Input/Output Using Streams 44 Chapter Review, Exercises, and Programming Projects 59 Chapter 1 Introduction to Software Design 63 1.1 The Software Life Cycle 64 1.2 Using Abstraction to Manage Complexity 73 1.3 Defining C++ Classes 75 1.4 Abstract Data Types, Interfaces, and Pre- and Postconditions 98 1.5 Requirements Analysis, Use Cases, and Sequence Diagrams 102 1.6 Design of an Array-Based Phone Directory 108 1.7 Implementing and Testing the Array-Based Phone Directory 114 1.8 Completing the Phone Directory Application 121 Chapter Review, Exercises, and Programming Projects 125 Chapter 2 Program Correctness and Efficiency 129 2.1 Program Defects and “Bugs” 130 2.2 Exceptions 138 2.3 Testing Programs 148 2.4 Debugging a Program 160 2.5 Reasoning about Programs: Assertions and Loop Invariants 166 2.6 Efficiency of Algorithms 170 Chapter Review, Exercises, and Programming Projects 179 Chapter 3 Inheritance and Class Hierarchies 185 3.1 Introduction to Inheritance and Class Hierarchies 186 3.2 Member Function Overriding, Member Function Overloading, and Polymorphism 193 3.3 Abstract Classes, Assignment, and Casting in a Hierarchy 202 3.4 Multiple Inheritance 210 3.5 Namespaces and Visibility 213 3.6 A Shape Class Hierarchy 220 Chapter Review, Exercises, and Programming Projects 225 Chapter 4 Sequential Containers 231 4.1 Template Classes and the Vector 232 4.2 Applications of vector 238 4.3 Implementation of a vector Class 240 4.4 The Copy Constructor, Assignment Operator, and Destructor 247 4.5 Single-Linked Lists and Double-Linked Lists 252 4.6 The list Class and the Iterator 264 4.7 Implementation of a Double-Linked List Class 271 4.8 Application of the list Class 285 4.9 Standard Library Containers 292 4.10 Standard Library Algorithms and Function Objects 297 Chapter Review, Exercises, and Programming Projects 307 Chapter 5 Stacks 311 5.1 The Stack Abstract Data Type 312 5.2 Stack Applications 315 5.3 Implementing a Stack 325 5.4 Additional Stack Applications 332 Chapter Review, Exercises, and Programming Projects 351 Chapter 6 Queues and Deques 357 6.1 The Queue Abstract Data Type 358 6.2 Maintaining a Queue of Customers 362 6.3 Implementing the Queue ADT 365 6.4 The Deque 376 6.5 Simulating Waiting Lines Using Queues 380 Chapter Review, Exercises, and Programming Projects 398 Chapter 7 Recursion 403 7.1 Recursive Thinking 404 7.2 Recursive Definitions of Mathematical Formulas 412 7.3 Recursive Search 420 7.4 Problem Solving with Recursion 426 7.5 Backtracking 435 Chapter Review, Exercises, and Programming Projects 440 Chapter 8 Trees 445 8.1 Tree Terminology and Applications 447 8.2 Tree Traversals 454 8.3 Implementing a Binary_Tree Class 457 8.4 Binary Search Trees 466 8.5 Heaps and Priority Queues 484 8.6 Huffman Trees 496 Chapter Review, Exercises, and Programming Projects 505 Chapter 9 Sets and Maps 511 9.1 Associative Container Requirements 512 9.2 Maps and Multimaps 521 9.3 Hash Tables 530 9.4 Implementing the Hash Table 542 9.5 Implementation Considerations for the hash_map 555 9.6 Additional Applications of Maps 558 Chapter Review, Exercises, and Programming Projects 564 Chapter 10 Sorting 569 10.1 Using C++ Sorting Functions 570 10.2 Selection Sort 572 10.3 Bubble Sort 577 10.4 Insertion Sort 581 10.5 Comparison of Quadratic Sorts 586 10.6 Shell Sort: A Better Insertion Sort 588 10.7 Merge Sort 592 10.8 Heapsort 599 10.9 Quicksort 604 10.10 Testing the Sort Algorithms 614 10.11 The Dutch National Flag Problem (Optional Topic) 616 Chapter Review, Exercises, and Programming Projects 620 Chapter 11 Self-Balancing Search Trees 623 11.1 Tree Balance and Rotation 624 11.2 AVL Trees 628 11.3 Red-Black Trees 643 11.4 2-3 Trees 656 11.5 2-3-4 and B-Trees 663 Chapter Review, Exercises, and Programming Projects 681 Chapter 12 Graphs 691 12.1 Graph Terminology 692 12.2 The Graph ADT and Edge Class 697 12.3 Implementing the Graph ADT 701 12.4 Traversals of Graphs 715 12.5 Applications of Graph Traversals 727 12.6 Algorithms Using Weighted Graphs 734 Chapter Review, Exercises, and Programming Projects 743 Appendix A Advanced C++ Topics 755 A.1 Source Character Set, Trigraphs, Digraphs, and Alternate Keywords 755 A.2 The Allocator 756 A.3 Traits 757 A.4 Virtual Base Classes 759 A.5 Smart Pointers 764 Appendix B Overview of UML 769 B.1 The Class Diagram 770 B.2 Sequence Diagrams 776 Appendix C The CppUnit Test Framework 779 Glossary 783 Index 795
£168.26
John Wiley & Sons Inc Web Application Design and Implementation
Book SynopsisWeb Application Design and Implementation uses a hands-on approach of the major technologies and programming languages to teach readers web development. Providing an understanding of all major aspects of web programming in order to achieve the construction of a database-driven website, the book features state-of-the-art programming languages such as HTML, JavaScript, MySQL, PHP, Apache, Linux/Unix.Trade Review"It explains all concepts at a very elementary level, and allows the novice reader (with basic knowledge of programming) to learn fundamental concepts of Web programming and practical Web design. For an experienced reader, it will provide very good overview of Web programming practices form one particular perspective, that of using open-source software tools." (Computing Reviews, November 25, 2008)Table of ContentsPREFACE. About the Author. Before We Get Started. Who Should Read this book? About The Examples. How to read this book. Acknowledgments. Introduction: Web Application Recipe. Overview. Step 1 - Understanding the problem and finding the solution. Step 2 - Designing the database. Step 3 - Major functionalities. Step 4 - Back side. Step 5 - Improvements on functionality. Step 6 - Improvements on looks. Step 7 - Thorough testing, hacking attempts. Step 8 - Presentation. Step 9 - Publication. Step 10 - Celebration (and maintenance). Chapter 1. Fundamentals. The origins of the Internet. The World Wide Web. The Web Browsers. The Web Servers. TCP/IP BASICS. The Internet Layer. The Transport Layer. The Application Layer. The Toolbox. Browsers. FTP. E-Mail Clients. Programming Tools. Other Useful Tools. Chapter 2. The Different Approaches of Web Programming. Before We Get Started. The Basics - HTML. The Creator - SGML. Other SGML-based languages - XML / XSL. The good old Java. Something different - JavaScript. The Savior - PHP. The rival - ASP.NET. The Myth - CGI. Another Big Option - Perl. The Future? - C#. Client-side versus Server-side - Which side to pick? My Choices - PHP, MySQL, JavaScript. Chapter 3. Introduction To HTML. What do you need to get started? How does HTML work? Syntax basics. File Structure. Tags Parameters. Basic Text Formatting. External References. Links. Images. Organizing Data. Lists. Tables. Frames. Special Characters. Chapter 4. Work Environment. Introduction. Downloading the Software. Installing the Apache Server. Installation Steps. Checking the Installation. Possible Errors. Configuring Apache. Installing PHP5. Testing PHP. Installing MySQL. Adding a MySQL user. How do I know if MySQL is running? Installing phpMyAdmin. Installing a Bulletin Board: phpBB. Installation Steps. Basic Security things to consider! Conclusion. Chapter 5. PHP - A server Side Scripting Language. How does it work? Some “new” words on PHP. Syntax Generalities. Instructions. Operators. Mathematical Functions. Data Types. Constants. Variables. Chapter 6. PHP Arrays and Flow of Control. Arrays. Basic Arrays. Associative Arrays. Multidimensional Arrays. Arrays Functions. PHP Program Structure and Flow of control. Conditions. Loops. Functions. Chapter 7. Using files, folders and Strings in PHP. Using Files. Folder Manipulation. Basic String Manipulation. Changing a string. Finding and Comparing. Formatting Strings. Manipulating HTML files. PHP Information Functions. Closing Remarks. Writing a basic File Explorer. Requirements. HINTS. Case Study: An Indexer/Searcher STEP 1. Overview. The Indexer - Step 1. Chapter 8. PHP5 and Object-Oriented Programming. Overview. Classes and Objects. Classes in PHP. Constructors and Destructors. Visibility. The scope resolution operator. The Static Keyword. Class Constants. Class Abstraction. Object Interfaces. Copying and Cloning objects. Comparing Objects. Type Hinting. Exceptions. Final words. Chapter 9. Creating Some Interactivity. Overview. Forms. Writing a form in HTML. GET vs. POST. Retrieving the form info on a PHP script. Dynamically creating forms. Transferring data between PHP scripts. Cookies. Sessions. One last useful function and design techniques. Assignments. File explorer step 2. Case study: Indexer/Searcher - Step 2. Chapter 10: Making Cleaner Code and Output. Cleaning up your code. What you need. How to use it? - HTML side. How to use it? - PHP side. Cleaning up your output. The CSS file. Useful tools. Assignment. Chapter 11. Using Databases. Overview. Database Basics. The entity-relationship model. More Practical Example. Typical sources of Errors. Simplifying the Diagrams. Using MySQL. MySQL Syntax. Data Types. MySQL numeric data types. Date and Time data types. String Data types. MySQL Operators. MySQL Instructions. Using Functions in MySQL. Chapter 12. Using PhpMyAdmin. Overview. Creating a Database. Creating tables. Accessing an existing table. Exporting/Importing a database structure and content. Assignment - Final Project. Chapter 13. Creating Database-Driven Websites with PHP/MySQL. Overview. Connecting to your MySQL server with PHP. Submitting SQL queries. Processing the results of a query. Example of login procedure. Other useful functions. Grouping our Methods in a class. Indexer/Searcher - Steps 3 and 4. Chapter 14: JavaScript - A client side scripting language. Introduction. JavaScript syntax. Types of Data and Variables. Operations and calculations. Arrays. Decisions. Loops. Using Functions. Using Objects. The String Objects. The Math class. The Array objects. Chapter 15. Programming the Browser. Overview. The Window Object. The Location Object. The History Object. The Navigator Object. The Screen Object. The Document Object. Using Events. Timers. Time to practice! Chapter 16. Windows and Frames. Frames and JavaScript. Windows and JavaScript. Assignments. One Last Funny Example. Chapter 17: String Manipulations Revisited. Overview. New Basic String methods. Regular Expressions in JavaScript. Regular Expressions in PHP. The set of PCRE. Chapter 18. JavaScript and DHTML. Overview. Positioning Elements. Writing dynamic menus in DHTML. You turn!! . Chapter 19. Putting it All Together! Overview. Step 1 - Understanding the problem and finding the solution. Step 2 - Designing the database. Step 3 - Main functionalities. Step 4 - Back side. Step 5 - Improvements on functionality. Step 6 - Improvements on looks. Step 7 - Thorough testing, hacking attempts. Step 8 - Presentation. Step 9 - Publication. Step 10 - Celebration :) (and maintenance). What language to use? Appendix A: Special Characters. Appendix B: Installing on UNIX. Overview. Installing Apache and PHP. Installing MySQL. Appendix C: Advanced phpBB. Appendix D: class.FastTemplate.PHP. Appendix E - File Upload Script. Bibliography. Index.
£86.36
John Wiley & Sons Inc Programming the Boundary Element Method
Book SynopsisProviding an easy introduction to the boundary element method, this book is ideal for any reader wishing to work in this field or use this method for the solution of engineering problems. From the beginning, the emphasis is on the implementation of the method into computer programs which can be used to solve real problems. The book covers two-andthree-dimensional linear and non-linear analysis in potential flow (heat flow and seepage) and static elasticity. Several computer programs are listed in the book and may be downloaded free of charge via the Internet. They include programs and subroutines for: * 2-D analysis of potential problems using the Trefftz method * 2-D and 3-D linear analysis of potential and static elasticity problems using isoparametric elements (single and multiple regions) * implementation of non-linear problems * coupling to finite elements The programs (written in FORTRAN 90) are well documented, and can be employed by the user to gaiTable of ContentsPreface. Acknowledgements. Preliminaries. Programming. Discretisation and Interpolation. Material Modelling and Fundamental Solutions. Boundary Integral Equations. Boundary Element Methods - Numerical Implementation. Assembly and Solution. Postprocessing. Test Examples. Multiple Regions. Edges and Corners. Body Forces. Non-Linear Problems. Coupled Boundary Element/Finite Element Analysis. Industrial Applications. Appendix A: Program Libraries. Appendix B: Answers to Exercises. Index.
£59.80
John Wiley & Sons Inc Lingo Sorcery 2e The Magic of Lists Objects and
Book SynopsisThis text explains how to apply Object-Oriented Programming techniques to multimedia products made with Director, this edition incorporates the many significant changes made to the program since the first edition was published.Trade Review"...Plenty of good advice is dispensed on techniques for using objects and lists to best effect. At this price the book is value for money...", , , Computer Bulletin, November 1999 #Table of ContentsMaking an Independent Object. Adding Sophisticated Features to Objects. Getting Object-Oriented. Messages, Control and Feedback. The Ancestor Portal. The Basis of Complex Objects. The Mechanics of Linear Lists. The Mechanics of Property Lists. Using Lists. Messages and Message Paths. Using Lists in Message Paths. The Object-User Interface. Object-Controlled Menus. Magical Tricks with Lists and Objects. Making a Paint Box with a Memory. Intelligent Button and Palette Objects. The Magic of MIAW Objects. Using MIAW Objects. Behaviors. Intranets, Kiosks and Avatars. Epilog. Index.
£56.00
O'Reilly Media DocBook 5
Book SynopsisOffers you the details on how to use and customize version 5.0 of the DocBook XML schema. This book is suitable for technical writers, developers looking to customize the schema, tools developers, and managers evaluating DocBook.
£29.99
Princeton University Press Natural Complexity
Book SynopsisTrade Review"This book is a clear introduction to experimentation with complex systems that will appeal to multiple audiences. . . . It will serve as an example of pedagogical clarity and skill for anyone responsible for teaching the physical sciences."---H. Van Dyke Parunak, Computing Reviews"There is a certain enthusiasm distilled by the author all through the book, transporting the reader on a journey of discovery of a chosen set of complex systems, from where diverse insights into complexity science can be grasped. . . . Natural Complexity constitutes an excellent introduction to some perspectives about complexity science that might be appealing to a broad range of readers."---Miguel A. F. Sanjuán, Contemporary PhysicsTable of ContentsPreface xiii 1. Introduction: What Is Complexity? 1 1.1 Complexity Is Not Simple 1 1.2 Randomness Is Not Complexity 4 1.3 Chaos Is Not Complexity 10 1.4 Open Dissipative Systems 13 1.5 Natural Complexity 16 1.6 About the Computer Programs Listed in This Book 18 1.7 Suggested Further Reading 20 2 Iterated Growth 23 2.1 Cellular Automata in One Spatial Dimension 23 2.2 Cellular Automata in Two Spatial Dimensions 31 2.3 A Zoo of 2-D Structures from Simple Rules 38 2.4 Agents, Ants, and Highways 41 2.5 Emergent Structures and Behaviors 46 2.6 Exercises and Further Computational Explorations 47 2.7 Further Reading 50 3 Aggregation 53 3.1 Diffusion-Limited Aggregation 53 3.2 Numerical Implementation 54 3.3 A Representative Simulation 58 3.4 A Zoo of Aggregates 60 3.5 Fractal Geometry 63 3.6 Self-Similarity and Scale Invariance 73 3.7 Exercises and Further Computational Explorations 76 3.8 Further Reading 78 4 Percolation 80 4.1 Percolation in One Dimension 80 4.2 Percolation in Two Dimensions 83 4.3 Cluster Sizes 85 4.4 Fractal Clusters 98 4.5 Is It Really a Power Law? 98 4.6 Criticality 100 4.7 Exercises and Further Computational Explorations 102 4.8 Further Reading 104 5 Sandpiles 106 5.1 Model Definition 106 5.2 Numerical Implementation 110 5.3 A Representative Simulation 112 5.4 Measuring Avalanches 119 5.5 Self-Organized Criticality 123 5.6 Exercises and Further Computational Explorations 127 5.7 Further Reading 129 6 Forest Fires 130 6.1 Model Definition 130 6.2 Numerical Implementation 131 6.3 A Representative Simulation 134 6.4 Model Behavior 137 6.5 Back to Criticality 147 6.6 The Pros and Cons of Wildfire Management 148 6.7 Exercises and Further Computational Explorations 149 6.8 Further Reading 152 7 Traffic Jams 154 7.1 Model Definition 154 7.2 Numerical Implementation 157 7.3 A Representative Simulation 157 7.4 Model Behavior 161 7.5 Traffic Jams as Avalanches 164 7.6 Car Traffic as a SOC System? 168 7.7 Exercises and Further Computational Explorations 170 7.8 Further Reading 172 8 Earthquakes 174 8.1 The Burridge-Knopoff Model 175 8.2 Numerical Implementation 182 8.3 A Representative Simulation 184 8.4 Model Behavior 189 8.5 Predicting Real Earthquakes 193 8.6 Exercises and Further Computational Explorations 194 8.7 Further Reading 196 9 Epidemics 198 9.1 Model Definition 198 9.2 Numerical Implementation 199 9.3 A Representative Simulation 202 9.4 Model Behavior 205 9.5 Epidemic Self-Organization 213 9.6 Small-World Networks 215 9.7 Exercises and Further Computational Explorations 220 9.8 Further Reading 222 10 Flocking 224 10.1 Model Definition 225 10.2 Numerical Implementation 228 10.3 A Behavioral Zoo 235 10.4 Segregation of Active and Passive Flockers 240 10.5 Why You Should Never Panic 242 10.6 Exercises and Further Computational Explorations 245 10.7 Further Reading 247 11 Pattern Formation 249 11.1 Excitable Systems 249 11.2 The Hodgepodge Machine 253 11.3 Numerical Implementation 260 11.4 Waves, Spirals, Spaghettis, and Cells 262 11.5 Spiraling Out 266 11.6 Spontaneous Pattern Formation 270 11.7 Exercises and Further Computational Explorations 272 11.8 Further Reading 273 12 Epilogue 275 12.1 A Hike on Slickrock 275 12.2 Johannes Kepler and the Unity of Nature 279 12.3 From Lichens to Solar Flares 285 12.4 Emergence and Natural Order 288 12.5 Into the Abyss: Your Turn 290 12.6 Further Reading 291 A. Basic Elements of the Python Programming Language 293 A.1 Code Structure 294 A.2 Variables and Arrays 297 A.3 Operators 299 A.4 Loop Constructs 300 A.5 Conditional Constructs 304 A.6 Input/Output and Graphics 305 A.7 Further Reading 306 B. Probability Density Functions 308 B.1 A Simple Example 308 B.2 Continuous PDFs 312 B.3 Some Mathematical Properties of Power-Law PDFs 313 B.4 Cumulative PDFs 314 B.5 PDFs with Logarithmic Bin Sizes 315 B.6 Better Fits to Power-Law PDFs 318 B.7 Further Reading 320 C Random Numbers and Walks 321 C.1 Random and Pseudo-Random Numbers 321 C.2 Uniform Random Deviates 323 C.3 Using Random Numbers for Probability Tests 324 C.4 Nonuniform Random Deviates 325 C.5 The Classical Random Walk 328 C.6 Random Walk and Diffusion 335 D Lattice Computation 338 D.1 Nearest-Neighbor Templates 339 D.2 Periodic Boundary Conditions 342 D.3 Random Walks on Lattices 345 Index 351
£40.80
John Wiley & Sons Inc Access VBA Programming For Dummies For Dummies S
Book SynopsisGet the scoope on how to use VBA to create more powerful Access databases and applications.Table of ContentsIntroduction 1 Part I: Introducing VBA Programming 7 Chapter 1: Where VBA Fits In 9 Chapter 2: Your VBA Toolkit 21 Chapter 3: Jumpstart: Creating a Simple VBA Program 35 Part II: VBA Tools and Techniques 49 Chapter 4: Understanding Your VBA Building Blocks 51 Chapter 5: Controlling Access through VBA 71 Chapter 6: Programming Access Forms 87 Part III: VBA, Recordsets, and SQL 115 Chapter 7: The Scoop on SQL and Recordsets 117 Chapter 8: Putting Recordsets to Work 147 Part IV: Applying VBA in the Real World 173 Chapter 9: Creating Your Own Dialog Boxes 175 Chapter 10: Customizing Lists and Drop-Down Menus 201 Chapter 11: Creating Your Own Functions 241 Chapter 12: Testing and Debugging Your Code 267 Part V: Reaching Out with VBA 295 Chapter 13: Using VBA with Multiple Databases 297 Chapter 14: Integrating with Other Office Applications 317 Part VI: The Part of Tens 349 Chapter 15: Ten Commandments of Writing VBA 351 Chapter 16: Top Ten Nerdy VBA Tricks 357 Chapter 17: (Way More Than) Ten Shortcut Keys 367 Index 371
£23.99
IEEE Computer Society Press,U.S. Software Reliability and Testing
Book Synopsis
£62.06
O'Reilly Media Resilient Oracle PlSQL
Book SynopsisThis practical guide provides system administrators, DevSecOps engineers, and cloud architects with a concise yet comprehensive overview on how to use PL/SQL to develop resilient database solutions.
£47.99
John Wiley & Sons Inc Ivor Hortons Beginning Visual C 2013 Wrox
Book SynopsisLearn C++ with the best tutorial on the market! Horton''s unique tutorial approach and step-by-step guidance have helped over 100,000 novice programmers learn C++. In Ivor Horton''s Beginning Visual C++ 2013, Horton not only guides you through the fundamentals of the standard C++ language, but also teaches you how C++ is used in the latest Visual Studio 2013 environment. Visual Studio 2013 includes major changes to the IDE and expanded options for C++ coding. Ivor Horton''s Beginning Visual C++ 2013 will teach you the latest techniques to take your Visual C++ coding to an all-new level. C++ language and library changes supported under Visual Studio 2013 IDE-specific changes for code formatting and debugging Changes to the C++ Standard Language for both C++ 11 and the new C++ 14 And more Horton introduces you to both Standard C++ and Visual C++ so you can build any component your app requires. Ivor Horton'Table of ContentsIntroduction xxxiii Chapter 1: Programming with Visual C++ 1 Learning with Visual C++ 1 Writing C++ Applications 2 Learning Desktop Applications Programming 3 The Integrated Development Environment 6 Using the IDE 8 Summary 23 Chapter 2: Data, Variables, and Calculations 25 The Structure of a C++ Program 26 Defining Variables 38 Fundamental Data Types 40 Basic Input/Output Operations 47 Calculating in C++ 52 Type Conversion and Casting 63 The auto Keyword 65 Discovering Types 66 The Bitwise Operators 67 Introducing Lvalues and Rvalues 72 Understanding Storage Duration and Scope 72 Variables with Specific Sets of Values 79 Namespaces 83 Summary 86 Chapter 3: Decisions and Loops 91 Repeating a Block of Statements 109 Summary 127 Chapter 4: Arrays, Strings, and Pointers 129 Handling Multiple Data Values of the Same Type 129 Working with C-Style Strings 140 Indirect Data Access 146 Dynamic Memory Allocation 163 Using References 168 Library Functions for Strings 171 Summary 176 Chapter 5: Introducing Structure into Your Programs 179 Understanding Functions 179 Passing Arguments to a Function 188 Returning Values from a Function 206 Returning a Pointer 206 Recursive Function Calls 214 Summary 217 Chapter 6: More about Program Structure 221 Pointers to Functions 221 Initializing Function Parameters 228 Exceptions 229 Handling Memory Allocation Errors 235 Function Overloading 237 Function Templates 241 Using the decltype Operator 244 An Example Using Functions 246 Summary 264 Chapter 7: Defining Your Own Data Types 267 The struct in C++ 267 Types, Objects, Classes, and Instances 276 Understanding Classes 279 Class Constructors 287 Private Members of a Class 297 The Pointer this 304 Const Objects 306 Arrays of Objects 309 Static Members of a Class 310 Pointers and References to Objects 314 Summary 318 Chapter 8: More on Classes 323 Class Destructors 324 Implementing a Copy Constructor 329 Operator Overloading 331 The Object Copying Problem 351 Default Class Members 361 Class Templates 362 Perfect Forwarding 373 Default Arguments for Template Parameters 376 Aliases for Class Templates 381 Template Specialization 382 Using Classes 385 Organizing Your Program Code 403 Library Classes for Strings 405 Summary 427 Chapter 9: Class Inheritance and Virtual Functions 431 Object-Oriented Programming Basics 432 Inheritance in Classes 433 Access Control Under Inheritance 437 The Copy Constructor in a Derived Class 447 Preventing Class Derivation 450 Class Members as Friends 451 Virtual Functions 453 Casting Between Class Types 470 Summary 475 Chapter 10: The Standard Template Library 479 What Is the Standard Template Library? 479 Smart Pointers 485 Algorithms 488 Function Objects in the STL 489 Function Adapters 490 The Range of STL Containers 490 Sequence Containers 490 Associative Containers 543 More on Iterators 556 More on Function Objects 562 More on Algorithms 564 Type Traits and Static Assertions 566 Lambda Expressions 567 Summary 577 Chapter 11: Windows Programming Concepts 579 Windows Programming Basics 580 The Structure of a Windows Program 586 The Microsoft Foundation Classes 605 Summary 610 Chapter 12: Windows Programming with the Microsoft Foundation Classes (MF C) 613 The MFC Document/View Concept 614 Creating MFC Applications 618 Summary 635 Chapter 13: Working with Menus and Toolbars 637 Communicating with Windows 637 Extending the Sketcher Program 642 Elements of a Menu 643 Adding Menu Message Handlers 646 Adding Toolbar Buttons 656 Summary 660 Chapter 14: Drawing in a Window 663 Basics of Drawing in a Window 663 The MFC Drawing Mechanism 667 Drawing Graphics in Practice 678 Programming for the Mouse 680 Drawing a Sketch 709 Summary 713 Chapter 15: Improving the View 717 Sketcher Limitations 717 Improving the View 718 Deleting and Moving Elements 726 Implementing a Context Menu 726 Identifying an Element Under the Cursor 730 Dealing with Masked Elements 743 Summary 745 Chapter 16: Working with Dialogs and Controls 747 Understanding Dialogs 748 Understanding Controls 748 Creating a Dialog Resource 749 Programming for a Dialog 751 Supporting the Dialog Controls 755 Completing Dialog Operations 758 Using a Spin Button Control 763 Using the Scale Factor 769 Working with Status Bars 775 The CString Class 779 Using an Edit Box Control 780 Summary 790 Chapter 17: Storing and Printing Documents 793 Understanding Serialization 793 Applying Serialization 801 Exercising Serialization 809 Printing a Document 811 Implementing Multipage Printing 815 Summary 825 Chapter 18: Programming for Windows 8 827 Windows Store Applications 828 Developing Windows Store Apps 829 Windows Runtime Concepts 829 C++ Component Extensions (C++/CX) 831 The Extensible Application Markup Language (XAML) 836 Creating a Windows Store App 844 Scaling UI Elements 873 Transitions 875 Summary 879 Index 881
£40.00
John Wiley & Sons Inc Data Analysis Using SQL and Excel
Book SynopsisA practical guide to data mining using SQL and Excel Data Analysis Using SQL and Excel, 2nd Edition shows you how to leverage the two most popular tools for data query and analysisSQL and Excelto perform sophisticated data analysis without the need for complex and expensive data mining tools. Written by a leading expert on business data mining, this book shows you how to extract useful business information from relational databases. You''ll learn the fundamental techniques before moving into the where and why of each analysis, and then learn how to design and perform these analyses using SQL and Excel. Examples include SQL and Excel code, and the appendix shows how non-standard constructs are implemented in other major databases, including Oracle and IBM DB2/UDB. The companion website includes datasets and Excel spreadsheets, and the book provides hints, warnings, and technical asides to help you every step of the way. Data Analysis Using SQL and Excel, 2nd Table of ContentsForeword xxxiii Introduction xxxvii Chapter 1 A Data Miner Looks at SQL 1 Databases, SQL, and Big Data 2 Picturing the Structure of the Data 6 Picturing Data Analysis Using Dataflows 16 SQL Queries 21 Subqueries and Common Table Expressions Are Our Friends 36 Lessons Learned 47 Chapter 2 What’s in a Table? Getting Started with Data Exploration 49 What Is Data Exploration? 50 Excel for Charting 51 Sparklines 65 What Values Are in the Columns? 68 More Values to Explore—Min, Max, and Mode 79 Exploring String Values 81 Exploring Values in Two Columns 86 From Summarizing One Column to Summarizing All Columns 90 Lessons Learned 96 Chapter 3 How Different Is Different? 97 Basic Statistical Concepts 98 How Different Are the Averages? 105 Sampling from a Table 110 Counting Possibilities 115 Ratios and Their Statistics 128 Chi-Square 132 What Months and Payment Types Have Unusual Affinities for Which Types of Products? 140 Lessons Learned 143 Chapter 4 Where Is It All Happening? Location, Location, Location 145 Latitude and Longitude 146 Census Demographics 160 Geographic Hierarchies 172 Mapping in Excel 188 Lessons Learned 194 Chapter 5 It’s a Matter of Time 197 Dates and Times in Databases 198 Starting to Investigate Dates 204 How Long Between Two Dates? 218 Year-over-Year Comparisons 229 Counting Active Customers by Day 239 Simple Chart Animation in Excel 247 Lessons Learned 254 Chapter 6 How Long Will Customers Last? Survival Analysis to Understand Customers and Their Value 255 Background on Survival Analysis 256 The Hazard Calculation 260 Survival and Retention 269 Comparing Different Groups of Customers 280 Comparing Survival over Time 287 Important Measures Derived from Survival 293 Using Survival for Customer Value Calculations 298 Forecasting 308 Lessons Learned 314 Chapter 7 Factors Affecting Survival: The What and Why of Customer Tenure 315 Which Factors Are Important and When 316 Left Truncation 328 Time Windowing 336 Competing Risks 342 Before and After 353 Lessons Learned 366 Chapter 8 Customer Purchases and Other Repeated Events 367 Identifying Customers 368 RFM Analysis 393 Which Households Are Increasing Purchase Amounts Over Time? 404 Time to Next Event 416 Lessons Learned 420 Chapter 9 What’s in a Shopping Cart? Market Basket Analysis 421 Exploring the Products 422 Products and Customer Worth 437 Product Geographic Distribution 448 Which Customers Have Particular Products? 451 Lessons Learned 463 Chapter 10 Association Rules and Beyond 465 Item Sets 466 The Simplest Association Rules 480 One-Way Association Rules 483 Two-Way Associations 489 Extending Association Rules 499 Lessons Learned 506 Chapter 11 Data Mining Models in SQL 507 Introduction to Directed Data Mining 508 Look-Alike Models 515 Lookup Model for Most Popular Product 522 Lookup Model for Order Size 528 Lookup Model for Probability of Response 534 Naive Bayesian Models (Evidence Models) 546 Lessons Learned 559 Chapter 12 The Best-Fit Line: Linear Regression Models 561 The Best-Fit Line 562 Measuring Goodness of Fit Using R2 581 Direct Calculation of Best-Fit Line Coefficients 584 Weighted Linear Regression 592 More Than One Input Variable 600 Lessons Learned 607 Chapter 13 Building Customer Signatures for Further Analysis 609 What Is a Customer Signature? 610 Designing Customer Signatures 617 Operations to Build Customer Signatures 622 Extracting Features 639 Summarizing Customer Behaviors 644 Lessons Learned 653 Chapter 14 Performance Is the Issue: Using SQL Effectively 655 Query Engines and Performance 656 Considerations When Thinking About Performance 660 Performance: Its Meaning and Measurement 663 Performance Improvement 101 665 Using Indexes Effectively 668 When OR Is a Bad Thing 683 Pros and Cons: Different Ways of Expressing the Same Thing 686 Window Functions 694 Lessons Learned 701 Appendix Equivalent Constructs Among Databases 703 Index 731
£37.05
Springer London Python Programming Fundamentals Undergraduate
Book Synopsishighlights the patterns which frequently appear when writing programs, reinforcing the application of these patterns for problem-solving through practice exercises; introduces the use of a debugger tool to inspect a program, enabling students to discover for themselves how programs work and enhance their understanding;Trade Review“The book emphasizes hands-on learning, which makes sense when learning programming. An undergraduate student that has a computer with a Python integrated development environment (IDE) and this book can learn a lot and do some interesting projects. The book is also suitable for high school students interested in programming assignments and projects. A highly readable and compact book, students and beginning programmers will like it.” (Naga Narayanaswamy, Computing Reviews, September, 2015)“The introduction is well written and enables you to configure the WingIDE within minutes and start using the book. At the end of each chapter, there are programming tasks, most of which are resolved quite well a few pages after. This is a big plus. … if you have passion for easy-to-install scripting languages and you are interested in Python – the book is quite OK for a start!” (Vitosh, Vitosh Academy, vitoshacademy.com, February, 2015)Table of ContentsIntroduction.- Decision Making.- Repetitive Tasks.- Using Objects.- Defining Functions.- Event-Driven Programming.- Defining Classes.- Appendix A: Integer Operators.- Appendix B: Float Operators.- Appendix C: String Operators and Methods.- Appendix D: List Operators and Methods.- Appendix E: Dictionary Operators and Methods.- Appendix F: Turtle Methods.- Appendix G: TurtleScreen Methods.- Appendix H: The Reminder! Program.- Appendix I: The Bouncing Ball Program.
£34.19
O'Reilly Media Macintosh Terminal Pocket Guide
Book SynopsisEvery Mac user knows how to work with windows and icons, but there is a wonderful application behind the scenes - the Terminal - that provides tremendous additional power. With this handy guide, you'll learn valuable commands that remove limits and open doors that many Mac users don't know exist.
£16.99
O'Reilly Beginning BeagleBone
Book SynopsisThis book introduces you to both the original BeagleBone and the BeagleBone Black and gets you started with projects that take advantage of the board's processing power and its ability to interface with the outside world.
£10.79
Morgan & Claypool Publishers Semantic Web for the Working Ontologist
Book SynopsisBrings Semantic Web practice to enterprise. Fabien Gandon joins Dean Allemang and Jim Hendler, to open up the story to a modern view of global linked data. Examples have been brought up to date and applied in a modern setting, where enterprise and global data come together as a living, linked network of data.Table of Contents Preface What is the Semantic Web? Semantic modeling RDF—the basis of the Semantic Web Semantic Web application architecture Linked data Querying the Semantic Web—SPARQL Extending RDF: RDFS and SCHACL RDF Schema RDFS-Plus Using RDFS-Plus in the wild SKOS—managing vocabularies with RDFS-Plus Basic OWL Counting and sets in OWL Ontologies on the Web—putting it all together Good and bad modeling practices Expert modeling in OWL Conclusions and future work Bibliography
£46.80
Association for Computing Machinery 6504698 Semantic Web for the Working Ontologist
Book SynopsisBrings Semantic Web practice to enterprise. Fabien Gandon joins Dean Allemang and Jim Hendler, to open up the story to a modern view of global linked data. Examples have been brought up to date and applied in a modern setting, where enterprise and global data come together as a living, linked network of data.Table of Contents Preface What is the Semantic Web? Semantic modeling RDF—the basis of the Semantic Web Semantic Web application architecture Linked data Querying the Semantic Web—SPARQL Extending RDF: RDFS and SCHACL RDF Schema RDFS-Plus Using RDFS-Plus in the wild SKOS—managing vocabularies with RDFS-Plus Basic OWL Counting and sets in OWL Ontologies on the Web—putting it all together Good and bad modeling practices Expert modeling in OWL Conclusions and future work Bibliography
£62.10
O'Reilly Media Getting Started with Intel Galileo
Book SynopsisGetting Started with the Intel Galileo gets you up and running with this new, x86-powered board that was developed in collaboration between Arduino and Intel. You'll learn how to set it up, connect it to your computer, and begin programming.
£13.05
O'Reilly Media Getting Started with Adafruit FLORA
Book SynopsisThis book shows you how to plan your wearable circuits, sew with electronics, and write programs that run on the FLORA to control the electronics. The FLORA family includes an assortment of sensors, as well as RGB LEDs that let you add lighting to your wearable projects.
£12.15
APress Learn Raspberry Pi Programming with Python
Book SynopsisLearn how to program your nifty new $35 computer to make a web spider, a weather station, a media server, and more. This book explores how to make a variety of fun and even useful projects, from a web bot to search and download files to a toy to drive your pets insane. Even if you''re completely new to programming in general, you''ll see how easy it is to create a home security system, an underwater photography system, an RC plane with a camera, and even a near-space weather balloon with a camera. You''ll learn how to use Pi with Arduino as well as Pi with Gertboard, an expansion board with an onboard ATmega microcontroller. Learn Raspberry Pi Programming with Python has been fully updated in this new edition to cover the features of the new boards. You''ll learn how to program in Python on your Raspberry Pi with hands-on examples and fun projects. What You''ll Learn Set up your new Raspberry Pi<Trade Review“Donat (independent scholar) provides a volume that is about equally divided between background material (Python, Circuits, the Raspberry Pi) and a set of stimulating ‘maker’ projects that combine coding, circuit-building, and mechanical construction. The writing style is casual but clear. … the determined hobbyist with sufficient experience will find the background material useful and the projects challenging, stimulating, and rewarding, and the book likewise serves as a useful resource for libraries hosting makerspaces.” (C. Vickery, Choice, Vol. 56 (6), February, 2019)Table of ContentsLearn Raspberry Pi Programming with Python · Chapter 1: Introduction to the Raspberry Pi · Chapter 2: Linux by the Seat of Your Pants · Chapter 3: Introduction to Python · Chapter 4: Electronics at 100 MPF · Chapter 5: The Web bot · Chapter 6: The Weather Station · Chapter 7: The Media Server · Chapter 8: The Home Security System · Chapter 9: The Cat Toy · Chapter 10: The Radio-controlled Airplane · Chapter 11: The Weather Balloon · Chapter 12: The Submersible · Chapter 13: The Raspberry Pi and the Arduino ·
£44.99
APress Complete Guide to Test Automation
Book SynopsisRely on this robust and thorough guide to build and maintain successful test automation. As the software industry shifts from traditional waterfall paradigms into more agile ones, test automation becomes a highly important tool that allows your development teams to deliver software at an ever-increasing pace without compromising quality. Even though it may seem trivial to automate the repetitive tester''s work, using test automation efficiently and properly is not trivial. Many test automation endeavors end up in the graveyard of software projects. There are many things that affect the value of test automation, and also its costs. This book aims to cover all of these aspects in great detail so you can make decisions to create the best test automation solution that will not only help your test automation project to succeed, but also allow the entire software project to thrive.One of the most important details that affects the success of the test automation is Table of Contents Part 1: The “Why” and the “What”.- Chapter 1: The Value of Test Automation.- Chapter 2: From Manual to Automated Testing.- Chapter 3: People and Tools.- Chapter 4: Reaching Full Coverage.- Chapter 5: Business Processes.- Chapter 6: Test Automation and Architecture.- Chapter 7: Isolation and Test Environments.- Chapter 8: The Big Picture.- Part 2: The “How”.- Chapter 9: Preparing for the Tutorial.- Chapter 10: Designing the First Test Case.- Chapter 11: Start Coding the First Test.- Chapter 12: Completing the First Test.- Chapter 13: Investigating Failure.- Chapter 14: Adding More Tests.- Chapter 15: Continuous Integration.- Chapter 16: Acceptance Test Driven Development.- Chapter 17: Unit tests and TDD.- Chapter 18: Other Types of Automated Tests.- Chapter 19: Where to Go from Here.- Appendix A: Real-World Examples.- Appendix B: Cleanup Mechanism.- Appendix C: Test Automation Essentials.- Appendix D: Tips and Practices for Programmer’s Productivity.-
£46.74
APress Practical Machine Learning and Image Processing
Book Synopsis Gain insights into image-processing methodologies and algorithms, using machine learning and neural networks in Python. This book begins with the environment setup, understanding basic image-processing terminology, and exploring Python concepts that will be useful for implementing the algorithms discussed in the book. You will then cover all the core image processing algorithms in detail before moving onto the biggest computer vision library: OpenCV. You''ll see the OpenCV algorithms and how to use them for image processing. The next section looks at advanced machine learning and deep learning methods for image processing and classification. You''ll work with concepts such as pulse coupled neural networks, AdaBoost, XG boost, and convolutional neural networks for image-specific applications. Later you''ll explore how models are made in real time and then deployed using various DevOps tools. All the concepTable of ContentsChapter 1: Installation and Environment Setup Chapter Goal: Making System Ready for Image Processing and Analysis No of pages 20 Sub -Topics (Top 2) 1. Installing Jupyter Notebook 2. Installing OpenCV and other Image Analysis dependencies 3. Installing Neural Network Dependencies Chapter 2: Introduction to Python and Image Processing Chapter Goal: Introduction to different concepts of Python and Image processing Application on it. No of pages: 50 Sub - Topics (Top 2) 1. Essentials of Python 2. Terminologies related to Image Analysis Chapter 3: Advanced Image Processing using OpenCV Chapter Goal: Understanding Algorithms and their applications using Python No of pages: 100 Sub - Topics (Top 2): 1. Operations on Images 2. Image Transformations Chapter 4: Machine Learning Approaches in Image Processing Chapter Goal: Basic Implementation of Machine and Deep Learning Models, which takes care of Image Processing, before applications in real-time scenario No of pages: 100 Sub - Topics (Top 2): 1. Image Classification and Segmentation 2. Applying Supervised and Unsupervised Learning approaches on Images using Python Chapter 5: Real Time Use Cases Chapter Goal: Working on 5 projects using Python, applying all the concepts learned in this book No of pages: 100 Sub - Topics (Top 5): 1. Facial Detection 2. Facial Recognition 3. Hand Gesture Movement Recognition 4. Self-Driving Cars Conceptualization: Advanced Lane Finding 5. Self-Driving Cars Conceptualization: Traffic Signs Detection Chapter 6: Appendix A Chapter Goal: Advanced concepts Introduction No of pages: 50 Sub - Topics (Top 2): 1. AdaBoost and XGBoost 2. Pulse Coupled Neural Networks
£46.74
APress Learn Keras for Deep Neural Networks
Book SynopsisLearn, understand, and implement deep neural networks in a math- and programming-friendly approach using Keras and Python. The book focuses on an end-to-end approach to developing supervised learning algorithms in regression and classification with practical business-centric use-cases implemented in Keras.The overall book comprises three sections with two chapters in each section. The first section prepares you with all the necessary basics to get started in deep learning. Chapter 1 introduces you to the world of deep learning and its difference from machine learning, the choices of frameworks for deep learning, and the Keras ecosystem. You will cover a real-life business problem that can be solved by supervised learning algorithms with deep neural networks. You''ll tackle one use case for regression and another for classification leveraging popular Kaggle datasets. Later, you will see an interesting and challenging part of deep learning: hyperparameter tuning; Table of ContentsSECTION 1: Prepares the reader with all the necessary gears to get started on the fast track ride in deep learning. Chapter 1: Deep Learning & Keras Chapter Goal: Introduce the reader to the deep learning and keras framework Sub -Topics 1. Exploring the popular Deep Learning frameworks2. Overview of Keras, Pytorch, mxnet, Tensorflow, 3. A closer look at Keras: What’s special about Keras? Chapter 2: Keras in Action Chapter Goal: Help the reader to engage with hands-on exercises with Keras and implement the first basic deep neural network Sub - Topics 1. A closer look at the deep learning building blocks 2. Exploring the keras building blocks for deep learning 3. Implementing a basic deep neural network with dummy data SECTION 2 – Help the reader embrace the core fundamentals in simple lucid language while abstracting the math and the complexities of model training and validation with the least amount of code without compromising on flexibility, scale and the required sophistication Chapter 3: Deep Neural networks for Supervised Learning Chapter Goal: Embrace the core fundamentals of deep learning and its development Sub - Topics: 1. Introduction to supervised learning 2. Classification use-case – implementing DNN 3. Regression use-case – implementing DNN Chapter 4: Measuring Performance for DNN Chapter Goal: Aid the reader in understanding the craft of validating deep neural networks Sub - Topics: 1. Metrics for success – regression 2. Analyzing the regression neural network performance 3. Metrics for success – classification 4. Analyzing the regression neural network performance SECTION 3 – Tuning and deploying robust DL models Chapter 5: Hyperparameter Tuning & Model Deployment Chapter Goal: Understand how to tune the model hyperparameters to achieve improved performance Sub - Topics: 1. Hyperparameter tuning for deep learning models 2. Model deployment and transfer learning Chapter 6: The Path Forward Chapter goal – Educate the reader about additional reading for advanced topics within deep learning. Sub - Topics: 1. What’s next for deep learning expertise? 2. Further reading 3. GPU for deep learning 4. Active research areas and breakthroughs in deep learning5. Conclusion
£35.99
APress Numerical Methods Using Java
Book SynopsisImplement numerical algorithms in Java using NM Dev, an object-oriented and high-performance programming library for mathematics.You'll see how it can help you easily create a solution for your complex engineering problem by quickly putting together classes.Numerical Methods Using Java covers a wide range of topics, including chapters on linear algebra, root finding, curve fitting, differentiation and integration, solving differential equations, random numbers and simulation, a whole suite of unconstrained and constrained optimization algorithms, statistics, regression and time series analysis. The mathematical concepts behind the algorithms are clearly explained, with plenty of code examples and illustrations to help even beginners get started. What You Will Learn Program in Java using a high-performance numerical library Learn the mathematics for a wide range of numerical computing algorithms Trade Review“The book is primarily a user’s guide to the NM DEV commercial software library … .” (Anthony J. Duben, Computing Reviews, December 6, 2022)Table of ContentsTable of ContentsAbout the Authors...........................................................................................................iPreface............................................................................................................................ii1. Why Java?..............................................................................................................61.1. Java in 2020.....................................................................................................61.2. Java vs. C++....................................................................................................61.3. Java vs. Python................................................................................................61.4. Java in the future .............................................................................................62. Data Structures.......................................................................................................72.1. Function...........................................................................................................72.2. Polynomial ......................................................................................................73. Linear Algebra .......................................................................................................83.1. Vector and Matrix ...........................................................................................83.1.1. Vector Properties .....................................................................................83.1.2. Element-wise Operations.........................................................................83.1.3. Norm ........................................................................................................93.1.4. Inner product and angle ...........................................................................93.2. Matrix............................................................................................................103.3. Determinant, Transpose and Inverse.............................................................103.4. Diagonal Matrices and Diagonal of a Matrix................................................103.5. Eigenvalues and Eigenvectors.......................................................................103.5.1. Householder Tridiagonalization and QR Factorization Methods..........103.5.2. Transformation to Hessenberg Form (Nonsymmetric Matrices)...........104. Finding Roots of Single Variable Equations .......................................................114.1. Bracketing Methods ......................................................................................114.1.1. Bisection Method ...................................................................................114.2. Open Methods...............................................................................................114.2.1. Fixed-Point Method ...............................................................................114.2.2. Newton’s Method (Newton-Raphson Method) .....................................114.2.3. Secant Method .......................................................................................114.2.4. Brent’s Method ......................................................................................115. Finding Roots of Systems of Equations...............................................................125.1. Linear Systems of Equations.........................................................................125.2. Gauss Elimination Method............................................................................125.3. LU Factorization Methods ............................................................................125.3.1. Cholesky Factorization ..........................................................................125.4. Iterative Solution of Linear Systems.............................................................125.5. System of Nonlinear Equations.....................................................................126. Curve Fitting and Interpolation............................................................................146.1. Least-Squares Regression .............................................................................146.2. Linear Regression..........................................................................................146.3. Polynomial Regression..................................................................................146.4. Polynomial Interpolation...............................................................................146.5. Spline Interpolation .......................................................................................147. Numerical Differentiation and Integration...........................................................157.1. Numerical Differentiation .............................................................................157.2. Finite-Difference Formulas...........................................................................157.3. Newton-Cotes Formulas................................................................................157.3.1. Rectangular Rule....................................................................................157.3.2. Trapezoidal Rule....................................................................................157.3.3. Simpson’s Rules.....................................................................................157.3.4. Higher-Order Newton-Coles Formulas..................................................157.4. Romberg Integration .....................................................................................157.4.1. Gaussian Quadrature..............................................................................157.4.2. Improper Integrals..................................................................................158. Numerical Solution of Initial-Value Problems....................................................168.1. One-Step Methods.........................................................................................168.2. Euler’s Method..............................................................................................168.3. Runge-Kutta Methods...................................................................................168.4. Systems of Ordinary Differential Equations.................................................169. Numerical Solution of Partial Differential Equations..........................................179.1. Elliptic Partial Differential Equations...........................................................179.1.1. Dirichlet Problem...................................................................................179.2. Parabolic Partial Differential Equations........................................................179.2.1. Finite-Difference Method ......................................................................179.2.2. Crank-Nicolson Method.........................................................................179.3. Hyperbolic Partial Differential Equations.....................................................1710..................................................................................................................................1811..................................................................................................................................1912. Random Numbers and Simulation ....................................................................2012.1. Uniform Distribution .................................................................................2012.2. Normal Distribution...................................................................................2012.3. Exponential Distribution............................................................................2012.4. Poisson Distribution ..................................................................................2012.5. Beta Distribution........................................................................................2012.6. Gamma Distribution ..................................................................................2012.7. Multi-dimension Distribution ....................................................................2013. Unconstrainted Optimization ............................................................................2113.1. Single Variable Optimization ....................................................................2113.2. Multi Variable Optimization .....................................................................2114. Constrained Optimization .................................................................................2214.1. Linear Programming..................................................................................2214.2. Quadratic Programming ............................................................................2214.3. Second Order Conic Programming............................................................2214.4. Sequential Quadratic Programming...........................................................2214.5. Integer Programming.................................................................................2215. Heuristic Optimization......................................................................................2315.1. Genetic Algorithm .....................................................................................2315.2. Simulated Annealing .................................................................................2316. Basic Statistics..................................................................................................2416.1. Mean, Variance and Covariance................................................................2416.2. Moment......................................................................................................2416.3. Rank...........................................................................................................2417. Linear Regression .............................................................................................2517.1. Least-Squares Regression..........................................................................2517.2. General Linear Least Squares....................................................................2518. Time Series Analysis ........................................................................................2618.1. Univariate Time Series..............................................................................2618.2. Multivariate Time Series ...........................................................................2618.3. ARMA .......................................................................................................2618.4. GARCH .....................................................................................................2618.5. Cointegration .............................................................................................2619. Bibliography .....................................................................................................2720. Index .....................................................................................................
£44.99
APress Practical Explainable AI Using Python
Book SynopsisLearn the ins and outs of decisions, biases, and reliability of AI algorithms and how to make sense of these predictions. This book explores the so-called black-box models to boost the adaptability, interpretability, and explainability of the decisions made by AI algorithms using frameworks such as Python XAI libraries, TensorFlow 2.0+, Keras, and custom frameworks using Python wrappers. You'll begin with an introduction to model explainability and interpretability basics, ethical consideration, and biases in predictions generated by AI models. Next, you'll look at methods and systems to interpret linear, non-linear, and time-series models used in AI. The book will also cover topics ranging from interpreting to understanding how an AI algorithm makes a decisionFurther, you will learn the most complex ensemble models, explainability, and interpretability using frameworks such as Lime, SHAP, Skater, ELI5, etc. Moving forward, youwill be introduced to model explainability for unstructurTrade Review“Practical explainable AI using Python combines textbook and cookbook elements. It provides explanations of concepts along with practical examples and exercises. … this book offers a comprehensive foundation that will remain relevant for some time. However, readers should supplement their knowledge with the latest research in order to stay up to date in this dynamic field.” (Gulustan Dogan, Computing Reviews, August 21, 2023)“While the book presents just fundamental aspects, I find this to be a great advantage. Indeed, even the layperson to AI/ML can use this work: the author starts with the most basic definitions and models, and then provides software examples … . This way a very broad readership is possible, since more advanced parts of the chapters will be interesting even for specialists in AI/ML who would like to increase their expertise in the title topic.” (Piotr Cholda, Computing Reviews, April 17, 2023)Table of ContentsChapter 1: Introduction to Model Explainability and InterpretabilityChapter Goal: This chapter is to understand what is model explainability and interpretability using Python. No of pages: 30-40 pages Chapter 2: AI Ethics, Biasness and Reliability Chapter Goal: This chapter aims at covering different frameworks using XAI Python libraries to control biasness, execute the principles of reliability and maintain ethics while generating predictions.No of pages: 30-40Chapter 3: Model Explainability for Linear Models Using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by linear models for supervised learning task, for structured dataNo of pages : 30-40Chapter 4: Model Explainability for Non-Linear Models using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by non-linear models, such as tree based models for supervised learning task, for structured dataNo of pages: 30-40Chapter 5: Model Explainability for Ensemble Models Using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by ensemble models, such as tree based ensemble models for supervised learning task, for structured data No of pages: 30-40Chapter 6: Model Explainability for Time Series Models using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by time series models for structured data, both univariate time series model and multivariate time series modelNo of pages: 30-40Chapter 7: Model Explainability for Natural Language Processing using XAI ComponentsChapter Goal: This chapter explains use of LIME, SKATER, SHAP and other libraries to explain the decisions made by models from text classification, summarization, sentiment classification No of pages: 30-40Chapter 8: AI Model Fairness Using What-If ScenarioChapter Goal: This chapter explains use of Google’s WIT Tool and custom libraries to explain the fairness of an AI modelNo of pages: 30-40Chapter 9: Model Explainability for Deep Neural Network ModelsChapter Goal: This chapter explains use of Python libraries to interpret the neural network models and deep learning models such as LSTM models, CNN models etc. using smooth grad and deep shiftNo of pages: 30-40Chapter 10: Counterfactual Explanations for XAI modelsChapter Goal: This chapter aims at providing counterfactual explanations to explain predictions of individual instances. The "event" is the predicted outcome of an instance, the "cause" are the particular feature values of this instance that were the input to the model that "caused" a certain prediction.No of pages: 30-40Chapter 11: Contrastive Explanation for Machine LearningChapter Goal: In this chapter we will use foil trees: a model-agnostic approach to extracting explanations for finding the set of rules that causes the explanation to be predicted the actual outcome (fact) instead of the other (foil)No of pages: 20-30Chapter 12: Model-Agnostic Explanations By Identifying Prediction InvarianceChapter Goal: In this chapter we will use anchor-LIME (a-LIME), a model-agnostic technique that produces high-precision rule-based explanations for which the coverage boundaries are very clear.No of pages: 20-30Chapter 13: Model Explainability for Rule based Expert System Chapter Goal: In this chapter we will use anchor-LIME (a-LIME), a model-agnostic technique that produces high-precision rule-based explanations for which the coverage boundaries are very clear.No of pages: 20-30Chapter 14: Model Explainability for Computer Vision.Chapter Goal: In this chapter we will use Python libraries to explain computer vision tasks such as object detection, image classification models.No of pages: 20-30
£46.74
APress Beginning Java 17 Fundamentals
Book SynopsisLearn the fundamentals of the Java 17 LTS or Java Standard Edition version 17 Long Term Support release, including basic programming concepts and the object-oriented fundamentals necessary at all levels of Java development.Table of Contents1. Programming Concepts 2. Setting Up the Environment 3. Writing Java Programs 4. Data Types 5. Operators 6. Statements 7. Classes and Objects 8. Methods 9. Constructors 10. Modules11. Object and Objects Classes 12. Wrapper Classes 13. Execution Handling 14. Assertions 15. Strings 16. Dates and Times 17. Formatting Data 18. Regular Expressions 19. Arrays 20. Inheritance 21. Interfaces 22. Enum Types 23. Java Shell Appendix A: Character Encodings Appendix B: Documentation Comments
£49.49
APress Practical C Design
Book SynopsisGo from competent C++ developer to skilled designer or architect using this book as your personal C++ design master class. Updated for the C++20 standard, this title will guide you through the design and implementation of an engaging case study that forms the backdrop for learning the art of applying design patterns and modern C++ techniques to create a high quality, robust application. Starting with a quick exploration of the requirements for building the application, you''ll delve into selecting an appropriate architecture, eventually designing and implementing all of the necessary modules to meet the project''s requirements. By the conclusion of Practical C++ Design, you''ll have constructed a fully functioning calculator capable of building and executing on any platform that supports both Qt and C++20. Access to the complete source code will help speed your learning. Utilize the Model-View-Controller pattern as the basis for the architecTable of ContentsPreface (5 pages)The preface details my motivation for writing the book, the target audience for the book, thegeneral structure of the book, and how to contact the author. Of particular importance is therationale behind choosing the case study, the target language (C++), and the GUI toolkit (Qt).Chapter 1: Defining the Case Study (6 pages)The first chapter describes, in detail, the case study to be examine in the book. The chapterdiscusses requirements in the abstract and then transitions to the calculator’s specific requirements.This sets the stage for the remainder of the book, which describes, in detail, the design andimplementation of the calculator, pdCalc, proposed in Chapter 1.1. A Brief Introduction2. A Few Words About Requirements3. Reverse Polish Notation (RPN)4. The Calculator’s Requirements5. The Source Code1The advice, information, and conclusions discussed in this book are those of the author and have not beenendorsed by, or reflect the opinions or practices of, ExxonMobil Corporation or its affiliates.5Chapter 2: Decomposition (18 pages)In this chapter, I explain the elements of a good decomposition and strategies for decomposing aproblem into manageable pieces. Subsequently, an architecture for pdCalc is selected, the calculatoris modularized, and use cases are used to develop interfaces for the high level calculator modules.The four high level modules are the stack, the command dispatcher, the user interface (subdividedinto a command line interface and a graphic user interface), and a plugin manager.1. The Elements of a Good Decomposition2. Selecting An Architecture3. Interfaces4. Assessment of Our Current Design5. Next StepsChapter 3: The Stack (20 pages)The stack is the first module discussed in detail. The stack is the fundamental data repositoryof the calculator. As part of the calculator’s design and implementation, the singleton pattern isexplored. The stack also affords the first opportunity to discuss an event system for the calculator,which provides a backdrop for exploration of the observer pattern, including the design andimplementation of reusable publisher and observer abstract classes.1. Decomposition of the Stack Module2. The Stack Class3. Adding Events4. A Quick Note on TestingChapter 4: The Command Dispatcher (32 pages)This chapter describes the design and implementation of the command dispatcher, the module ofthe calculator responsible for the creation, storage, and execution of commands. Of particular notein this chapter is the exposition on the command pattern and how it can be used to implement apractical undo/redo framework. In addition to exploring a traditional deep hierarchy method forimplementing commands, a C++11 alternative using lambda expressions and the standard functiontemplate are presented as a modern alternative design.1. The Decomposition of the Command Dispatcher2. The Command Class3. The Command Repository4. The Command Manager5. The Command Dispatcher6. Revisiting Earlier Decisions6Chapter 5: The Command Line Interface (14 pages)This chapter marks an important milestone, the creation of the first user executable program.In addition to building a simple command line interface, we’ll explore how to create an abstractsoftware interface suitable for both a command line interface and a graphical user interface. Withinthe context of the command line interface, we’ll learn techniques for simple parsing and tokenizingof input text streams.1. The User Interface Abstraction2. The Concrete CLI Class3. Tying It Together: A Working ProgramChapter 6: The Graphical User Interface (24 pages)In this chapter, we build the Qt-based graphical user interface for the calculator. Here, we’llexamine different strategies for building GUIs, abstraction of GUI elements, and modularization ofthe overall GUI design. Included in the discussion is design for the separation of on-screen widgetsfrom look-and-feel.1. Requirements2. Building GUIs3. Modularization4. A Working Program5. A Microsoft Windows Build NoteChapter 7: Plugins (38 pages)In this chapter, I describe how to build a cross-platform plugin system. This system includes theabstract interface for C++ plugins as well as the operating system specific mechanics involved withloading plugins and executing plugin functions. In the concrete case of the plugin loader, I explainthe many build tricks that can be used to handle cross-platform code and demonstrate how theabstract factory pattern provides an elegant design solution to this problem.1. What Is a Plugin?2. Problem 1: The Plugin Interface3. Problem 2: Loading Plugins4. Problem 3: Retrofitting pdCalc5. Incorporating Plugins6. A Concrete Plugin7. Next Steps7Chapter 8: New Requirements (24 pages)Any developer who has ever worked on a production software project quickly learns that newrequirements are always added late in the development cycle. In this chapter, we explore theaddition of new user requests after the original requirements have already been satisfied. Thediscussion progresses from fully implemented solutions to design only solutions to vague ideas forthe reader to explore on her own.1. Fully Designed New Features2. Designs Toward a More Useful Calculator3. Some Interesting Extensions for Self-ExplorationAppendix A: Acquiring, Building, and Executing pdCalc (4 pages)This appendix explains how to download the source code from GitHub and how to build the casestudy on Linux and Windows. Once the program is built, readers will want to execute the codeand its included test suite; execution instructions are therefore provided.1. Getting The Source Code2. Dependencies3. Building pdCalc4. Executing pdCalcAppendix B: Organization of the Source Code (6 pages)This appendix simply explains the organization of the source tree for pdCalc. This appendix isuseful for finding the locations for the source files referenced in the text.1. The src Directory2. The test DirectoryReferences (2 pages)This section lists twenty-nine references cited in the book.Index (3 pages)This section is a complete index for the book.
£35.99
APress Handson Matplotlib
Book SynopsisLearn the core aspects of NumPy, Matplotlib, and Pandas, and use them to write programs with Python 3. This book focuses heavily on various data visualization techniques and will help you acquire expert-level knowledge of working with Matplotlib, a MATLAB-style plotting library for Python programming language that provides an object-oriented API for embedding plots into applications.You'll begin with an introduction to Python 3 and the scientific Python ecosystem. Next, you'll explore NumPy and ndarray data structures, creation routines, and data visualization. You'll examine useful concepts related to style sheets, legends, and layouts, followed by line, bar, and scatter plots. Chapters then cover recipes of histograms, contours, streamplots, and heatmaps, and how to visualize images and audio with pie and polar charts.Moving forward, you'll learn how to visualize with pcolor, pcolormesh, and colorbar, and how to visualize in 3D in Matplotlib, create simple animations, and embed MatplTable of ContentsChapter 1: Getting Started with Python and Jupyter Notebook Chapter Goal: Introduce the reader to the basics of Python programming language, philosophy, and installation. We will also learn how to install it on various platforms. This chapter also introduces the readers to Python programming with Jupyter notebook. In the end, we will also have a brief overview of the constituent libraries of SciPy stack. No of pages - 26 Sub -Topics • Python Programming Language • Installing Python on various platforms • Python Modes • Python IDEs • Scientific Python Ecosystem • Overview of Jupyter Notebook • Setting up Jupyter Notebook • Running Code in Jupyter Notebook Chapter 2: Getting Started with NumPy Chapter Goal: Get started with NumPy Ndarrays and basics of NumPy library. The chapter covers the instructions for installation and basic usage of NumPy. No of pages: 9 Sub - Topics: · Introduction to the NumPy Ndarrays · Ndarray Properties · NumPy Constants Chapter 3 : NumPy Routines and Getting started with Matplotlib Chapter goal – In this chapter, we will discuss the various Ndarray creation routines available in NumPy. We will also get started with visualizations with Matplotlib. We will learn how to visualize the various numerical ranges with Matplotlib. No of pages: 15 Sub - Topics: · Routines for creating Ndarrays · Matplotlib · Visualization with NumPy and Matplotlib Chapter 4 : Revisiting Matplotlib Visualizations Chapter goal – This chapter is focused on learning the details of Matplotlib styles for visualizing NumPy Ndarrays. No of pages: 24 Sub - Topics: • Single Line Plots • Multiline plots • Grid, Axes, and Labels • Colors, Lines, and Markers • Subplots • Object Oriented Style • Working with the text Chapter 5 : Styles and Layouts Chapter goal – This chapter is focused on learning the details of Matplotlib styles and layouts. No of pages: 12 Sub - Topics: 1. Styles 2. layouts Chapter 6 : Line, Bar, and Scatter Plots Chapter goal – In this chapter, we will learn how to create nice visualizations with lines, bars, and scatter. No of pages: 14 Sub - Topics: · Lines and Logs · Errorbar · Bar Graphs · Scatter Plot Chapter 7 : Histograms, Contours, and Streamplots Chapter goal – In this chapter, we will learn how to create nice visualizations histograms, contours, and streamplots. No of pages: 15 Sub - Topics: • Histograms • Contours • Plot vector entities with streamplots Chapter 8 : Image and Audio Visualization Chapter goal – Learn to work with Image Processing using NumPy and Matplotlib. Also learn how to process and visualize audio data as waveforms. No of pages: 15 Sub - Topics: • Visualizing images • Interpolation Methods • Audio Visualization • Audio Processing Chapter 9 : Pie and Polar Charts Chapter goal – Learn to work with Pie and Polar charts. No of pages: 12 Sub - Topics: 1. Pie charts 2. Polar charts Chapter 10 : PColor, Pcolormesh, and Colorbar Chapter goal – In this chapter, we will learn Pcolor, Pcolormesh, and colorbar. No of pages: 10 Sub - Topics: 1. PColor 2. Pcolormesh 3. Colorbar Chapter 11 : 3D Visualizations in Matplotlib Chapter goal – In this chapter, we will learn how to create 3D visualizations. No of pages: 17 Sub - Topics: • Getting Ready • Plotting 3D Line • 3D Scatter plot • 3D Contours • Wireframe, Surface, and Sample Data • Bar graphs • Quiver and Stemplot • 3D Volumes Chapter 12 : Animations with Matplotlib Chapter goal – In this chapter, we will learn how to create simple animations with Matplotlib. No of pages: 8 Sub - Topics: • Animation Basics • Celluloid library Chapter 13 : More Recipes of Visualizations with Matplotlib Chapter goal – In this chapter, we will learn more types of visualizations with Matplotlib. No of pages: 14 Sub - Topics: · Visualizing Function as an image and a contour · 3D Vignette · Decorated Scatter Plots · Time plots and Signals · Filled Plots · Step Plots · Hexbins · XKCD Style Chapter 14 : Introduction to Pandas Chapter goal – Get started with Pandas data structures No of pages: 10 Sub - Topics: • Introduction to Pandas • Series in Pandas • Dataframe in Pandas Chapter 15 : Data Acquisition Chapter goal – Read the data from various sources No of pages: 18 Sub - Topics: • Plain Text File Handling • Handling CSV with Python • Python and Excel • Writing and reading files with NumPy • Reading the data from a CSV file with NumPy • Matplotlib CBook • Reading data from a CSV • Reading data from an Excel • Reading data from JSON • Reading data from Pickle • Reading data from Web • Reading data from Relation databases • Reading Data from the clipboard Chapter 16 : Visualizing Data with Pandas and Matplotlib Chapter goal – Get started with Data Visualization with Matplotlib No of pages: 25 • Simple Plots • Bar Graphs • Histogram • Box Plot • Area Plots • Scatter Plot • Hexagonal Bin Plot • Pie Charts Chapter 17 : Introduction to Data Visualization with Seaborn Chapter goal – Get started with Pandas and seaborn No of pages: 20 Sub - Topics: • What is Seaborn? • Plotting statistical Relationships • Plotting Lines • Visualizing the distribution of data Chapter 18 : Visualizing real-life Data with Matplotlib and Seaborn Chapter goal – Get started with COVID and Animal disease datasets and Visualize them No of pages: 20 Sub - Topics: • COVID-19 Pandemic Data • Fetching the Pandemic Data Programmatically • Preparing the data for visualization • Visualization with Matplotlib and Seaborn • Visualization of Animal Disease Data
£46.74
APress Beginning IntelliJ IDEA
Book SynopsisGet started quickly with IntelliJ, from installation to configuration to working with the source code and more. This tutorial will show you how to leverage IntelliJ's tools to develop clean, efficient Java applications. Author Ted Hagos will first walk you through buidling your first Java applications using IntelliJ. Then, he'll show you how to analyze your application, top to bottom; using version control and tools that allow you expand your application for big data or data science applications and more. You'll also learn some of the IDE's advanced features to fully maximize your application's capabilities.The last portion of the book focuses on application testing and deployment, and language- and framework- specific guidelines. After reading this book and working through its freely available source code, you'll be up to speed with this powerful IDE for today's Java development.What You Will LearnUse IntelliJ IDEA to build Java applicationsSet up your IDE and projectWork with sourcTable of Contents1. Install IntelliJ2. Getting Started3. Configuring the IDE4. Configuring Projects5. Working with Source Code6. Building Applications7. Analyzing Applications8. Version Control9. Big Data / Data Science Tools10. Other Tools11. Advanced IDE Features12. Migration Guides13. Language and Framework Specific Guidelines14. Testing 15. Deployment
£37.99
APress DataDriven Alexa Skills
Book SynopsisDesign and build innovative, custom, data-driven Alexa skills for home or business. Working through several projects, this book teaches you how to build Alexa skills and integrate them with online APIs. If you have basic Python skills, this book will show you how to build data-driven Alexa skills. You will learn to use data to give your Alexa skills dynamic intelligence, in-depth knowledge, and the ability to remember. Data-Driven Alexa Skills takes a step-by-step approach to skill development. You will begin by configuring simple skills in the Alexa Skill Builder Console. Then you will develop advanced custom skills that use several Alexa Skill Development Kit features to integrate with lambda functions, Amazon Web Services (AWS), and Internet data feeds. These advanced skills enable you to link user accounts, query and store data using a NoSQL database, and access real estate listings and stock prices via web APIs. What You Will LearnSet up and configure your development environmTable of ContentsPart I: Getting Started Chapter 1: Voice User Interfaces Chapter 2: Routines and Blueprints Chapter 3: The Developer Accounts Chapter 4: Creating the VUI for a Custom Data-driven Skill Chapter 5: Writing the Back-end Code Chapter 6: Publishing an Alexa Skill Part II: Custom Skill Development Chapter 7: Custom Alexa Skills Chapter 8: Beyond Hello World Chapter 9: Configuring the VUI Chapter 10: Using APL to Present on Screens Chapter 11: Coding the Lambda Function Chapter 12: Unit Testing an Alexa Skill Chapter 13: Storing the Data Part III: Using APIs in Advanced Skills Chapter 14: A Personal Net Worth Skill Chapter 15: The Real Estate API Chapter 16: The Stock Market API Chapter 17: What’s Next?
£46.74
APress Spring REST
Book SynopsisDesign and develop Java-based RESTful APIs using the latest versions of the Spring MVC and Spring Boot frameworks. This book walks you through the process of designing and building a REST application while delving into design principles and best practices for versioning, security, documentation, error handling, paging, and sorting. Spring RESTprovides a brief introduction to REST, HTTP, and web infrastructure. You will learn about several Spring projects such as Spring Boot, Spring MVC, Spring Data JPA, and Spring Security, and the role they play in simplifying REST application development. You will learn how to build clients that consume REST services. Finally, you will learn how to use the Spring MVC test framework to unit test and integration test your REST API. After reading this book, you will come away with all the skills to build sophisticated REST applications using Spring technologies. What You Will LearnBuild Java-based microservices, native cloud, or any applications uTable of Contents1. Introduction to REST2. Spring MVC & Spring Boot Primer3. RESTful Spring4. Beginning the QuickPoll Application5. Error Handling6. Documenting REST Services7. Versioning, Paging, and Sorting8. Security9. Clients and Testing10. HATEOASA. Installing cURL on Windows
£26.99
APress Introducing Qt 6
Book SynopsisGet started quickly with Qt, the popular open source C++ framework for building C++-based applications and games. This book will have you building both fully functional desktop and mobile applications in no time, including some simple game applications. Introducing Qt 6 begins by guiding you in setting up your tools and environment, and then walks you through the first baby steps of Qt framework. Next, you''ll learn the basics of how project and app structure are set up using Qt. Then, you''ll begin your first real hands-on projects using Qt, including a task and problem management application and two games. As you progress, you can enhance these apps and games using additional Qt components and features. The book then delves into advanced topics in Qt, learning above and beyond what the Qt docs can offer, including local storage, C++ integration, deployment to Windows and Android, custom components and how to work with them. UpTable of ContentsPart 11. IntroductionPart 2 - Content2. Setting up the Tools 3. First Baby Steps with Qt4. Explaining the Basics of Project and App Structure5. First Real Projects6. Taskmaster7. Hang-Man Game8. Rock, Paper, Scissors GamePart 3 - Components, Features and Things9. Components10. Features 11. Writing Diagrams in Qt12. Advanced Topics in Qt
£46.74
APress Java 17 Recipes
Book SynopsisQuickly find solutions to dozens of common programming problemsencountered while building Java applications, with recipes presented in the popular problem-solution format. Look up the programming problem that you want to resolve. Read the solution. Apply the solution directly in your own code. Problem solved!Java 17 Recipes is updated to reflect changes in specification and implementation since the Java 9 edition of this book. Java 17 is the next long-term support release (LTS) of the core Java Standard Edition (SE) version 17 which also includes some of the features from previous short term support (STS) releases of Java 16 and previous versions.This new edition covers of some of the newest features, APIs, and more such as pattern matching for switch, Restore Always-Strict-Floating-Point-Semantics, enhanced pseudo-random number generators, the vector API, sealed classes, and enhancements in the use of String. Source code for all recipes is available in a dedicated GitHub repository. Table of Contents1. Getting Started with Java 172. Java 17 Enhancements3. Strings4. Numbers and Dates5. Object-Oriented Java6. Lambda Expressions7. Data Structures and Collections8. Input and Output9. Exceptions and Logging10. Concurrency11. Debugging and Unit Testing12. Unicode, Internationalization, and Currency Codes13. Working with Databases14. JavaFX Fundamentals15. Graphics with JavaFX16. Media with JavaFX17. Java Web Applications18. Nashorn and Scripting19. E-mail20. JSON and XML Processing21. Networking22. Java Modularity
£49.49
APress Java Design Patterns
Book SynopsisUse the step-by-step approach of this book to learn and implement design patterns in real-world applications. It focuses on classical design patterns with Java 17 and Eclipse (2021-09). In addition to Gang of Four (GoF) design patterns, the book covers popular and alternative design patterns and includes criticisms of design patterns in a chapter on anti-patterns. The book is divided into four parts. Part one covers the SOLID design principles and the Simple Factory pattern. Part two covers the 23 (GoF) design patterns, including the creational patterns, structural patterns, and behavioral patterns. Part three covers alternative design patterns, including the Null Object pattern, and the model-view-controller (MVC) pattern. Part four covers criticisms of design patterns with a quick overview of anti-patterns. It also includes a chapter on FAQs on design patterns.The book also includes a chapter on FAQs on design patterns. Each pattern is explained with realTable of Contents Part-I: FoundationChapter 1: SOLID PrinciplesChapter Goal: To discuss all the 5 fundamental design principles-SRP, OCP, LSP, ISP, and DIPSub - Topics SRP, OCP, LSP, ISP, and DIPChapter 2: Simple Factory PatternChapter Goal: To discuss the simple factory pattern a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. It is the foundation for the factory method pattern and abstract factory pattern in Part II.Part-II: Gang of Four Design Patterns2.A: Creational PatternsChapter 3: Factory Method PatternChapter Goal: To discuss the factory method pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 4: Abstract Factory PatternChapter Goal: To discuss the abstract factory pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 5: Prototype PatternChapter Goal: To discuss the prototype pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 6: Builder PatternChapter Goal: To discuss the builder pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 7: Singleton PatternChapter Goal: To discuss the singleton pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. 2.B: Structural PatternsChapter 8: Proxy PatternChapter Goal: To discuss the proxy pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 9: Decorator PatternChapter Goal: To discuss the decorator pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 10: Adapter PatternChapter Goal: To discuss the adapter pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 11: Facade PatternChapter Goal: To discuss the facade pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 12: Flyweight PatternChapter Goal: To discuss the flyweight pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 13: Composite PatternChapter Goal: To discuss the composite pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 14: Bridge PatternChapter Goal: To discuss the bridge pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. 2.C: Behavioral PatternsChapter 15: Visitor PatternChapter Goal: To discuss the visitor pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 16: Observer PatternChapter Goal: To discuss the observer pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 17: Strategy PatternChapter Goal: To discuss the strategy pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 18: Template Method PatternChapter Goal: To discuss the template method pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 19: Command PatternChapter Goal: To discuss the command pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 20: Iterator PatternChapter Goal: To discuss the iterator pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 21: Memento PatternChapter Goal: To discuss the memento pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 22: State PatternChapter Goal: To discuss the state pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 23: Mediator PatternChapter Goal: To discuss the mediator pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 24: Chain of Responsibility PatternChapter Goal: To discuss the chain of responsibility pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 25: Interpreter PatternChapter Goal: To discuss the interpreter pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Part-II: Additional Design PatternsChapter 26: Null Object PatternChapter Goal: To discuss the null object pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Chapter 27: MVC PatternChapter Goal: To discuss the MVC pattern with the GoF definition and the core concept behind that with a real-life example and a computer world example. The chapter ends with a concrete implementation and its corresponding output. Part-III: Final talks on Design PatternsChapter 28: Criticism to Design PatternsChapter Goal: To discuss the criticism to design patternsChapter 29: Brief overview of Anti-PatternsChapter Goal: To discuss the anti-patternsChapter 30: FAQChapter Goal: This chapter will consist of the frequently asked questions to help readers with a quick revision. This chapter will also clear the doubts that may arise among similar patterns.
£49.49
APress C 10 Quick Syntax Reference
Book SynopsisDiscover what's new in C# and .NET for Windows programming. This book isa condensed code and syntax reference to the C# programming language, updated with the latest features of version 10 for .NET 6.You'll review the essential C# 10 and earlier syntax, not previously covered, in a well-organized format that can be used as a handy reference. Specifically, unions, generic attributes, CallerArgumentExpression, params span, Records,Init only setters,Top-level statements,Pattern matching enhancements,Native sized integers,Function pointers and more. You'll find a concise reference to the C# language syntax: short, simple, and focused code examples; a well laid out table of contents; and a comprehensive index allowing easy review. You won't find any technical jargon, bloated samples, drawn-out history lessons, or witty stories. What you will find is a language reference that is to the point and highly accessible.The book is a must-have for any C# programmer. What You Will LearnEmploy nuTable of Contents1. Hello World2. Compile and Run3. Variables4. Operators5. Strings6. Arrays7. Conditionals8. Loops9. Methods10. Class11. Inheritance12. Redefining Members13. Access Levels14. Static15. Properties16. Indexers17. Interfaces18. Abstract19. Namespaces20. Enum21. Exception Handling22. Operator Overloading23. Custom Conversions24. Struct25. Preprocessors26. Delegates27. Events28. Generics29. Constants30. Asynchronous Methods
£25.19
APress Automated Deep Learning Using Neural Network
Book SynopsisOptimize, develop, and design PyTorch and TensorFlow models for a specific problem using the Microsoft Neural Network Intelligence (NNI) toolkit. This book includes practical examples illustrating automated deep learning approaches and provides techniques to facilitate your deep learning model development. The first chapters of this book cover the basics of NNI toolkit usage and methods for solving hyper-parameter optimization tasks. You will understand the black-box function maximization problem using NNI, and know how to prepare a TensorFlow or PyTorch model for hyper-parameter tuning, launch an experiment, and interpret the results. The book dives into optimization tuners and the search algorithms they are based on: Evolution search, Annealing search, and the Bayesian Optimization approach. The Neural Architecture Search is covered and you will learn how to develop deep learning models from scratch. Multi-trial and one-shot searching approaches of automatic neural networTable of ContentsChapter 1: Introduction to Neural Network Intelligence1.1 Installation1.2 Trial, search space, experiment1.3 Finding maxima of multivariate function1.4 Interacting with NNIChapter 2:Hyper-Parameter Tuning2.1 Preparing a model for hyper-parameter tuning2.2 Running experiment2.3 Interpreting results2.4 DebuggingChapter 3: Hyper-Parameter TunersChapter 4: Neural Architecture Search: Multi-trial4.1 Constructing a search space4.2 Running architecture search4.3 Exploration strategies4.4 Comparing exploration strategiesChapter 5: Neural Architecture Search: One-shot5.1 What is one-shot NAS?5.2 ENAS5.3 DARTSChapter 6: Model Compression6.1 What is model compression?6.2 Compressing your model6.3 Pruning6.4 QuantizationChapter 7: Advanced NNI
£46.74
APress Pragmatic Python Programming
Book SynopsisExplore the world of programming languages through Python and learn the building blocks of writing programs. This book covers Python 3.10, explaining it through six key concepts. Each chapter contains a real-world example with practical advice and a section on advanced concepts. You''ll start by reviewing the concept of expressions and functions, which are two of the core building blocks of programming languages. You''ll then move on to object-oriented concepts to help gain a practical understanding of Python, along with a chapter on control flow constructs. The book also takes a close look at sequences, explaining constructs and additional types, and wraps up with a chapter on modules, focusing on how to use and create packages. Whether you''re new to programming or already an experienced developer, upon finishing this book, you will have a solid understanding of Python''s state-of-the-art development features.WhatTable of ContentsChapter 1: Expression- Explains expression as the first key concept of a programming language.1.1. What is an expression?1.2. Expressions containing different types1.3. Variable names1.4. Statements1.5. Deleting variable names1.6. Further language constructs1.7. Expressions and statements in practice1.8. References:Chapter 2: Function- Explains function as the second most important building block.2.1. What is a function?2.2. Calling functions2.3. Functions with side effects2.4. Function parameters2.5. Defining functions2.6. Referencing to variable and function names2.7. Function as parameter2.8. Embedded function definitions2.9. Function in practice2.10. ReferencesChapter 3: Class- Explains object-oriented concepts as everything is an object in Python.3.1. What is object-oriented programming?3.2. What is a class?3.3. Creating objects3.4. Using attributes and methods3.5. Defining classes3.6. Connection between classes3.7. Properties3.8. Inheritance3.9. Embedded classes3.10. Special methods3.11. Classes in practice3.12. ReferencesChapter 4. Control flow- Explains what control flow constructs and everything related to it (exceptions, recursion, etc.)4.1. What is control flow?4.2. Conditional statement4.3. Condition-controlled loops4.4. Count-controlled loops4.5. Exception handling4.6. Context management4.7. ReferencesChapter 5: Sequence- Explains the list like constructs and additional container types.5.1. What is a sequence?5.2. List and its operations5.3. List comprehension5.4. Tuples 5.5. Dictionaries5.6. Sets5.7. ReferencesChapter 6: Module- Explains how to use and create packages.6.1. What is a module?6.2. Built-in modules6.3. Create your own modules6.4. Packages6.5. Package management6.6. Interesting third party packages6.7. References
£35.99
APress Programming 101
Book SynopsisProgramming permeates almost all aspects of our lives. This includes being active on social media, shopping online, and participating in virtual courses. It also includes driving a car and using many devices. This book will teach you the basics of programming using the Processing programming language and provide practice with logical, algorithmic thinking. It can provide insight into what is involved in producing the technical infrastructure of our world. While reading this book, you can build programs based on your own ideas, using images you create or acquire and making connections to activities you enjoy.The chapters in the book will demonstrate the process of programming, starting with formulating an idea, planning, building on past projects, and refining the work, similar to writing an essay or composing a song. This approach will guide you to make use of logic and mathematics to produce beautiful effects. The text contains an Appendix with an introductiTable of Contents1. Basics2. Interactions3. Animation Using Arrays and Parallel Structures4. Classes 5. More Interactions6. Images, Graphics, and Building on Prior Work7. Using Files for Making a Holiday Card8. Combining Videos, Images, and Graphics9. Hangman10. 3DAppendix: Processing and JavaScript: p5.js
£46.74
APress Learn JavaFX Game and App Development
Book SynopsisUnderstand real-world game development concepts using JavaFX game engine called FXGL. The core focus of the book is on developing a standalone game or application with FXGL. We will start with an overview of the book followed by requisite concepts from Java and JavaFX that will be used throughout this book. Next, we will learn about the FXGL game engine and its wide range of real-world game development techniques. In the following chapter, we learn about entity-component model used in FXGL to create a powerful abstraction of the game world. The next chapter builds on this, where we develop a platformer game using the physics engine and a popular external tool called Tiled. An important concept of games AI is covered in the following chapter. Visually complex features related to graphics and rendering as well as UI elements and animation system in FXGL will be discussed in the next chapter. The following chapter is dedicated to non-game applications that can be developed usTable of ContentsChapter 1: IntroductionChapter Goal: Sets the scene for the book, provides an overview and sets expectationsChapter 2: Requisite Java and JavaFX ConceptsChapter Goal: Covers fundamental knowledge required to understand the book contentSub-topics: Java programmingJavaFX scene graphJavaFX model of programmingJavaFX conceptsChapter 3: FXGL ArchitectureChapter Goal: Provides an overview of the FXGL architecture, features, and capabilitiesChapter 4: Entity-Component Case Study: Develop Arcade GamesChapter Goal: Introduction to entity-component model used for abstracting game worldsSub-topics: Game worldEntity-Component modelPong and Breakout style gamesChapter 5: Physics Case Study: Develop a Platformer Game Chapter Goal: Introduction to lightweight and heavyweight physics engines in FXGLSub-topics: Collision detectionRigid body dynamicsMario style gameChapter 6: AI Case Study: Develop a Maze Action GameChapter Goal: Provides a foundation for using and developing AI agents in FXGLSub-topics: A* pathfindingGraph theoryComponent-driven behaviorPac-man style gameChapter 7: Graphics and UI Case Study: Develop a Top-Down Shooter GameChapter Goal: Introduction to the particle and animation systems used in FXGLSub-topics: Particle systemMulti-layer renderingAnimationsInterpolationsGeometry wars style gameChapter 8: Developing General-Purpose ApplicationsChapter Goal: Provide information on how FXGL can be used in non-game contextsChapter 9: Cross-platform DeploymentChapter Goal: Demonstrates the package and deployment process with FXGLSub-topics: jlinkNative imagesGluon toolsMobile developmentChapter 10: ConclusionChapter Goal: Recap what was covered in the chapters, provides external resources and ideas for future projects
£42.49
APress Test Your Skills in C Programming
Book SynopsisReview the fundamental constructs in C# using Q&As and program segments to boost your confidence and gain expertise. This book will help you analyze your programs more efficiently and enhance your programming skills.The book is divided into three parts, where you will learn the fundamentals, object-oriented programming, and some advanced features of C#. In the first part, you will review C# and .NET basics along with the important constructs such as strings, arrays, and structures. In the second part, you''ll review the concepts of object-oriented programming in detail. Here, you will go through various program segments in class and objects, inheritance, polymorphism, abstraction, encapsulation, and much more. You will also analyze the output of the given programs with the help of Q&A sections. The uses of interfaces, static class, and exception handling are discussed in the book along with some other important concepts in C#. In the third and last part, you will learn aTable of ContentsPart I Fundamentals Chapter 1: Language Basics Chapter Goal: This chapter discusses the following topics: The important concepts in .NET The basic programming constructs in C#. Use of some useful data types including the var type. Use of some useful operators and explicit-casting. Use of the selection statements and case guards. Use of iteration statements. Use of the jump statements. Use of the ternary operator. No of pages: 28 Sub - Topics N Chapter 2: String and Arrays Chapter Goal: Once you finish this chapter, you can answer the following questions and related areas: How can you use string datatype in your program? How can you use the common in-built methods from the String class? How a String variable is different from a StringBuilder? How can you convert a string to an int? How can you use nullable reference type in a program? How to create arrays in C#? What are the different types of C# arrays and how to use them? How to use common in-built methods from the System.Array class? How can you iterate over a string or an array? No of pages 23 Sub - Topics NA Chapter 3: Enumeration and Structures Chapter Goal: This chapter discusses the following topics: The enum fundamentals Flags enumeration Defaut value expressions The struct fundamentals Non-destructive mutations No of pages: 26 Sub - Topics NA Part II Object-Oriented Programming Chapter 4: Class and Objects Chapter Goal: This chapter focuses on the following topics: Classes and objects creations. Instance fields and methods. Constructors and their usage. Optional parameters. Object initializers. Nested classes. The uses of private, internal, and public modifiers inside a class. No of pages: 17 Sub - Topics NA Chapter 5: Inheritance Chapter Goal: This chapter covers the following topics: Inheritance and types. Method and constructor overloading. Method overriding. Use of virtual, override, and new keywords. Use of the sealed keyword. Introductory discussion on covariance and contravariance No of pages 33 Sub - Topics NA Chapter 6: Polymorphism Chapter Goal: This chapter helps you to review: Polymorphism and its benefits. Abstract classes and their uses. Interfaces and their uses. Different types of interfaces. Writing polymorphic codes using abstract classes and interfaces No of pages: 30 Sub - Topics NA Chapter 7: Encapsulation Chapter Goal: This chapter covers the following topics: What is encapsulation? How is it different from an abstraction? Properties and their usage. Different ways to create a property. The usage of the get and set accessors. Virtual and abstract properties. The discussion of the init accessor. Indexers and their usage. How can the indexers and properties work with an interface? Discussion on different aspects of properties and indexers. No of pages: 26 Sub - Topics NA Chapter 8: Exception Handling Chapter Goal: This chapter covers the following topics: Exception and its uses in C# programming. Use of the try, catch, and finally blocks. Use of multiple catch blocks in a program. Use of a general catch block. How to throw and re-throw an exception. Use of exception filters. Custom exception class and its usage. No of pages: 23 Sub - Topics NA Chapter 9: Useful Concepts Chapter Goal: Q&A and program segments on some useful constructs such as casting and boxing, static class and methods, passing value type by value, passing value type by references(using ref and out keyword), extension methods, and so on. No of pages: 15-25+ Sub - Topics NA Part III Advanced Features Chapter 10: Delegates Chapter Goal: This chapter covers the following topics: Delegates and their uses Multicast delegates Some commonly used in-built delegates Covariance and contravariance using delegates No of pages: 20 Sub - Topics NA Chapter 11: Events Chapter Goal: This chapter helps you to review your understanding of events and discusses the following: Events creation and their uses. How to pass the event data. Use of event accessors. Use of interface events (both implicit and explicit). Simplified coding with events. No of pages: 22 Sub - Topics NA Chapter 12: Lambdas Chapter Goal: This chapter focuses on this and covers the following topics: Lambda expressions and their use Expression-bodied members Use of local variables inside lambda expressions. Event handling using lambda expressions. Use of a static lambda. Understanding natural type. No of pages: 22 Sub - Topics NA Chapter 13: Generics Chapter Goal: This chapter focuses on the following topics: The motivation behind generics. The fundamentals of generic programs. Use of generic interfaces. Use of generic constraints. Use of covariance and contravariance using generics. Self-referencing generic type. Experimenting with generic method’s overloading and overriding. Analyzing the static data in the context of generics. No of pages: 35 Sub - Topics NA Chapter 14: Multithreading Chapter Goal: Upon completion of this chapter, you’ll be able to answer the following questions: What are the threads and how can you create them? What is a multithreaded program? How does it differ from a single-threaded application? Why are the ThreadStart and ParameterizedThreadStart delegates important in thread programming? How to block a thread using Sleep or Join methods? How can you use lambda expressions in a multithreaded program? How to use important Thread class members? How a foreground thread is different from a background thread? What is synchronization and why is it needed? How can you implement thread safety in C# using lock statements? How can you implement an alternative approach to lock statements using Monitor’s Entry and Exit Method? What is a deadlock and how can you detect the deadlock in your system? What is the purpose of using the ThreadPool class? What are the associative pros and cons of using it? How to cancel a running thread in the managed environment? And many more. No of pages: 40 Sub - Topics NA Chapter 15: Miscellaneous Chapter Goal: Q&A and program segments on the related latest features that are covered in the previous chapters and any other important topics(if any). No of pages: 10-20+ Sub - Topics NA
£46.74
APress Reinforcement Learning for Finance
Book SynopsisThis book introduces reinforcement learning with mathematical theory and practical examples from quantitative finance using the TensorFlow library. Reinforcement Learning for Finance begins by describing methods for training neural networks. Next, it discusses CNN and RNN two kinds of neural networks used as deep learning networks in reinforcement learning. Further, the book dives into reinforcement learning theory, explaining the Markov decision process, value function, policy, and policy gradients, with their mathematical formulations and learning algorithms. It covers recent reinforcement learning algorithms from double deep-Q networks to twin-delayed deep deterministic policy gradients and generative adversarial networks with examples using the TensorFlow Python library. It also serves as a quick hands-on guide to TensorFlow programming, covering concepts ranging from variables and graphs to automatic differentiation, layers, models, andloss functions. After completing this boTable of ContentsChapter 1 Overview 1.1 Methods for Training Neural NetworksChapter 2 Convolutional Neural Networks 2.1 A Simple CNN 2.2 Identifying Technical Patterns in Security PricesChapter 3 Recurrent Neural Networks 3.1 LSTM Network 3.2 LSTM Application: Correlation in Asset Returns Chapter 4 Reinforcement Learning 4.1 Basics 4.2 Methods For Estimating MDP 4.3 Value Estimation Methods 4.4 Policy Learning 4.5 Actor-Critic Algorithms 4.6; Implementation of algorithms to quantitative finance using TensorFlow - 1Chapter 5 Recent Advances in Reinforcement Learning Algorithms 5.1 Double Deep Q-Network: DDQN 5.2 Dueling Double Deep Q-Network 5.3 Noisy Networks 5.4 Deterministic Policy Gradient
£25.19
APress Beginning Java Objects
Book SynopsisAs a programming language, Java's object-oriented nature is key to creating powerful, reusable code and applications that are easy to maintain and extend.That being said, many people learn Java syntax without truly understanding its object-oriented roots, setting them up to fail to harness all of the power of Java. This book is your key to learning both!This new third edition of Beginning Java Objects: From Concepts to Codediscusses Java syntax, object principles, and how to properly structure the requirements of an application around an object architecture. It is unique in that it uses a single case study of a Student Registration System throughout the book, carrying the reader from object concepts, to object modeling, to building actual code for a full-blown application. A new chapter covers a technology-neutral discussion of the principles of building a three-tier architecture using Java, introducing the notion of model layer presentation layer data layer separation. Coding eTable of ContentsPart I: The ABCs of ObjectsChapter 1: Abstraction and ModelingChapter Goal: Introducing the mechanism of abstraction as a natural way for humans to interpret the world, and how this relates to object modeling in the software realm.Subtopics:• Simplification through abstraction• Generalization through abstraction• Reusing abstractionsChapter 2: Some Java BasicsChapter Goal: Provide the reader with an immediate introduction to Java language fundamentals so that object concepts can be illustrated using Java code examples as soon as we begin introducing them in chapter 3.Subtopics:• Strengths of the Java language• Primitive Java types• The anatomy of a Java program• Mechanics of compiling and running a Java program• Java’s block structured nature• Elements of Java programming styleChapter 3: Objects and ClassesChapter Goal: Explain the basic building blocks of an OO application – classes as mini-abstractions aka templates for creating object instances.Subtopics:• Advantages of an OO approach to software development over a non-OO approach• How classes are used to specify a type of object’s data • How objects are created (instantiated) at run time• The use of reference variables to refer to objects symbolicallyChapter 4: Object InteractionsChapter Goal: Explain how object behaviors are defined as methods within classes, and how objects collaborate by invoking one another’s methods to accomplish the overall mission of the system.Subtopics:• How methods are used to specify an object’s behaviors• The anatomy of a Java method• How objects send messages to one another to accomplish collaboration• How classes use public and private visibility to publicize what services a type of object can perform while hiding both the logic for how the service is accomplished and the internal data structure needed to support the service• The use of constructors to instantiate the state of an object when first instantiated Chapter 5: Relationships Between ObjectsChapter Goal: Explains the notion of a structural relationship between two objects, wherein the data structures of the classes to which they belong are designed to maintain lasting relationships between objects once instantiated. The two main approaches to accomplishing this are (a) encoding associations between two classes of objects as reference variables within their data structures, (b) having one class inherit and extend the capabilities of another.Subtopics:• Types of structural relationships maintained by objects: associations, aggregations, inheritance• The inheritance mechanism, and guidelines for what we can and cannot achieve when deriving new classes via inheritance• Revisiting constructors regarding some complexities that must be understood when inheritance is involvedChapter 6: Collections of ObjectsChapter Goal: Introduce a special category of objects (classes) known as collections, to be used for efficiently managing an indefinite number of objects of the same type.Subtopics:• The properties of three generic collection types: ordered lists, sets, and dictionaries• The specifics of several different commonly-used built-in Java collection types• The concept of Java packages as logical groupings of classes, and the use of import statements• The power of collections in modeling very sophisticated real-world scenarios• Design techniques for programmer-defined collection typesChapter 7: Some Final Object ConceptsChapter Goal: Covers several key but often misunderstood advanced language features that are essential to taking full advantage of Java’s object-oriented nature: polymorphism (how a single line of code representing a method invocation can exhibit a variety of different behaviors at run time); abstract methods, classes, and interfaces; and static features (data/methods belonging to an entire class of objects versus objects individually).Subtopics:• The runtime mechanism of polymorphism• Abstract classes and methods• The incredible power of interfaces in streamlining Java code• Static featuresPart II: Object Modeling 101Chapter 8: The Object Modeling Process in a NutshellChapter Goal: A high-level overview of how to approach the requirements of a system so as to structure it from the ground up to take advantage of all of the strengths of an OO language like Java.Subtopics:• The goals of and philosophy begin object modeling• Flexibility in terms of selecting or devising a modeling methodology• The pros and cons of using object modeling software toolsChapter 9: Formalizing Requirements Through Use CasesChapter Goal: Explains the importance of developing use cases when establishing requirements for an application, to ensure that (a) all categories of intended user are identified, (b) all of the services that each user category will expect the system to provide, and (c) what their expectations are of the desired outcome for each of the service types.Subtopics:• Introduction to use cases• The notion of actors • Involving users in defining use cases• Approaches to documenting/diagramming use casesChapter 10: Modeling the Data Aspects of the SystemChapter Goal: Illustrate the process by which the types of classes, their respective data structures, and their interrelationships can be discovered and rendered graphically using UML notation.Subtopics:• Technique for identifying the appropriate classes and their respective attributes• Technique for determining the structural relationships that exist among these classes• How to graphically portray this information in proper UML notationChapter 11: Modeling the Behavioral Aspects of the SystemChapter Goal: Revisiting the evolving object model of chapter 10 to reflect the services/behaviors/methods required of each identified class to ensure that the overall requirements of the application will be satisfied.Subtopics:• How the behaviors (method execution) of an object affects its state (data)• Developing scenarios for how use cases (defined in chapter 9) might play out• Creating sequence diagrams based on scenarios• Using sequence diagrams to determine methodsChapter 12: Wrapping Up Our Modeling EffortsChapter Goal: This chapter focuses on ways to test a model before coding begins, as well as Subtopics:• Testing the model• Revisiting requirements and adapting the model as necessary• Reusing models in the form of design patterns Part III: Translating an Object Blueprint into Java CodeChapter 13: A Few More Key Java Details (retitled from 2nd edition)Chapter Goal: Covering a variety of important Java topics that were not essential to illustrating the object concepts of Part I per se, but which are nonetheless key to a rounding out a beginning level Java programmer’s facility with the language. I plan on eliminating a few sections from this chapter if I determine that any of the topics covered are *not* essential to understanding the Student Registration System (SRS) code of chapter 14.Subtopics:• Java application architecture, revisited• Nature and purpose of Java Archive (JAR) files• Java documentation comments• Object nature of Strings• Java enums (enumerations)• Object self-referencing via the “this” keyword• The nature of run-time exceptions, how to handle them, and how to define and use custom exception types• Important features of the built-in Object class• Techniques for command line input• Remove: discussion of inner classes (no longer needed since we are eliminating the chapter on the Swing API)• Remove: narrative regarding Java version 5 language enhancementsChapter 14: Transforming Your Model into Java CodeChapter Goal: In this chapter, I pull together all that we’ve covered in Part I of the book to render the UML model created in Part II of the book into a complete, fully functioning model layer for the Student Registration System. This code can be run from the command line, and will be downloadable from the Apress website.Subtopics: How to code …• … associations of varying multiplicities (one-to-one, one-to-many, many-to-many)• … inheritance relationships• … association classes• … reflexive associations• … abstract classes• … metadata• … static attributes and methodsChapter 15: Three Tier Architectures: Considerations for Adding a User Interface and Data Layer to Your ApplicationChapter Goal: Conceptually introduce the notion of model – presentation layer – data layer separation, using pseudocode examples to illustrate how these layers interact with the model layer code of chapter 14.Subtopics:• Overview of the power of model – presentation layer – data layer separation • Concept of operations for the Student Registration System user interface• Detailed walk-through of pseudocode illustrating (a) how the data layer is used to validate and persist model layer logic, (b) how the user interface/presentation layer is used to receive data and operational requests from a user
£59.49
APress DataDriven SEO with Python
Book Synopsis Solve SEO problems using data science. This hands-on book is packed with Python code and data science techniques to help you generate data-driven recommendations and automate the SEO workload. This book is a practical, modern introduction to data science in the SEO context using Python. With social media, mobile, changing search engine algorithms, and ever-increasing expectations of users for super web experiences, too much data is generated for an SEO professional to make sense of in spreadsheets. For any modern-day SEO professional to succeed, it is relevant to find an alternate solution, and data science equips SEOs to grasp the issue at hand and solve it. From machine learning to Natural Language Processing (NLP) techniques, Data-Driven SEO with Python provides tried and tested techniques with full explanations for solving both everyday and complex SEO problems. This book is ideal for SEO professionals who want to take their industry skiTable of ContentsData Driven SEO with PythonChapter 1: Meeting the Challenges of SEO with Data1.1 Agents of change in SEO1.2 The Pillars of SEO Strategy1.3 Installing Python1.4 Using Python for SEOChapter 2: Keyword Research2.1 Data Sources2.2 Google Search Console2.4 Google Trends2.5 Google Suggest2.6 Competitor Analytics2.7 SERPsChapter 3: Technical3.1 Improving CTRs3.2 Allocate keywords to pages based on the copy3.3 Allocating parent nodes to the orphaned URLs3.4 Improve interlinking based on copy3.5 Automate Technical AuditsChapter 4: Content & UX4.1 Content that best satisfies the user query4.2 Splitting and merging URLs4.3 Content Strategy: Planning landing page content Chapter 5: Authority5.1 A little SEO history5.1 The source of authority5.2 Finding good linksChapter 6: Competitors6.1 Defining the problem6.2 Data Strategy6.3 Data Sources6.4 Selecting Your Competitors6.5 Get Features6.6 Explore, Clean and Transform6.7 Modelling The SERPS6.8 Evaluating your Model6.9 ActivationChapter 7: Experiments7.1 How experiments fit into the SEO process7.2 Generating Hypotheses7.3 Experiment Design7.4 Running your experiment7.5 Experiment EvaluationChapter 8: Dashboards8.1 Use a Data Layer8.2 Extract, Transform and Load (ETL)8.3 Transform8.4 Querying the Data Warehouse (DW)8.5 Visualization8.6 Making Future ForecastsChapter 9: Site Migrations and Relaunches9.1 Data sources9.2 Establishing the Impact9.3 Segmenting the URLs9.4 Legacy Site URLs9.5 Priority9.6 RoadmapChapter 10: Google Updates10.1 Data sources10.2 Winners and Losers10.3 Quantifying the Impact10.4 Search Intent10.5 Unique URLs10.6 RecommendationsChapter 11: The Future of SEO11.1 Automation11.2 Your journey to SEO science11.3 Suggest resourcesAppendix: CodeGlossaryIndex
£29.69
APress Handson Guide to Apache Spark 3
Book SynopsisThis book explains how to scale Apache Spark 3 to handle massive amounts of data, either via batch or streaming processing. It covers how to use Spark's structured APIs to perform complex data transformations and analyses you can use to implement end-to-end analytics workflows.This book covers Spark 3's new features, theoretical foundations, and application architecture. The first section introduces the Apache Spark ecosystem as a unified engine for large scale data analytics, and shows you how to run and fine-tune your first application in Spark. The second section centers on batch processing suited to end-of-cycle processing, and data ingestion through files and databases. It explains Spark DataFrame API as well as structured and unstructured data with Apache Spark. The last section deals with scalable, high-throughput, fault-tolerant streaming processing workloads to process real-time data. Here you'll learn about Apache Spark Streaming's execution model, the architecture of Spark STable of ContentsPart I. Apache Spark Batch Data ProcessingChapter 1: Introduction to Apache Spark for Large-Scale Data Analytics1.1. What is Apache Spark? 1.2. Spark Unified Analytics1.3. Batch vs Streaming Data1.4. Spark EcosystemChapter 2: Getting Started with Apache Spark2.2. Scala and PySpark Interfaces2.3. Spark Application Concepts2.4. Transformations and Actions in Apache Spark2.5. Lazy Evaluation in Apache Spark2.6. First Application in Spark2.7. Apache Spark Web UIChapter 3: Spark Dataframe APIChapter 4: Spark Dataset APIChapter 5: Structured and Unstructured Data with Apache Spark5.1. Data Sources5.2. Generic Load/Save Functions5.3. Generic File Source Options5.4. Parquet Files5.5. ORC Files5.6. JSON Files5.7. CSV Files5.8. Text Files5.9. Hive Tables5.10. JDBC To Other DatabasesChapter 6: Spark Machine Learning with MLlibPart II. Spark Data StreamingChapter 7: Introduction to Apache Spark Streaming7.1. Apache Spark Streaming’s Execution Model7.2. Stream Processing Architectures7.3. Architecture of Spark Streaming: Discretized Streams7.4. Benefits of Discretized Stream Processing7.4.1. Dynamic Load Balancing7.4.2. Fast Failure and Straggler RecoveryChapter 8: Structured Streaming8.1. Streaming Analytics8.2. Connecting to a Stream8.3. Preparing the Data in a Stream8.4. Operations on a Streaming DatasetChapter 9: Structured Streaming Sources9.1. File Sources9.2. Apache Kafka Source9.3. A Rate SourceChapter 10: Structured Streaming Sinks10.1. Output Modes10.2. Output Sinks10.3. File Sink10.4. The Kafka Sink10.5. The Memory Sink 10.6. Streaming Table APIs10.7. Triggers10.8. Managing Streaming Queries10.9. Monitoring Streaming Queries10.9.1. Reading Metrics Interactively10.9.2. Reporting Metrics programmatically using Asynchronous APIs10.9.3. Reporting Metrics using Dropwizard10.9.4. Recovering from Failures with Checkpointing10.9.5. Recovery Semantics after Changes in a Streaming QueryChapter 11: Future Directions for Spark Streaming11.1. Backpressure11.2. Dynamic Scaling11.3. Event time and out-of-order data11.4. UI enhancements11.5. Continuous ProcessingChapter 12: Watermarks. A deep survey of temporal progress metrics
£46.74
APress Beginning Helidon
Book SynopsisLearn how to build cloud-native microservices with Helidon - an open-source Java framework from Oracle. This book will show you how to take full advantage of the cloud by optimizing applications with fast start times, low memory consumption, and a small disk footprint. The open-source Helidon framework provides all that, and more. It''s based on Java 17, giving you full access to new code features. This book reveals how Helidon also supports modern enterprise Java standards such as MicroProfile. Plus, you''ll see how Helidon lets you use GraalVM to build lightning-fast native executables, and its unique reactive layer allows you to develop efficient low-level APIs.Each chapter in the book teaches a new Helidon concept through practical examples based on real-life use-cases. You''ll learn how to add observability and security to your microservices, how to work with databases, and call other services. You''ll also look at all MicroProfile 5.0 platform specificationsTable of Contents1:Introduction.- 2: Your First Application.- 3: Configuration.- 4: Observability.- 5: Communicating with other Services.- 6: Accessing Data.- 7: Resiliency.- 8:Security.- 9: Using Open API.- 10: Testing Your Application.- 11: Scheduling Tasks.- 12: Integration with other Technologies.- 13: Going Reactive.- 14: Long Running Actions.- 15: Helidon SE.
£46.74
