Thinking and Coding Life

这是一本全面介绍常微分方程的书，其中给出了用C++，Java，Maple，Matlab等各种语言实现的解方程例子和分析过程。对于物理等专业应该很适用。

This book is oriented primarily toward junior to intermediate software developers work ing in the realm of embedded computing. If you are an experienced developer but new to real-time embedded systems develop ment, you will also find the approach to design in this book quite useful. If you are a technical manager who is active in software design reviews of real-time systems, you can refer to this book to become better informed regarding the design and implementation phases. This book can also be used as complementary reference material if you are an engineering or computer science student. Before using this book, you should be proficient in at least one programming language and should have some exposure to the software-development process.

This text has several objectives. A primary goal of this text is to give you a solid understanding of the fundamental concepts involved in interactive 3D graphics programming at the intermediate to advanced level. Such an understanding not only enables you to write your own 3D programs, libraries, and games under Linux, but also gives you the knowledge and confidence you need to xii analyze and use other 3D graphics texts and programs. In the open source world of Linux, understanding fundamental concepts is indeed important so that you can understand and possibly contribute to the common pool of knowledge and code. Furthermore, learning fundamental 3D graphics concepts also enables you to understand and effectively use sophisticated 3D applications and libraries such as 3D modelers and OpenGL. A second goal of this text is to give you plenty of hands-on experience programming 3D graphics applications under Linux. It is one thing to understand the theoretical mechanics of an algorithm; it is another to actually implement, debug, and optimize that same algorithm using a particular set of programming tools. Small standalone programs are scattered throughout this text to demonstrate key 3D graphics concepts. It is often easy to lose sight of the forest for the trees, particularly in the complicated world of 3D graphics. Standalone sample programs address this problem by concisely illustrating how all the necessary components of a 3D program “fit together.” They reduce the intimidation that often accompanies the study of large, complicated programs, and give you confidence in developing and modifying complete 3D programs under Linux. A third goal of this text is to help you develop and understand the techniques for developing a reusable 3D application framework or library. In addition to the standalone programs mentioned above, the book also develops a series of generally reusable C++ library classes for 3D graphics, called the l3d library. This library was introduced in the introductory companion book Linux 3D Graphics Programming and is developed further in this book. This C++ library code follows an object-oriented approach, relying heavily on virtual functions, (multiple) inheritance, and design patterns. In this manner, the developed library classes are usable as is but still open for extension through subclassing. Each chapter builds upon the library classes developed in previous chapters, either adding new classes or combining existing classes in new ways. Through subclassing, the library classes can be adapted to work with virtually any hardware or software platform or API; currently, the code runs under Linux and MicrosoftWindows, with or without hardware acceleration. The techniques used to develop the 3D library classes illustrate both valuable 3D abstractions and generally applicable object-oriented techniques. A fourth goal of this text is to demonstrate the excellence of the Linux platform as a graphics programming environment. For a programmer, Linux is a dream come true. All of the source code is available, all of the operating system features are enabled, a large number of excellent first-rate software development tools exist, and it is all freely available, being constantly tested and improved by thousands of programmers around the world. Linux empowers the programmer with open source, open information, and open standards. Given this outstanding basis for development, it is no wonder that programmers in every conceivable application area (including 3D graphics) have flocked to Linux. This has created a wealth of 3D libraries, tools, and applications for Linux. Linux is, therefore, an outstanding software development platform with powerful 3D tools and software—an ideal environment for learning and practicing 3D graphics programming. A final, personal goal of this text, and the main reason I am writing this book, is to impart to you a sense of the excitement that 3D graphics programming offers. You, the 3D programmer, have the power to model reality. You control every single z-buffered, Gourad-shaded, texture- mapped, perspective-correct, dynamically morphed, 24-bit, real-time pixel on the flat 2D screen, and amazingly, your painstakingly coded bits and bytes merge to form a believable 3D Introduction xiii world. By working under Linux, you are no longer held back by a lack of tools or software. It’s all out there—free for download and top quality. Linux software gives you the tools you need to realize your 3D ideas.

这是一份非常有意思的文档，作者是一位物理学博士，但他对编译器有浓厚的兴趣，在经历了漫长的研究之后，他在自己的电脑上实现了一个编译器的原型。 他觉得很有必要把这些经历和如何实现的要诀分享给大家，于是就自己编写了一本书。这本书不是某个出版社出版的，纯粹是Jack W. Crenshaw博士的一本自编书籍。写作的风格不拘小节，读起来实践性很强。对编译器感兴趣的话可以跟他一起尝试一下。

DOWEC是一个丹麦牵头的研究项目，旨在设计一款6MW海上风力发电机。这篇文献是该项目中描述控制算法设计的报告，对于搞风电机组控制系统的软件开发人员是一份难得的资料。

