Pro Android 3

What you'll learn Use Android to build Java-based mobile applications for Google phones with a touch screen or keyboard Design and architect using Google’s Android SDK Use the Android SDK to write mobile applications for embedded devices Create 3D graphics with OpenGL and custom components Cuild multimedia and game apps using Android’s Media APIs and OpenGL Use Android’s location-based services, networking (Wi-Fi APIs), and security Create and allow for more integrated local and web searches Build handwriting gesture UIs Incorporate Google Translate into your Android applications

Perl最佳实践 中文版

Perl最佳实践 如何成为优秀的Perl程序员

[Perl.by.Example(4th.Edition)]

[Perl.by.Example(4th.Edition)] Perl 实例精解，很有帮助

Perl语言入门(第五版)英文原版

Perl语言入门(第五版)英文原版 简单的入门书籍

Perl Cookbook 2nd Edition

Perl程序员必备. Perl Cookbook is a comprehensive collection of problems, solutions, and practical examples for anyone programming in Perl. The book contains hundreds of rigorously reviewed Perl "recipes" and thousands of examples ranging from brief one-liners to complete applications. The second edition of Perl Cookbook has been fully updated for Perl 5.8, with extensive changes for Unicode support, I/O layers, mod_perl, and new technologies that have emerged since the previous edition of the book. Recipes have been updated to include the latest modules. New recipes have been added to every chapter of the book, and some chapters have almost doubled in size.

[麻省理工学院-算法导论].Introduction.to.Algorithms,.Second.Edition.chm

如此经典的书就不用多说了。 Introduction to Algorithms, Second Edition by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest and Clifford Stein ISBN:0262032937 The MIT Press © 2001 (1180 pages) A course in computer algorithms, suitable for use as a field reference for working software developers.

Introduction to the Theory of Computation

Introduction+to+the+Theory+of+Computation 计算理论的基础

Springer - Logic Programming With Prolog (2005)

Contents 1. Getting Started 1 1.1 Starting Prolog 1 1.2 Prolog Programs 3 1.3 Data Objects in Prolog: Prolog Terms 8 Practical Exercise 1 12 2. Clauses and Predicates 13 2.1 Clauses 13 2.2 Predicates 15 2.3 Loading Clauses 19 2.4 Variables 21 Practical Exercise 2 27 3. Satisfying Goals 29 Introduction 29 3.1 Unification 31 3.1.1 Unifying Call Terms 32 3.2 Evaluating Goals 35 3.3 Backtracking 39 3.4 Satisfying Goals: A Summary 50 3.5 Removing Common Variables 52 3.6 A Note on Declarative Programming 52 Practical Exercise 3 55 4. Operators and Arithmetic 57 4.1 Operators 57 4.2 Arithmetic 59 4.3 Equality Operators 63 4.4 Logical Operators 66 Practical Exercise 4 68 xii Contents 5. Input and Output 69 Introduction 69 5.1 Outputting Terms 69 5.2 Inputting Terms 71 5.3 Input and Output Using Characters 72 5.4 Outputting Characters 73 5.5 Inputting Characters 73 5.6 Using Characters: Examples 74 5.7 Input and Output Using Files 77 5.8 File Output: Changing the Current Output Stream 77 5.9 File Input: Changing the Current Input Stream 78 5.9.1 Reading from Files: End of File 78 5.9.2 Reading from Files: End of Record 79 5.10 Using Files: Examples 79 Practical Exercise 5 82 6. Loops 85 Introduction 85 6.1 Looping a Fixed Number of Times 85 6.2 Looping Until a Condition Is Satisfied 89 6.2.1 Recursion 89 6.2.2 Using the 'repeat' Predicate 91 6.3 Backtracking with Failure 94 6.3.1 Searching the Prolog Database 94 6.3.2 Finding Multiple Solutions 96 Practical Exercise 6 97 7. Preventing Backtracking 99 Introduction 99 7.1 The Cut Predicate 99 7.2 Cut with Failure 106 Practical Exercise 7 108 8. Changing the Prolog Database 109 8.1 Changing the Database: Adding and Deleting Clauses 109 8.2 Adding Clauses 110 8.3 Deleting Clauses 111 8.4 Changing the Database: Example 112 8.5 Maintaining a Database of Facts 114 Practical Exercise 8 118 Contents xiii 9. List Processing 119 9.1 Representing Data as Lists 119 9.2 Notation for Lists 120 9.3 Decomposing a List 122 9.4 Built-in Predicate: member 125 9.5 Built-in Predicate: length 126 9.6 Built-in Predicate: reverse 126 9.7 Built-in Predicate: append 127 9.8 List Processing: Examples 129 9.9 Using findall/3 to Create a List 133 Practical Exercise 9 136 10. String Processing 137 10.1 Converting Strings of Characters To and From Lists 137 10.2 Joining Two Strings 139 10.3 Trimming a String 139 10.4 Inputting a String of Characters 141 10.5 Searching a String 142 10.6 Dividing a String into Its Component Parts 144 Practical Exercise 10 147 11. More Advanced Features 149 Introduction 149 11.1 Extending Prolog: Arithmetic 149 11.2 Extending Prolog: Operations on Strings 155 11.3 Extending Prolog: Sets 157 11.4 Processing Terms 160 Practical Exercise 11 166 Appendix 1. Built-in Predicates 167 Appendix 2. Built-in Operators 179 Appendix 3. Specimen Solutions to Practical Exercises 185 Appendix 4. Glossary 209 Index 221