本书的主旨： Help students and developers create object designs through the application of a set of explainable principles and heuristics. By studying and applying the information and techniques presented here, you will become more adept at understanding a problem in terms of its processes and concepts, and designing a solid solution using objects. 针对的读者： This book is an introduction to OOA/D, related requirements analysis, and to iterative development with the Unified Process as a sample process; it is not meant as an advanced text. It is for the following audience: • Developers and students with experience in an object-oriented programming language, but who are new—or relatively new—to object-oriented analysis and design. • Students in computer science or software engineering courses studying object technology. • Those with some familiarity in OOA/D who want to learn the UML notation, apply patterns, or who want to sharpen and deepen their analysis and design skills. 总体上，从行文结构和单词量看，应该是难度偏易。对于英文基础中上的读者没有阅读难度。

这本书适合初级及中级开发人员针对控制系统进行开发，其中详细的给出了一些典型控制算法的C和C++语言实现。对于没有太多自动控制背景知识的开发人员也有一定帮助，不过如果开发人员有控制系统基础知识（包括经典控制理论、状态空间、最优控制基础知识、卡尔曼滤波等等）能更好的使用这本书。 以下是目录： Embedded Control Systems in C/C++—An Introduction for Software Developers Using MATLAB Preface Chapter 1 - Control Systems Basics Chapter 2 - PID Control Chapter 3 - Plant Models Chapter 4 - Classical Control System Design Chapter 5 - Pole Placement Chapter 6 - Optimal Control Chapter 7 - MIMO Systems Chapter 8 - Discrete-Time Systems and Fixed-Point Mathematics Chapter 9 - Control System Integration and Testing Chapter 10 - Wrap-Up and Design Example

本书覆盖了Windows系统编程的核心内容，建议中高级读者阅读。以下摘自书籍概述（Overview）。 The premier guide to the Windows kernel now covers Windows Server 2003, Windows XP, and Windows 2000, including 64-bit extensions. Get the architectural perspectives and insider insights needed to unlock the power of Windows. 以下为目录： Copyright Historical Perspective Foreword Acknowledgments Introduction Structure of the Book History of the Book Fourth Edition Changes Hands-On Experiments Topics Not Covered A Warning and Caveat Support About the Authors David Solomon Mark Russinovich Chapter 1. Concepts and Tools Windows Operating System Versions Foundation Concepts and Terms Digging into Windows Internals Conclusion Chapter 2. System Architecture Requirements and Design Goals Operating System Model Architecture Overview Key System Components Conclusion Chapter 3. System Mechanisms Trap Dispatching Object Manager Synchronization System Worker Threads Windows Global Flags Local Procedure Calls (LPCs) Kernel Event Tracing Wow64 Conclusion Chapter 4. Management Mechanisms The Registry Services Windows Management Instrumentation Conclusion Chapter 5. Startup and Shutdown Boot Process Troubleshooting Boot and Startup Problems Shutdown Conclusion Chapter 6. Processes, Threads, and Jobs Process Internals Flow of CreateProcess Thread Internals Examining Thread Activity Thread Scheduling Job Objects Conclusion Chapter 7. Memory Management Introduction to the Memory Manager Services the Memory Manager Provides System Memory Pools Virtual Address Space Layouts Address Translation Page Fault Handling Virtual Address Descriptors Section Objects Working Sets Logical Prefetcher Page Frame Number Database Conclusion Chapter 8. Security Security Ratings Trusted Computer System Evaluation Critiera The Common Criteria Security System Components Protecting Objects Account Rights and Privileges Security Auditing Logon Software Restriction Policies Conclusion Chapter 9. I/O System I/O System Components Device Drivers I/O Processing The Plug and Play (PnP) Manager The Power Manager Conclusion Chapter 10. Storage Management Storage Terminology Disk Drivers Volume Management Conclusion Chapter 11. Cache Manager Key Features of the Cache Manager Cache Virtual Memory Management Cache Size Cache Data Structures File System Interfaces Fast I/O Read Ahead and Write Behind Conclusion Chapter 12. File Systems Windows File System Formats File System Driver Architecture Troubleshooting File System Problems NTFS Design Goals and Features NTFS File System Driver NTFS On-Disk Structure NTFS Recovery Support Encrypting File System Security Conclusion Chapter 13. Networking Windows Networking Architecture Networking APIs Multiple Redirector Support Name Resolution Protocol Drivers NDIS Drivers Binding Layered Network Services Conclusion Chapter 14. Crash Dump Analysis Why Does Windows Crash? The Blue Screen Crash Dump Files Windows Error Reporting Online Crash Analysis Basic Crash Dump Analysis Using Crash Troubleshooting Tools Advanced Crash Dump Analysis Glossary Index

Windows Sytem Programming

C++ Template Metaprogramming sheds light on the most powerful idioms of today's C++, at long last delivering practical metaprogramming tools and techniques into the hands of the everyday programmer. <br><br>A metaprogram is a program that generates or manipulates program code. Ever since generic programming was introduced to C++, programmers have discovered myriad "template tricks" for manipulating programs as they are compiled, effectively eliminating the barrier between program and metaprogram. While excitement among C++ experts about these capabilities has reached the community at large, their practical application remains out of reach for most programmers. This book explains what metaprogramming is and how it is best used. It provides the foundation you'll need to use the template metaprogramming effectively in your own work.<br><br>This book is aimed at any programmer who is comfortable with idioms of the Standard Template Library (STL). C++ power-users will gain a new insight into their existing work and a new fluency in the domain of metaprogramming. Intermediate-level programmers who have learned a few advanced template techniques will see where these tricks fit in the big picture and will gain the conceptual foundation to use them with discipline. Programmers who have caught the scent of metaprogramming, but for whom it is still mysterious, will finally gain a clear understanding of how, when, and why it works. All readers will leave with a new tool of unprecedented power at their disposalthe Boost Metaprogramming Library.<br><br>The companion CD-ROM contains all Boost C++ libraries, including the Boost Metaprogramming Library and its reference documentation, along with all of the book's sample code and extensive supplementary material. <br>

C++ Templates begins with an insightful tutorial on basic concepts and language features. The remainder of the book serves as a comprehensive reference, focusing first on language details, then on a wide range of coding techniques, and finally on advanced applications for templates. Examples used throughout the book illustrate abstract concepts and demonstrate best practices.<br><br>Readers learn<br><br>The exact behaviors of templates <br><br>How to avoid the pitfalls associated with templates <br><br>Idioms and techniques, from the basic to the previously undocumented <br><br>How to reuse source code without threatening performance or safety <br><br>How to increase the efficiency of C++ programs <br><br>How to produce more flexible and maintainable software<br><br><br>This practical guide shows programmers how to exploit the full power of the template features in C++.<br><br>

Inside the C++ Object Model focuses on the underlying mechanisms that support object-oriented programming within C++: constructor semantics, temporary generation, support for encapsulation, inheritance, and "the virtuals"-virtual functions and virtual inheritance. This book shows how your understanding the underlying implementation models can help you code more efficiently and with greater confidence. Lippman dispells the misinformation and myths about the overhead and complexity associated with C++, while pointing out areas in which costs and trade offs, sometimes hidden, do exist. He then explains how the various implementation models arose, points out areas in which they are likely to evolve, and why they are what they are. He covers the semantic implications of the C++ object model and how that model affects your programs.<br><br>Highlights<br><br>Explores the program behavior implicit in the C++ Object Model's support of object-oriented programming. <br><br>Explains the basic implementation of the object-oriented features and the trade offs implicit in those features. <br><br>Examines the impact on performance in terms of program transformation. <br><br>Provides abundant program examples, diagrams, and performance measurements to relate object-oriented concepts to the underlying object model. <br><br><br>If you are a C++ programmer who desires a fuller understanding of what is going on "under the hood," then Inside the C++ Object Model is for you!<br><br>

Introducing the Boost libraries: the next breakthrough in C++ programming<br><br>Boost takes you far beyond the C++ Standard Library, making C++ programming more elegant, robust, and productive. Now, for the first time, a leading Boost expert systematically introduces the broad set of Boost libraries and teaches best practices for their use.<br><br>Writing for intermediate-to-advanced C++ developers, Björn Karlsson briefly outlines all 58 Boost libraries, and then presents comprehensive coverage of 12 libraries you're likely to find especially useful. Karlsson's topics range from smart pointers and conversions to containers and data structures, explaining exactly how using each library can improve your code. He offers detailed coverage of higher-order function objects that enable you to write code that is more concise, expressive, and readable. He even takes you "behind the scenes" with Boost, revealing tools and techniques for creating your own generic libraries.<br><br>Coverage includes<br><br>Smart pointers that provide automatic lifetime management of objects and simplify resource sharing<br><br>Consistent, best-practice solutions for performing type conversions and lexical conversions<br><br>Utility classes that make programming simpler and clearer<br><br>Flexible container libraries that solve common problems not covered by the C++ Standard Library<br><br>Powerful support for regular expressions with Boost.Regex<br><br>Function objects defined at the call site with Boost.Bind and Boost.Lambda<br><br>More flexible callbacks with Boost.Function<br><br>Managed signals and slots (a.k.a. the Observer pattern) with Boost.Signals<br><br>The Boost libraries are proving so useful that many of them are planned for inclusion in the next version of the C++ Standard Library. Get your head start now, with Beyond the C++ Standard Library.<br><br>