HPL: Vol. IV: Functional and Logic Programming Languages

HPL: Vol. IV: Functional and Logic Programming Languages by Peter Salus Macmillan Technical Publishing, Macmillan Computer Publishing ISBN: 1578700116 Pub Date: 06/11/98 Foreword to the Handbook of Programming Languages About the Authors Part 1—Lisp Chapter 1—The LISP Language Chapter 2—Emacs Lisp: A Short Description 2.1. GNU Emacs and Emacs Lisp 2.2. Lisp Lists 2.2.1. Parts of Lisp 2.3. Example: Two Plus Two 2.4. Evaluation 2.5. A Function Definition 2.5.1. An Example of a Search Within a Buffer 2.5.2. An Example: multiply-by-seven 2.6. Variables 2.7. A Chest of Drawers 2.8. Functions 2.9. The read-eval-print Loop and Side Effects 2.10. Types of Variables 2.10.1. defvar and defconst 2.10.2. setq 2.10.3. Passing an Argument 2.10.4. A let Expression 2.10.5. Buffer-Local Variables 2.11. Sequencing 2.12. Conditionals 2.12.1. and, or, and not 2.13. while Loops and Recursion 2.13.1. while 2.13.2. car, cdr, cons: Fundamental Functions 2.13.3. while, Continued 2.13.4. Recursion 2.14. Macros 2.14.1. The list Built-in Function 2.14.2. Backquote 2.15. Property Lists 2.16. Keymaps 2.17. Editing Lisp 2.18. Help 2.19. Debugging 2.19.1. The Built-in Debugger 2.19.2. Edebug 2.20. Backups and Auto-Saving 2.21. Evaluating or Loading a Whole File 2.22. Byte Compilation 2.23. Your .emacs Initialization File Part II—Scheme Chapter 3—Scheme 3.1. Who Uses Scheme? 3.2. Scheme as a Dialect of Lisp 3.2.1. Expressions 3.2.2. Uniform Syntax 3.2.3. Automatic Storage Management 3.2.4. High-Level Data Types 3.2.5. Untyped Variables 3.3. Scheme as a Dialect of Algol 3.3.1. Internal Definitions 3.3.2. Lexical Scope 3.4. Innovations in Scheme 3.4.1. First-Class Data 3.4.2. Tail Call Elimination 3.4.3. First-Class Continuations 3.4.4. Lexical Scoping Rules for Macros 3.5. Functional Programming in Scheme 3.6. Object-Oriented Programming in Scheme 3.7. Common Problems for Beginning Scheme Programmers 3.7.1. Function Composition Problems 3.7.2. Attempted Sequential Results 3.7.3. Expressions Don’t Print 3.7.4. No Variable Reassignment 3.7.5. Scheme Isn’t English 3.7.6. Incomplete Expression Problems 3.7.7. Recursion Problems 3.7.8. cons Problems 3.8. References Part III—Guile Chapter 4—Guile: An Interpreter Core for Complete Applications 4.1. Pure Guile 4.2. The Guile Library 4.3. Domain-Specific Languages 4.4. Specializing Guile 4.4.1. Adding Functions to Guile 4.4.2. Adding Types to Guile 4.5. Cooperation Between Scheme and C 4.6. Hints for Using Guile 4.7. Related Work 4.8. Obtaining Guile and Other Packages Part IV—CLOS Chapter 5—A History and Description of CLOS 5.1. A Quick History of CLOS 5.2. An Introduction to CLOS 5.3. Components of CLOS 5.3.1. Classes and Instances 5.3.2. Class Inheritance 5.3.3. Classes and Operations 5.3.4. Multiple Argument Dispatch 5.3.5. Structure Encapsulation and Slots 5.3.6. Standard Method Combination 5.3.7. The Metaobject Protocol 5.4. Programming in CLOS 5.4.1. Slot Properties 5.4.2. Accessors and slot-value 5.4.3. Multiple Inheritance: Using Mix-ins to Get Modularity 5.4.4. Inheritance Rules: Precedence 5.4.5. Methods and Generic Functions 5.4.6. Before, After, and Around Methods 5.4.7. Operator Method Combination 5.4.8. Redefining Classes and Changing the Class of Instances 5.4.9. Extending CLOS Using the Metaobject Protocol 5.4.10. Performance Considerations 5.4.11. Summary of CLOS Operators Part V—Prolog Chapter 6—Prolog: Programming in Logic 6.1. History and Background 6.1.1. The Early Days 6.1.2. Progress on Prolog 6.1.3. Myths and Problems of Prolog 6.1.4. Prolog Resources 6.1.5. The Structure of This Chapter 6.2. Basic Prolog Programming 6.2.1. Hello World 6.2.2. The Genealogy Program 6.2.3. A Grammatical Summary 6.2.4. Equality and Variables 6.2.5. Lists 6.2.6. Predicates on Lists 6.2.7. Complex Terms in Heads of Clauses 6.2.8. How Prolog Does It 6.3. More Advanced Features 6.3.1. Negation 6.3.2. The Cut Literal 6.3.3. Multi-Arity Predicates 6.3.4. More About Terms 6.3.5. Input and Output 6.3.6. Other Logic and Control Constructs 6.3.7. Finding All Solutions 6.3.8. The Four-Port Debugger 6.3.9. Definite Clause Grammars 6.3.10. assert and retract 6.3.11. Operator Declarations 6.4. Tips and Traps 6.4.1. Style 6.4.2. Overusing assert and retract 6.4.3. The Singleton Warning and Anonymous Variables 6.4.4. Infinite Terms and the Occurs Check 6.4.5. The Transitive Closure Problem 6.4.6. Tail Recursion Optimization 6.4.7. First Argument Indexing 6.4.8. Reading Clauses from the Terminal 6.4.9. Using the Dash in a Symbol 6.5. Examples 6.5.1. A Balanced Tree Package 6.5.2. Eratosthenes’ Sieve 6.5.3. A C Leak Checker 6.5.4. The Game of Life 6.5.5. A Simple Lisp Interpreter 6.6. Acknowledgments 6.7. References Index -------------------------------------------------------------------------------- Copyright © Macmillan Computer Publishing, Inc.

artificial intelligence thru prolog

Artificial intelligence through prolog