C++ Standard Library: A Tutorial and ReferenceBy Nicolai M. Josuttis Publisher : Addison Wesley Pub Date : August 06, 1999 ISBN : 0-201-37926-0 Pages : 832 Content------------------PrefaceAcknowledgmentsChapter 1. About this Book1.1 Why this Book1.2 What You Should Know Before Reading this Book1.3 Style and Structure of the Book1.4 How to Read this Book1.5 State of the Art1.6 Example Code and Additional Information1.7 FeedbackChapter 2. Introduction to C++ and the Standard Library2.1 History2.2 New Language Features2.3 Complexity and the Big-O NotationChapter 3. General Concepts3.1 Namespace 3.2 Header Files3.3 Error and Exception Handling3.4 AllocatorsChapter 4. Utilities4.1 Pairs4.1.1 Convenience Function 4.1.2 Examples of Pair Usage4.2 Class 4.3 Numeric Limits4.4 Auxiliary Functions4.5 Supplementary Comparison Operators4.6 Header Files Chapter 5. The Standard Template Library5.1 STL Components5.2 Containers5.3 Iterators5.4 Algorithms5.5 Iterator Adapters5.6 Manipulating Algorithms5.7 User-Defined Generic Functions5.8 Functions as Algorithm Arguments5.9 Function Objects5.10 Container Elements5.11 Errors and Exceptions Inside the STL5.12 Extending the STLChapter 6. STL Containers6.1 Common Container Abilities and Operations6.2 Vectors6.3 Deques6.4 Lists6.5 Sets and Multisets6.6 Maps and Multimaps6.7 Other STL Containers6.8 Implementing Reference Semantics6.9 When to Use which Container6.10 Container Types a

C++ Standard Library: A Tutorial and Reference, <br/>By Nicolai M. Josuttis <br/> <br/>Publisher : Addison Wesley <br/>Pub Date : August 06, 1999 <br/>ISBN : 0-201-37926-0 <br/>Pages : 832 <br/> <br/>C++ Standard Library provides a set of common classes and interfaces that greatly extend the core C++ language. The library, however, is not self-explanatory. To make full use of its components-and to benefit from their power-you need a resource that does far more than list the classes and their functions.<br/><br/>The C++ Standard Library not only provides comprehensive documentation of each library component, it also offers clearly written explanations of complex concepts, describes the practical programming details needed for effective use, and gives example after example of working code.<br/><br/>This thoroughly up-to-date book reflects the newest elements of the C++ standard library incorporated into the full ANSI/ISO C++ language standard. In particular, the text focuses on the Standard Template Library (STL), examining containers, iterators, function objects, and STL algorithms. You will also find detailed coverage of special containers, strings, numerical classes, internationalization, and the IOStream library. Each component is presented in depth, with an introduction to its purpose and design, examples, a detailed description, traps and pitfalls, and the exact signature and definition of its classes and their functions. An insightful introduction to fundamental concepts and an overview of the library will help bring newcomers quickly up to speed.<br/><br/>Comprehensive, detailed, readable, and practical, The C++ Standard Library is the C++ resource you will turn to again and again. <br/><br/><br/>Content<br/>--------------------<br/>Preface<br/><br/>Acknowledgments<br/><br/>Chapter 1. About this Book<br/><br/> 1.1 Why this Book<br/><br/> 1.2 What You Should Know Before Reading this Book<br/><br/> 1.3 Style and Structure of the Book<br/><br/> 1.4 How to Read this Book<br/><br/> 1.5 State of the Art<br/><br/> 1.6 Example Code and Additional Information<br/><br/> 1.7 Feedback<br/><br/>Chapter 2. Introduction to C++ and the Standard Library<br/><br/> 2.1 History<br/><br/> 2.2 New Language Features<br/><br/> 2.3 Complexity and the Big-O Notation<br/><br/>Chapter 3. General Concepts<br/><br/> 3.1 Namespace <br/><br/> 3.2 Header Files<br/><br/> 3.3 Error and Exception Handling<br/><br/> 3.4 Allocators<br/><br/>Chapter 4. Utilities<br/><br/> 4.1 Pairs<br/><br/> 4.1.1 Convenience Function <br/><br/> 4.1.2 Examples of Pair Usage<br/><br/> 4.2 Class <br/><br/> 4.3 Numeric Limits<br/><br/> 4.4 Auxiliary Functions<br/><br/> 4.5 Supplementary Comparison Operators<br/><br/> 4.6 Header Files <br/><br/>Chapter 5. The Standard Template Library<br/><br/> 5.1 STL Components<br/><br/> 5.2 Containers<br/><br/> 5.3 Iterators<br/><br/> 5.4 Algorithms<br/><br/> 5.5 Iterator Adapters<br/><br/> 5.6 Manipulating Algorithms<br/><br/> 5.7 User-Defined Generic Functions<br/><br/> 5.8 Functions as Algorithm Arguments<br/><br/> 5.9 Function Objects<br/><br/> 5.10 Container Elements<br/><br/> 5.11 Errors and Exceptions Inside the STL<br/><br/> 5.12 Extending the STL<br/><br/>Chapter 6. STL Containers<br/><br/> 6.1 Common Container Abilities and Operations<br/><br/> 6.2 Vectors<br/><br/> 6.3 Deques<br/><br/> 6.4 Lists<br/><br/> 6.5 Sets and Multisets<br/><br/> 6.6 Maps and Multimaps<br/><br/> 6.7 Other STL Containers<br/><br/> 6.8 Implementing Reference Semantics<br/><br/> 6.9 When to Use which Container<br/><br/> 6.10 Container Types and Members in Detail<br/><br/>Chapter 7. STL Iterators<br/><br/> 7.1 Header Files for Iterators<br/><br/> 7.2 Iterator Categories<br/><br/> 7.3 Auxiliary Iterator Functions<br/><br/> 7.4 Iterator Adapters<br/><br/> 7.5 Iterator Traits<br/><br/>Chapter 8. STL Function Objects<br/><br/> 8.1 The Concept of Function Objects<br/><br/> 8.2 Predefined Function Objects<br/><br/> 8.3 Supplementary Composing Function Objects<br/><br/>Chapter 9. STL Algorithms<br/><br/> 9.1 Algorithm Header Files<br/><br/> 9.2 Algorithm Overview<br/><br/> 9.3 Auxiliary Functions<br/><br/> 9.4 The for_each() Algorithm<br/><br/> 9.5 Nonmodifying Algorithms<br/><br/> 9.6 Modifying Algorithms<br/><br/> 9.7 Removing Algorithms<br/><br/> 9.8 Mutating Algorithms<br/><br/> 9.9 Sorting Algorithms<br/><br/> 9.10 Sorted Range Algorithms<br/><br/> 9.11 Numeric Algorithms<br/><br/>Chapter 10. Special Containers<br/><br/> 10.1 Stacks<br/><br/> 10.2 Queues<br/><br/> 10.3 Priority Queues<br/><br/> 10.4 Bitsets<br/><br/>Chapter 11. Strings<br/><br/> 11.1 Motivation<br/><br/> 11.2 Description of the String Classes<br/><br/> 11.3 String Class in Detail<br/><br/>Chapter 12. Numerics<br/><br/> 12.1 Complex Numbers<br/><br/> 12.2 Valarrays<br/><br/> 12.3 Global Numeric Functions<br/><br/>Chapter 13. Input/Output Using Stream Classes<br/><br/> 13.1 Common Background of I/O Streams<br/><br/> 13.2 Fundamental Stream Classes and Objects<br/><br/> 13.3 Standard Stream Operators << and >><br/><br/> 13.4 State of Streams<br/><br/> 13.5 Standard Input/Output Functions<br/><br/> 13.6 Manipulators<br/><br/> 13.7 Formatting<br/><br/> 13.8 Internationalization<br/><br/> 13.9 File Access<br/><br/> 13.10 Connecting Input and Output Streams<br/><br/> 13.11 Stream Classes for Strings<br/><br/> 13.12 Input/Output Operators for User-Defined Types<br/><br/> 13.13 The Stream Buffer Classes<br/><br/> 13.14 Performance Issues<br/><br/>Chapter 14. Internationalization<br/><br/> 14.1 Different Character Encodings<br/><br/> 14.2 The Concept of Locales<br/><br/> 14.3 Locales in Detail<br/><br/> 14.4 Facets in Detail<br/><br/>Chapter 15. Allocators<br/><br/> 15.1 Using Allocators as an Application Programmer<br/><br/> 15.2 Using Allocators as a Library Programmer<br/><br/> 15.3 The Default Allocator<br/><br/> 15.4 A User-Defined Allocator<br/><br/> 15.5 Allocators in Detail<br/><br/> 15.6 Utilities for Uninitialized Memory in Detail<br/><br/>Internet Resources<br/><br/>Bibliography<br/><br/>

Memory Management: Algorithms and Implementation in C/C++ <br/>by Bill Blunden ISBN:1556223471 <br/><br/>Wordware Publishing © 2003 (360 pages) <br/><br/>This book presents several concrete implementations of garbage collection and explicit memory management algorithms.<br/> <br/>Table of Contents <br/> Memory Management—Algorithms and Implementation in C/C++ <br/>· Introduction <br/>· Chapter 1 - Memory Management Mechanisms <br/>· Chapter 2 - Memory Management Policies <br/>· Chapter 3 - High-Level Services <br/>· Chapter 4 - Manual Memory Management <br/>· Chapter 5 - Automatic Memory Management <br/>· Chapter 6 - Miscellaneous Topics <br/>· Index <br/>· List of Figures <br/>· List of Tables <br/>· List of Case Studies <br/>· List of Sidebars <br/>

Principal component analysis (PCA) is a mainstay of modern data analysis - a black box that is widely used but (sometimes) poorly understood. The goal of this paper is to dispel the magic behind this black box. This manuscript focuses on building a solid intuition for how and why principal component analysis works. This manuscript crystallizes this knowledge by deriving from simple intuitions, the mathematics behind PCA. This tutorial does not shy away from explaining the ideas informally, nor does it shy away from the mathematics. The hope is that by addressing both aspects, readers of all levels will be able to gain a better understanding of PCA as well as the when, the how and the why of applying this technique.

在实际开发项目中，使用MATLAB的神经网络工具箱和模糊逻辑工具箱设计算法然后用Coder将算法转换为高级语言。然后使用过Coder的用户就知道，一定有部分应用场景需要直接用高级语言编写算法。这本书就是为此目的编写。 书是以网页形式组织的，其中ewtoc.htm是目录。主要章节如下。 ------------------------------------------------------------- • Chapter 1 gives you an overview of neural network terminology and nomenclature. You discover that neural nets are capable of solving complex problems with parallel computational architectures. The Hopfield network and feedforward network are introduced in this chapter. • Chapter 2 introduces C++ and object orientation. You learn the benefits of object-oriented programming and its basic concepts. • Chapter 3 introduces fuzzy logic, a technology that is fairly synergistic with neural network problem solving. You learn about math with fuzzy sets as well as how you can build a simple fuzzifier in C++. • Chapter 4 introduces you to two of the simplest, yet very representative, models of: the Hopfield network, the Perceptron network, and their C++ implementations. • Chapter 5 is a survey of neural network models. This chapter describes the features of several models, describes threshold functions, and develops concepts in neural networks. • Chapter 6 focuses on learning and training paradigms. It introduces the concepts of supervised and unsupervised learning, self-organization and topics including backpropagation of errors, radial basis function networks, and conjugate gradient methods. • Chapter 7 goes through the construction of a backpropagation simulator. You will find this simulator useful in later chapters also. C++ classes and features are detailed in this chapter. • Chapter 8 covers the Bidirectional Associative memories for associating pairs of patterns. • Chapter 9 introduces Fuzzy Associative memories for associating pairs of fuzzy sets. • Chapter 10 covers the Adaptive Resonance Theory of Grossberg. You will have a chance to experiment with a program that illustrates the working of this theory. • Chapters 11 and 12 discuss the Self-Organizing map of Teuvo Kohonen and its application to pattern recognition. • Chapter 13 continues the discussion of the backpropagation simulator, with enhancements made to the simulator to include momentum and noise during training. • Chapter 14 applies backpropagation to the problem of financial forecasting, discusses setting up a backpropagation network with 15 input variables and 200 test cases to run a simulation. The problem is approached via a systematic 12-step approach for preprocessing data and setting up the problem. You will find a number of examples of financial forecasting highlighted from the literature. A resource guide for neural networks in finance is included for people who would like more information about this area. • Chapter 15 deals with nonlinear optimization with a thorough discussion of the Traveling Salesperson problem. You learn the formulation by Hopfield and the approach of Kohonen. • Chapter 16 treats two application areas of fuzzy logic: fuzzy control systems and fuzzy databases. This chapter also expands on fuzzy relations and fuzzy set theory with several examples. • Chapter 17 discusses some of the latest applications using neural networks and fuzzy logic.

MATLAB Coder User Guide 2015（官方文档） 在MATLAB中开发完算法后，往往需要把算法转换成高级语言的源程序，之后对转化的源程序再进行工程化开发。Coder可以帮助开发人员自动化的完成大部分转化功能。尽管一些与矩阵运算的功能仍然要手动优化，但是框架代码的转化可以自动化实现。

MATLAB2014b; 安装序列号（测试环境ubuntu 14.10， 64位）

MATLAB 2014b 许可协议文件（Linux，64位，Ubuntu14.10已测试）

MATLAB 2014b Linux破解文件, libmwservices.so

MATLAB 2014b 安装镜像修改文件，用于替换镜像中原有install.jar，否则产品列表中只有有限的几项可以选择。

Nerual Network Design (2nd Edition) Content Ch 2 Neuron Model and Network Architectures Ch 3 An Illustrative Example Ch 4 Perceptron Learning Rule Ch 5 Signal and Weight Vector Spaces Ch 6 Linear Transformations for Neural Networks Ch 7 Supervised Hebbian Learning Ch 8 Performance Surfaces and Optimum Points Ch 9 Performance Optimization Ch 10 Widrow-Hoff Learning Ch 11 Backpropagation Ch 12 Variations on Backpropagation Ch 13 Generalization Ch 14 Dynamic Networks Ch 15 Associative Learning Ch 16 Competitive Networks Ch 17 Radial Basis Networks Ch 18 Grossberg Network Ch 19 Adaptive Resonance Theory Ch 20 Stability Ch 21 Hopfield Network Ch 22 Practical Training Issues Ch 23 Case Study 1:Function Approximation Ch 24 Case Study 2:Probability Estimation Ch 25 Case Study 3:Pattern Recognition Ch 26 Case Study 4: Clustering Ch 27 Case Study 5: Prediction

神经网络现在又重新回到很多人关注的焦点中，所以特地把MATLAB 2014A中有关神经网络的工具箱使用资料分享给大家。 以下是目录摘要： ----------------------------------------------------- Automatic Script Generation . . . . 1-6 Neural Network Toolbox Applications . 1-7 Neural Network Design Steps . . . . . 1-9 Fit Data with a Neural Network . . . 1-10 Defining a Problem. . . . . . . . . . 1-10 Using the Neural Network Fitting Tool . . 1-12 Using Command-Line Functions . . . . . . . 1-23 Classify Patterns with a Neural Network . . 1-33 Defining a Problem . . . . . . . . . . .. . 1-33 Using the Neural Network Pattern Recognition Tool .. 1-35 Using Command-Line Functions . . . . . . . . . . . . 1-47 Cluster Data with a Self-Organizing Map . . . . . . 1-56 Defining a Problem . . . . . . . . . . . . . . . . . 1-56 vii Using the Neural Network Clustering Tool ... . . 1-57 Using Command-Line Functions . . . . . . . . .. . . 1-67 Neural Network Time Series Prediction and Modeling . . . . . . . . . . . . . . . . . . . 1-75 Defining a Problem . . . . . . . . . . . . . . 1-75 Using the Neural Network Time Series Tool . . . . . 1-76 Using Command-Line Functions . . . . . . . . . . . . 1-88 Parallel Computing on CPUs and GPUs . . . . . . . . .1-99 Parallel Computing Toolbox . . . . . . . . . . . . . 1-99 Parallel CPU Workers . . . . . . . . . . . . . . . . 1-99 GPU Computing . . . .. . . . . . . . . . . . . . . . 1-100 Multiple GPU/CPU Computing . . . . . . . . . . . . . 1-100 Cluster Computing with MATLAB Distributed Computing Server . . . . . . . . . . . . . . . . . . . . . . . 1-101 Load Balancing, Large Problems, and Beyond . . . . . 1-101 Neural Network Toolbox Sample Data Sets . . . . . . 1-103

这是Windows System Programming的勘误表，供参考。

这是目前为止我见过的最完整的使用LPV增益调度（Linear Parameter Varying Gain Scheduling）方法对风电机组控制系统进行描述的专著。其中，详细的给出了定桨变速和变桨变速机型完整的建模过程和分析过程，其中相当一部分内容可以使用MATLAB Robust Control Toolbox进行验证。 这本书属于控制理论的中高级参考资料，如果希望深入理解全书的内容，建议先仔细研究一下周克敏编著的《鲁棒与最优控制》。不过，即使暂时不使用LPV增益调度方法进行算法的编写，也可以从这本书中关于定桨变速和变桨变速功率控制过程的详细分析中受益。 这本书机械工业出版社有中文版，但是我从摘要内容看翻译质量不佳，所以希望本书的读者且有且珍惜。^_^

本书是从方法论的视角来介绍C++语言，重点阐述了C++基础本分的主要内容。它适合完全没有编程基础的人学习C++。尽管教材有点老，例如很多语法的运用还是C++98之前的语句。不过，作为入门教材并不影响学习。 目录： Ch1: The way of the program Ch2: Variables and types Ch3: Function Ch4: Conditions and recursion Ch5: Fruitful functions Ch6: Iteration Ch7: Strings and things Ch8: Structures Ch9: More Structures Ch10: Vectors Ch11: Member functions Ch12: Vectors of objects Ch13: Objects of vectors Ch14: Classes and invariants Ch15: File input/output and apmatrixes Annex A：Quick references for AP Classes

这是C++ Template Metaprogramming原书附带的例子代码，可以方便各位进行研习，请首先编译开篇的第一个例子，以测试你手头的编译器对模板的支持程度。 另，有的亲反映上载的书无法打开，可能是Windows7进行了权限控制，请选择文件，然后单击右键选“属性”，然后选“解除锁定”就可以阅读了。

推荐做移动开发和嵌入式系统的人抽空演习一下，尽管硬件资源越来越廉价，但是如何有效地利用各种资源譬如存储器是高手成长的必经之路。 Table of Contents --------------------------------------------- Code Optimization—Effective Memory Usage Introduction to Optimization Chapter 1 - Program Profiling Chapter 2 - RAM Subsystem Chapter 3 - Cache Subsystem Chapter 4 - Machine Optimization On the CD-ROM Index List of Figures List of Tables List of Listings Intended Audience -------------------------------- This book describes the organization, architecture, and mechanisms of interaction between various hardware components. It focuses on efficient programming and code-optimization techniques, at the level of machine code and of data structures. The book is oriented toward application programmers with some experience in C/C++ programming, as well as toward system programmers with knowledge of the assembly language. However, the optimization techniques described here are not bound to any high-level programming language. Thus, knowledge of C is required only for understanding the source code provided in this book. I also hope that this book will be useful to hardware specialists and technicians — especially those who build and fine-tune computers. I tried to provide detailed descriptions of the hardware operating principles and discuss the bottlenecks of the most common hardware components. Most materials provided in this book are based on my experience. All information has been tested and checked carefully. However, I can't guarantee that it is free of errors. (After all, "there is always one more bug.") The materials of the book are mainly applicable to the AMD Athlon and the Intel Pentium II, Pentium III, and Pentium 4 microprocessors. Earlier processors are mentioned and considered when necessary.

一本有关内存管理的专著，以下是目录和针对读者说明。 Content -------------------------------- Introduction Chapter 1 - Memory Management Mechanisms Chapter 2 - Memory Management Policies Chapter 3 - High-Level Services Chapter 4 - Manual Memory Management Chapter 5 - Automatic Memory Management Chapter 6 - Miscellaneous Topics Audience -------------------------- This book is directed toward professional developers and students who are interested in discovering how memory is managed on production systems. Specifically, engineers working on PC or embedded operating systems may want to refresh their memory or take a look at alternative approaches. If this is the case, then this book will serve as a repository of algorithms and software components that you can apply to your day-to-day issues. Professionals who design and construct development tools will also find this book useful. In general, development tools fall into the class of online transaction processing (OLTP) programs. When it comes to OLTP apps, pure speed is the name of the game. As such, programming language tools, like compilers, often make use of suballocators to speed up the performance of the code that manipulates their symbol table. With regard to compiling large software programs consisting of millions of lines of code, this type of suballocator-based optimization can mean the difference between waiting for a few minutes and waiting for a few hours. Anyone who mucks around with suballocators will find this book indispensable. Software engineers who work with virtual machines will also be interested in the topics that I cover. The Java virtual machine is famous for its garbage collection facilities. In this book I explore several automatic memory management techniques and also provide a couple of concrete garbage collection implementations in C++. Finally, this book also targets the curious. There is absolutely nothing wrong with being curious. In fact, I would encourage it. You may be an application developer who has used memory management facilities countless times in the past without taking the time to determine how they really work. You may also have nurtured an interest that you have had to repress due to deadlines and other priorities. This book will offer such engineers an opportunity to indulge their desire to see what is going on under the hood.

请注意本书不是入门教程，一本面向中高级C++开发者的书，对于某些章节，例如AI的应用，最好有一定的基础才方便阅读。原书的内容概述如下。特别提示：本书各章节相对独立，可以分开阅读。 What’s Inside （The Art of C++) This book is different from most other books on C++. Whereas other books teach the basics of the language, this book shows how to apply it to a wide range of interesting, useful, and, at times, mysterious programming tasks. In the process, it displays the power and elegance of the C++ language. Thus, it is through the art of C++ that the artistry of C++’s design is displayed. In general, the book contains two types of applications. The first type I call “pure code” because they focus on expanding the C++ programming environment, itself. The garbage collector in Chapter 2, the thread control panel in Chapter 3, and the custom STL container in Chapter 8 are examples. The second type shows how C++ can be applied to a variety of computing tasks. For example, Chapter 5 develops a restartable Internet downloader, Chapter 6 shows how to create financial applications, and Chapter 8 applies C++ to Artificial Intelligence. The book ends with a unique and interesting piece of code: the Mini C++ interpreter, which interprets a small subset of C++. Mini C++ gives insight into how the keywords and syntax of C++ work together to create the grammar of the language. Moreover, it lets you get “inside the language,” showing some of the reasons behind C++’s design. Although Mini C++ is fun to use as-is, it can also serve as a starting point for your own language development, or be adapted to work as an interpreter for any other language. Each chapter develops code that you can use as-is, without changes. For example, the garbage collector in Chapter 2 is applicable to many programming tasks. However, the real benefits result when you use the applications as starting points for your own development. For example, the Internet file downloader in Chapter 8 could be enhanced to start a download at a specific time, or to watch a download site, waiting to download until an updated file is posted. In general, think of the various programs and subsystems as launching pads for your own projects.