This document is a doctrine manual that provides instructions on how to get started with doctrine, including requirements, installation methods, starting new projects, creating tables, generating models, auto loading models, using the command line interface, and a tutorial on creating a basic project with users. It also covers connecting to databases, managing connections, basic schema mapping including table and class naming, table and column options, and data types.
This document provides documentation for the NetworkX Python package for working with network graphs. It covers how to install NetworkX via quick install, from source, or pre-built packages. It describes requirements like Python and optional packages. It then provides a tutorial on NetworkX basics, examples, input/output, directed/undirected graphs, and interfacing with other tools.
This document provides reference documentation for Pylons version 0.9.7. It covers getting started topics like requirements, installation and creating a Pylons project. It also covers key Pylons concepts like WSGI applications and middleware. The document is divided into several sections that cover controllers, views, models, configuration, logging, helpers, forms and internationalization.
Information extraction systems aspects and characteristicsGeorge Ang
This document provides a survey of information extraction systems and techniques. It discusses the main components and design approaches of information extraction, including manual and automatic pattern discovery. It also reviews several important prior information extraction systems and approaches to wrapper generation, including both supervised and unsupervised methods. The document serves to describe the state of the art in information extraction and provide an overview of the field.
This document is a manual for Cinelerra CV, an open source non-linear video editor for Linux. It discusses installing and configuring Cinelerra CV, including hardware and software requirements and instructions for different Linux distributions. It also covers compiling Cinelerra from source, configuring audio and video drivers, and playback settings. The manual is distributed under the GNU GPL license.
This document outlines the goals and requirements for Project 3, which involves writing a kernel from scratch. It discusses hardware primitives, the boot process, device drivers, context switching, scheduling, system calls, building and loading user programs, the programming environment, hints for implementing a kernel, and debugging strategies. The project involves implementing an operating system kernel that supports interrupts, scheduling, and basic system calls.
This document provides an overview and instructions for using WebHost Manager, a control panel for managing web hosting servers and accounts. It describes how to install and log into WebHost Manager, configure server settings like backups and quotas, and manage user accounts including creating, modifying, suspending, and deleting accounts. The document is organized into sections covering installation, server setup, support, backups, reboots, status checks, and account functions.
This document is the CUDA API Reference Manual for version 5.0. It provides documentation on the CUDA API, including sections that describe the synchronization behavior of functions like memcpy and kernel launches. It also includes indexes of deprecated functions, modules, and data structures. The majority of the document consists of in-depth documentation of the functions within each CUDA API module, including parameters, return values, and usage examples.
This document provides instructions for installing and administering R on various operating systems. It covers obtaining R sources, installing on Unix-like systems, Windows, and OS X. It also discusses installing add-on packages, internationalization, choosing 32- vs 64-bit builds, and using the standalone Rmath library. The document is intended as a manual for installing and managing R versions 3.0.2 or higher.
This document provides documentation for the NetworkX Python package for working with network graphs. It covers how to install NetworkX via quick install, from source, or pre-built packages. It describes requirements like Python and optional packages. It then provides a tutorial on NetworkX basics, examples, input/output, directed/undirected graphs, and interfacing with other tools.
This document provides reference documentation for Pylons version 0.9.7. It covers getting started topics like requirements, installation and creating a Pylons project. It also covers key Pylons concepts like WSGI applications and middleware. The document is divided into several sections that cover controllers, views, models, configuration, logging, helpers, forms and internationalization.
Information extraction systems aspects and characteristicsGeorge Ang
This document provides a survey of information extraction systems and techniques. It discusses the main components and design approaches of information extraction, including manual and automatic pattern discovery. It also reviews several important prior information extraction systems and approaches to wrapper generation, including both supervised and unsupervised methods. The document serves to describe the state of the art in information extraction and provide an overview of the field.
This document is a manual for Cinelerra CV, an open source non-linear video editor for Linux. It discusses installing and configuring Cinelerra CV, including hardware and software requirements and instructions for different Linux distributions. It also covers compiling Cinelerra from source, configuring audio and video drivers, and playback settings. The manual is distributed under the GNU GPL license.
This document outlines the goals and requirements for Project 3, which involves writing a kernel from scratch. It discusses hardware primitives, the boot process, device drivers, context switching, scheduling, system calls, building and loading user programs, the programming environment, hints for implementing a kernel, and debugging strategies. The project involves implementing an operating system kernel that supports interrupts, scheduling, and basic system calls.
This document provides an overview and instructions for using WebHost Manager, a control panel for managing web hosting servers and accounts. It describes how to install and log into WebHost Manager, configure server settings like backups and quotas, and manage user accounts including creating, modifying, suspending, and deleting accounts. The document is organized into sections covering installation, server setup, support, backups, reboots, status checks, and account functions.
This document is the CUDA API Reference Manual for version 5.0. It provides documentation on the CUDA API, including sections that describe the synchronization behavior of functions like memcpy and kernel launches. It also includes indexes of deprecated functions, modules, and data structures. The majority of the document consists of in-depth documentation of the functions within each CUDA API module, including parameters, return values, and usage examples.
This document provides instructions for installing and administering R on various operating systems. It covers obtaining R sources, installing on Unix-like systems, Windows, and OS X. It also discusses installing add-on packages, internationalization, choosing 32- vs 64-bit builds, and using the standalone Rmath library. The document is intended as a manual for installing and managing R versions 3.0.2 or higher.
The document provides an overview of Doctrine 2, an object-relational mapper (ORM) for PHP. Some key points:
- Doctrine 2 has been completely rewritten from Doctrine 1 and requires PHP 5.3. It uses namespaces, has a new architecture and workflow.
- It provides a database abstraction layer (DBAL), object relational mapper (ORM), and common utilities. The DBAL can be used independently of the ORM.
- Entities do not need to extend a base class. Metadata is provided via annotations, YAML or XML.
- Performance is improved over Doctrine 1 through optimizations like a faster hydration algorithm.
- The documentation covers
The document provides an overview of Doctrine 2, an object-relational mapper (ORM) for PHP. Some key points:
- Doctrine 2 has been completely rewritten from Doctrine 1 and requires PHP 5.3. It uses namespaces, has a new architecture and workflow.
- It provides a database abstraction layer (DBAL), object relational mapper (ORM), and common utilities. The DBAL can be used independently of the ORM.
- Entities do not need to extend a base class. Metadata is provided via annotations, YAML or XML.
- Performance is improved over Doctrine 1 through optimizations like a faster hydration algorithm.
- The documentation covers
O documento discute ondas de rádio, explicando que elas possuem o maior comprimento de onda e menor frequência em comparação com outras faixas eletromagnéticas. Detalha como as ondas de rádio funcionam através de antenas e frequências específicas, e a diferença entre transmissão AM e FM. Também menciona a radioastronomia.
Reflexión y refracción de las ondas esfericasAngel Cisneros
La reflexión ocurre cuando una onda de sonido rebota en un medio que no puede traspasar ni rodear, regresando al medio original. La refracción ocurre cuando el sonido pasa de un medio a otro, desviando las ondas de su trayectoria original. Los materiales como el concreto reflejan bien el sonido debido a su alta densidad, mientras que materiales blandos y de baja densidad como las cortinas absorben parte del sonido. Cuando una onda elástica incide en la corteza terrestre, la onda que rebote
Las ondas de radio son un tipo de radiación electromagnética que se usan ampliamente en comunicaciones. Han evolucionado desde los primeros osciladores de audio hasta tecnologías modernas que nos benefician en la vida cotidiana. Las ondas de radio varían en longitud desde milímetros hasta cientos de kilómetros y oscilan en frecuencias entre kilohercios y terahercios.
Este documento trata sobre diferentes tipos de ondas electromagnéticas como las ondas de radio, microondas, satelitales y WiFi, y cómo se usan para transmitir información. Describe cómo las ondas de radio no necesitan un medio físico, cómo las microondas y satelitales se usan para comunicaciones a larga distancia, y cómo el WiFi y Bluetooth permiten conexiones inalámbricas a corta distancia. También discute estándares como IEEE 802.11 para WiFi y 802.16 para WiMAX.
Este documento describe los fenómenos de refracción y difracción de las ondas. La refracción ocurre cuando una onda cambia de velocidad al pasar entre dos medios, cambiando su dirección. La difracción ocurre cuando las ondas se curvan y dispersan al encontrarse con un obstáculo. Ambos efectos se rigen por leyes: la ley de Snell describe la refracción y la ley de Bragg describe cómo la difracción revela la estructura cristalina.
Este documento resume tres temas fundamentales de las telecomunicaciones: 1) La propagación de ondas electromagnéticas, incluyendo diferentes formas como la propagación superficial, troposférica e ionosférica. 2) Las propiedades ópticas de la luz, como la reflexión, refracción, absorción y difracción. 3) La polarización de ondas electromagnéticas, la cual ocurre cuando la parte eléctrica de la onda oscila en un solo plano, pudiendo ser lineal, elíptica o circular. Estos temas son esen
This document provides reference documentation for Pylons version 0.9.7. It covers getting started topics like requirements, installation and creating a Pylons project. It also covers key Pylons concepts like WSGI applications and middleware. The document is divided into several sections that cover controllers, views, models, configuration, logging, helpers, forms and internationalization.
This document is a book about MIPS Assembly Language Programming. It covers various topics related to MIPS assembly language such as data representation, memory organization, the MIPS instruction set, writing MIPS assembly programs, and using the SPIM simulator. The book is intended as a reference and contains tutorials, examples, and exercises to help the reader learn MIPS assembly programming.
This document provides guidelines for creating and developing R packages. It discusses the standard package structure and files like DESCRIPTION and NAMESPACE. It also covers checking, building and submitting packages to CRAN. Guidelines are provided for writing documentation using the Rd format and internationalization. The document is a comprehensive reference for developing high-quality R packages.
This document describes the Embedded Filesystem Library (EFSL), which provides filesystem functionality for embedded systems. It allows accessing files stored on various storage devices from different microcontroller families. The document explains how to set up and compile EFSL for Linux, AVR, DSP and ARM microcontrollers. It provides examples and describes the EFSL API functions for opening, reading, writing and managing files and directories. It also gives notes for EFSL configuration and developing for new hardware targets.
TortoiseSVN is a Windows client for Subversion version control. It provides features for importing and exporting files to a repository, checking out working copies, committing changes, updating working copies, and viewing project history. The document discusses TortoiseSVN's installation, basic version control concepts, repository creation and management, daily use features like committing and updating, and resolving conflicts. It is intended as a user guide for getting started with and using TortoiseSVN for source control management.
This document provides instructions for installing and administering R on various operating systems. It covers obtaining R sources, compiling and installing R under Unix-like systems, Windows, and Mac OS X. It also discusses running R, installing add-on packages, internationalization, choosing 32- vs 64-bit builds, and the standalone Rmath library.
The use of synchrophasors for monitoring and improving the stability of power transmission networks is gaining in significance all over the world. The aim is to monitor the system state, to intensify awareness for system stability and to make optimal use of existing lines. This way, system stability can be improved overall and even the transmission performance can be increased. The data from so many PMU’s and PDC’s needs to be collected and directed to proper channels for its efficient use. Thus we need to develop an efficient, flexible and hybrid data concentrator that can serve this purpose. Besides accepting the data from PMU’s, PDC should be able to accept the data also from other PDC. We have designed such a PDC (iPDC) that accepts data from PMU & PDC that are IEEEC37.118 standard compliant.
WAMS architecture with iPDC and PMU at different levels. This architecture enables iPDC to receive data either from a PMU or other iPDC. Both PMU and iPDC from whom the data is being received should be IEEE C37.118 synchrophasor standard compliant. It is hybrid architecture.
iPDC Design
The client server architecture is common in networks when two peers are communicating with each other. Of the two peers (PMU and iPDC) that are communicating with each other in WAMS one acts as a client and the other as a server. Since PMU saves the requests coming
from iPDC by sending data or configuration frames it acts as a server. It listens for command frames from iPDC. PMU-iPDC communication can be either over TCP or UDP communication protocols. On receiving command frames, PMU replies to the iPDC with data or configuration frames according to the type of request.
iPDC functionality is bifurcated as server and client. iPDC as a Client - When iPDC receives data or configuration frames its acts as a client. When acting as a client, it creates a new thread for each PMU or a PDC from whom it is going to receive data/configuration frames. This thread would establish connection between the two communication entities. It handles both TCP and UDP connections. The first frame that the server (PMU/PDC) would receive is the command for sending the configuration frame. When the server replies with the configuration frame, iPDC (client) would generate another request to start sending the data frames. On receiving
such a command frame, the server starts sending the data frames. If there is some change in the status bits of data frame which the client (iPDC) notices, it would take an action. For example if it notices a bit 10 has been set, it would internally send a command to server to send the latest configuration frame.
iPDC as a Server- When iPDC receives command frames from another PDC it would acts as a server. There would be two reserved ports one for UDP and other for TCP on which the PDC would receive command frame requests. Thus PDC now plays the role of PMU waiting
for command frames.
This document provides an overview of R's internal structures and programming concepts. It discusses topics such as SEXPs (the basic R data structure), environments and variable lookup, attributes, contexts, argument evaluation, autoprinting, serialization formats, encodings, warnings and errors, S4 objects, memory allocation, and graphics devices. The document is intended for developers and advanced users who want to understand how R works under the hood.
The document is the Flask documentation, which provides information on using the Flask web framework in Python. It covers topics like installation, basic usage, routing, templates, testing, configuration, debugging errors, and signals. The documentation contains tutorials, guides, and reference material to help developers build web applications with Flask.
Ibm info sphere datastage data flow and job designdivjeev
This document provides an overview of IBM InfoSphere DataStage and discusses its key functions and best practices. It contains chapters that describe various IBM InfoSphere DataStage stages and components, present a retail industry scenario to demonstrate how to design and implement ETL jobs, and include additional reference material.
Jfreereport and Charts an essential Report generation tool for Java DevelopersSanjeev Kulkarni
This document is a reference guide for version 0.8.3 of the JFreeReport library. It includes an introduction to JFreeReport, instructions for downloading, installing, and running JFreeReport, and documentation of the simple and extended report definition formats. It also covers topics like functions, expressions, groups, and the package structure.
This document provides a tutorial on learning C++. It introduces fundamental C++ concepts like objects, data types, functions, classes and pointers. It is divided into chapters that cover getting started, decision making, loops, functions, structs, references, classes and pointers. Each chapter defines and provides examples for the core elements of C++ programming in that topic area.
The document provides an overview of Doctrine 2, an object-relational mapper (ORM) for PHP. Some key points:
- Doctrine 2 has been completely rewritten from Doctrine 1 and requires PHP 5.3. It uses namespaces, has a new architecture and workflow.
- It provides a database abstraction layer (DBAL), object relational mapper (ORM), and common utilities. The DBAL can be used independently of the ORM.
- Entities do not need to extend a base class. Metadata is provided via annotations, YAML or XML.
- Performance is improved over Doctrine 1 through optimizations like a faster hydration algorithm.
- The documentation covers
The document provides an overview of Doctrine 2, an object-relational mapper (ORM) for PHP. Some key points:
- Doctrine 2 has been completely rewritten from Doctrine 1 and requires PHP 5.3. It uses namespaces, has a new architecture and workflow.
- It provides a database abstraction layer (DBAL), object relational mapper (ORM), and common utilities. The DBAL can be used independently of the ORM.
- Entities do not need to extend a base class. Metadata is provided via annotations, YAML or XML.
- Performance is improved over Doctrine 1 through optimizations like a faster hydration algorithm.
- The documentation covers
O documento discute ondas de rádio, explicando que elas possuem o maior comprimento de onda e menor frequência em comparação com outras faixas eletromagnéticas. Detalha como as ondas de rádio funcionam através de antenas e frequências específicas, e a diferença entre transmissão AM e FM. Também menciona a radioastronomia.
Reflexión y refracción de las ondas esfericasAngel Cisneros
La reflexión ocurre cuando una onda de sonido rebota en un medio que no puede traspasar ni rodear, regresando al medio original. La refracción ocurre cuando el sonido pasa de un medio a otro, desviando las ondas de su trayectoria original. Los materiales como el concreto reflejan bien el sonido debido a su alta densidad, mientras que materiales blandos y de baja densidad como las cortinas absorben parte del sonido. Cuando una onda elástica incide en la corteza terrestre, la onda que rebote
Las ondas de radio son un tipo de radiación electromagnética que se usan ampliamente en comunicaciones. Han evolucionado desde los primeros osciladores de audio hasta tecnologías modernas que nos benefician en la vida cotidiana. Las ondas de radio varían en longitud desde milímetros hasta cientos de kilómetros y oscilan en frecuencias entre kilohercios y terahercios.
Este documento trata sobre diferentes tipos de ondas electromagnéticas como las ondas de radio, microondas, satelitales y WiFi, y cómo se usan para transmitir información. Describe cómo las ondas de radio no necesitan un medio físico, cómo las microondas y satelitales se usan para comunicaciones a larga distancia, y cómo el WiFi y Bluetooth permiten conexiones inalámbricas a corta distancia. También discute estándares como IEEE 802.11 para WiFi y 802.16 para WiMAX.
Este documento describe los fenómenos de refracción y difracción de las ondas. La refracción ocurre cuando una onda cambia de velocidad al pasar entre dos medios, cambiando su dirección. La difracción ocurre cuando las ondas se curvan y dispersan al encontrarse con un obstáculo. Ambos efectos se rigen por leyes: la ley de Snell describe la refracción y la ley de Bragg describe cómo la difracción revela la estructura cristalina.
Este documento resume tres temas fundamentales de las telecomunicaciones: 1) La propagación de ondas electromagnéticas, incluyendo diferentes formas como la propagación superficial, troposférica e ionosférica. 2) Las propiedades ópticas de la luz, como la reflexión, refracción, absorción y difracción. 3) La polarización de ondas electromagnéticas, la cual ocurre cuando la parte eléctrica de la onda oscila en un solo plano, pudiendo ser lineal, elíptica o circular. Estos temas son esen
This document provides reference documentation for Pylons version 0.9.7. It covers getting started topics like requirements, installation and creating a Pylons project. It also covers key Pylons concepts like WSGI applications and middleware. The document is divided into several sections that cover controllers, views, models, configuration, logging, helpers, forms and internationalization.
This document is a book about MIPS Assembly Language Programming. It covers various topics related to MIPS assembly language such as data representation, memory organization, the MIPS instruction set, writing MIPS assembly programs, and using the SPIM simulator. The book is intended as a reference and contains tutorials, examples, and exercises to help the reader learn MIPS assembly programming.
This document provides guidelines for creating and developing R packages. It discusses the standard package structure and files like DESCRIPTION and NAMESPACE. It also covers checking, building and submitting packages to CRAN. Guidelines are provided for writing documentation using the Rd format and internationalization. The document is a comprehensive reference for developing high-quality R packages.
This document describes the Embedded Filesystem Library (EFSL), which provides filesystem functionality for embedded systems. It allows accessing files stored on various storage devices from different microcontroller families. The document explains how to set up and compile EFSL for Linux, AVR, DSP and ARM microcontrollers. It provides examples and describes the EFSL API functions for opening, reading, writing and managing files and directories. It also gives notes for EFSL configuration and developing for new hardware targets.
TortoiseSVN is a Windows client for Subversion version control. It provides features for importing and exporting files to a repository, checking out working copies, committing changes, updating working copies, and viewing project history. The document discusses TortoiseSVN's installation, basic version control concepts, repository creation and management, daily use features like committing and updating, and resolving conflicts. It is intended as a user guide for getting started with and using TortoiseSVN for source control management.
This document provides instructions for installing and administering R on various operating systems. It covers obtaining R sources, compiling and installing R under Unix-like systems, Windows, and Mac OS X. It also discusses running R, installing add-on packages, internationalization, choosing 32- vs 64-bit builds, and the standalone Rmath library.
The use of synchrophasors for monitoring and improving the stability of power transmission networks is gaining in significance all over the world. The aim is to monitor the system state, to intensify awareness for system stability and to make optimal use of existing lines. This way, system stability can be improved overall and even the transmission performance can be increased. The data from so many PMU’s and PDC’s needs to be collected and directed to proper channels for its efficient use. Thus we need to develop an efficient, flexible and hybrid data concentrator that can serve this purpose. Besides accepting the data from PMU’s, PDC should be able to accept the data also from other PDC. We have designed such a PDC (iPDC) that accepts data from PMU & PDC that are IEEEC37.118 standard compliant.
WAMS architecture with iPDC and PMU at different levels. This architecture enables iPDC to receive data either from a PMU or other iPDC. Both PMU and iPDC from whom the data is being received should be IEEE C37.118 synchrophasor standard compliant. It is hybrid architecture.
iPDC Design
The client server architecture is common in networks when two peers are communicating with each other. Of the two peers (PMU and iPDC) that are communicating with each other in WAMS one acts as a client and the other as a server. Since PMU saves the requests coming
from iPDC by sending data or configuration frames it acts as a server. It listens for command frames from iPDC. PMU-iPDC communication can be either over TCP or UDP communication protocols. On receiving command frames, PMU replies to the iPDC with data or configuration frames according to the type of request.
iPDC functionality is bifurcated as server and client. iPDC as a Client - When iPDC receives data or configuration frames its acts as a client. When acting as a client, it creates a new thread for each PMU or a PDC from whom it is going to receive data/configuration frames. This thread would establish connection between the two communication entities. It handles both TCP and UDP connections. The first frame that the server (PMU/PDC) would receive is the command for sending the configuration frame. When the server replies with the configuration frame, iPDC (client) would generate another request to start sending the data frames. On receiving
such a command frame, the server starts sending the data frames. If there is some change in the status bits of data frame which the client (iPDC) notices, it would take an action. For example if it notices a bit 10 has been set, it would internally send a command to server to send the latest configuration frame.
iPDC as a Server- When iPDC receives command frames from another PDC it would acts as a server. There would be two reserved ports one for UDP and other for TCP on which the PDC would receive command frame requests. Thus PDC now plays the role of PMU waiting
for command frames.
This document provides an overview of R's internal structures and programming concepts. It discusses topics such as SEXPs (the basic R data structure), environments and variable lookup, attributes, contexts, argument evaluation, autoprinting, serialization formats, encodings, warnings and errors, S4 objects, memory allocation, and graphics devices. The document is intended for developers and advanced users who want to understand how R works under the hood.
The document is the Flask documentation, which provides information on using the Flask web framework in Python. It covers topics like installation, basic usage, routing, templates, testing, configuration, debugging errors, and signals. The documentation contains tutorials, guides, and reference material to help developers build web applications with Flask.
Ibm info sphere datastage data flow and job designdivjeev
This document provides an overview of IBM InfoSphere DataStage and discusses its key functions and best practices. It contains chapters that describe various IBM InfoSphere DataStage stages and components, present a retail industry scenario to demonstrate how to design and implement ETL jobs, and include additional reference material.
Jfreereport and Charts an essential Report generation tool for Java DevelopersSanjeev Kulkarni
This document is a reference guide for version 0.8.3 of the JFreeReport library. It includes an introduction to JFreeReport, instructions for downloading, installing, and running JFreeReport, and documentation of the simple and extended report definition formats. It also covers topics like functions, expressions, groups, and the package structure.
This document provides a tutorial on learning C++. It introduces fundamental C++ concepts like objects, data types, functions, classes and pointers. It is divided into chapters that cover getting started, decision making, loops, functions, structs, references, classes and pointers. Each chapter defines and provides examples for the core elements of C++ programming in that topic area.
This document is a user guide for the LSI SAS2 Integrated RAID solution. It describes the benefits of the integrated RAID solution such as host interface support, metadata support, SMART support, and Fusion-MPT support. It also provides overviews of how mirrored volumes operate and their key features like resynchronization, hot swapping, hot spares, online capacity expansion, and more. The document includes steps for creating mirrored volumes, managing hot spare disks, and other administrative tasks.
This document describes MPI for Python, a package that provides bindings for the Message Passing Interface (MPI) standard to allow Python programs to exploit multiple processors. It supports point-to-point and collective communications of picklable Python objects as well as optimized communication of objects like NumPy arrays that expose a single-segment buffer interface. The interface is designed to closely follow the MPI-2 C++ bindings for compatibility with standard MPI usage.
This document describes a student project using the B-Method formal method to model and verify the software for NASA's Simplified Aid for EVA Rescue (SAFER) system. It provides background on formal methods and the B-Method approach. The student developed formal models for the SAFER system at different levels of abstraction using B-Method concepts like abstract machines, refinement, and implementation. The models were analyzed using the AtelierB tool to check types and proofs. The document evaluates the modeling effort and outlines plans for future work.
This document provides documentation for Zend Framework 2. It outlines the installation and getting started process for Zend Framework 2 applications. It then walks through building a sample album application module by module, covering routing, controllers, models, forms and actions. It also discusses additional topics like unit testing, events, configuration and authentication.
This document is the user manual for Snort version 2.8.6. It provides an overview of Snort's capabilities in different operating modes like sniffer, packet logger, and network intrusion detection system modes. It also describes how to configure Snort, including preprocessor and rule configuration, as well as output and logging options. The document contains detailed information on topics like includes, rule profiling, output modules, and more.
This document proposes a system to allow a robot to automatically find a path to a predefined goal in uncontrolled environments. The system has three main modules: 1) An artificial vision module that obtains a quantified representation of the robot's vision using local feature detection and visual words. 2) A reinforcement learning module that receives the vision input and sensor data to compute the state and reward. The state is a normalized vector and sensor data, and reward is based on distance to the goal. 3) A behavior control module. The robot is tested using Sony Aibo to seek the goal and change behavior based on experience, but does not find the optimal route.
This document provides notes from a Linux system administration course. It covers topics like installing Red Hat Linux, configuring XFree86 for graphics, managing software packages, understanding the boot sequence, basic network concepts, kernel functions, configuring services, managing users and groups, working with filesystems, and basic security measures. The document contains detailed sections on partitioning and formatting disks, mounting filesystems, and using common Linux administration tools.
13. Chapter 1
Getting started
1.1 Requirements
Doctrine requires PHP >= 5.2. it doesn’t require any external libraries. For database function
call abstraction
Doctrine uses PDO which is bundled with php by default.
1.2 Installation
There are currently four different methods to install Doctrine.
• SVN (subversion)
• SVN externals
• Pear
• Zip-package
It is recommended to download Doctrine via SVN (subversion), because in this case updating
is easy.
If your project is already under version control with SVN, you should choose SVN externals.
If you wish to just try out Doctrine in under 5 minutes, the sandbox package is recommended.
1.2.1 Sandbox Package
Doctrine also provides a special package which is a zero configuration Doctrine implementation.
It
includes a fully featured command line interface for managing your schema files, migrations,
database connections, data fixtures, and many other features. You can read about the sandbox
package
and how to use it in the 6 chapter under the Sandbox section.
Below you will find the url to a tutorial on how to how to get started using
Doctrine with the sandbox package. With the sandbox and this tutorial you can get Doctrine
up
and running in under 5 minutes. The tutorial offers example schema files, data fixtures, and a
14. Chapter 1. Getting started Doctrine Manual
simple
script for managing a ”User” model with Doctrine. Simple create, update, delete functionality.
The tutorial can be found here http://trac.phpdoctrine.org/wiki/MyFirstProject and the
sandbox package
can be downloaded from here http://www.phpdoctrine.org/download
1.2.2 SVN
The installation of doctrine via SVN is very easy. Just get the latest revision of Doctrine from
http://svn.phpdoctrine.org/branches/0.10.
In order to check out Doctrine in the current directory using the svn command line tool use the
following code:
Listing 1.1:
svn co http :// svn . phpdoctrine . org / branches /0.10 .
If you do not have a SVN client, chose one from the list below. Find the Checkout option and
enter
svn.phpdoctrine.org/branches/0.10 in the path or repository url parameter. There is no need
for a username
or password to check out Doctrine.
• TortoiseSVN1 a Windows application that integrates into Windows Explorer
• svnx2 a Mac OS X GUI svn application
• Eclipse has SVN integration through the subeclipse3 plugin
You can update to the latest version with
Listing 1.2:
svn update
in your doctrine directory.
1.2.3 SVN externals
If your project is under version control with SVN, you should set up doctrine via svn externals.
You can do this with
the svn command line tool:
Listing 1.3:
svn pe svn : externals / path / to / project
You have to put the following line in the editor and save the changes.
Listing 1.4:
doctrine http :// svn . phpdoctrine . org / branches /0.10
Afterwards you can download doctrine with
Listing 1.5:
svn update
1
http://tortoisesvn.tigris.org/
2
http://www.apple.com/downloads/macosx/development tools/svnx.html
3
http://subclipse.tigris.org/
14
15. Doctrine Manual 1.3. Starting new project
1.2.4 PEAR
You can install Doctrine via PEAR with the following command:
Listing 1.6:
pear install http :// pear . phpdoctrine . org / Doctrine -0.10.2
1.2.5 Zip-package
You can download Doctrine as a .zip or .tgz (for Linux) package from http://www.phpdoctrine.
org/download.
Simply unzip it to your project directory with your favorite zip tool.
Under Linux you can extract the .tgz package with the following command line instruction:
Listing 1.7:
tar xzf Doctrine -0.10.1. tgz
1.3 Starting new project
Doctrine Record is the basic component of every doctrine-based project. There should be atleast
one Doctrine Record for
each of your database tables. Doctrine Record follows the [http://www.martinfowler.com/
eaaCatalog/activeRecord.html
Active Record pattern]
Doctrine always adds a primary key column named ’id’ to tables that doesn’t have any primary
keys specified. Only thing
you need to for creating database tables is defining a class which extends Doctrine Record and
setting a setTableDefinition
method with hasColumn() method calls and by exporting those classes.
Lets say we want to create a database table called ’user’ with columns id(primary key), name,
username, password and
created. Provided that you have already installed Doctrine these few lines of code are all you
need:
User.php :
Listing 1.8:
<? php
class User extends Doctrine_Record
{
public function setTableDefinition ()
{
// set ’ user ’ table columns , note that
// id column is auto - created as no primary key is specified
$this - > hasColumn ( ’ name ’ , ’ string ’ ,30) ;
$this - > hasColumn ( ’ username ’ , ’ string ’ ,20) ;
$this - > hasColumn ( ’ password ’ , ’ string ’ ,16) ;
}
public function setUp ()
{
15
16. Chapter 1. Getting started Doctrine Manual
$this - > actAs ( ’ Timestampable ’) ;
}
}
?>
You can alternatively specify your Doctrine schema information as a YAML schema file. Below
is an example user.yml file
which you can generate your Doctrine Record from.
Listing 1.9:
---
User :
actAs : [ Timestampable ]
columns :
name : string (30)
username : string (20)
password : string (16)
You can generate the php code from the yaml with the following code.
Listing 1.10:
<? php
Doctrine : : g e ne ra teM od el sFr om Ya ml ( ’/ path / to / user . yml ’ , ’/ path / to / generate / models )
;
?>
Have a look in /path/to/generate/models/ and /path/to/generate/models/generated. You will
see User.php and BaseUser.class.php.
User.php is for you to add your own custom functionality, and BaseUser.php is the code which
is automatically regenerated
from the YAML schema file above each time.
Now that we have a Doctrine Record class, we can export it to the database and create the
tables. For exporting the user
class into database we need a simple build script:
Listing 1.11:
<? php
// require the base Doctrine class
require_once ( ’ path - to - doctrine / lib / Doctrine . php ’) ;
// register the autoloader
sp l _ a u t o l o a d _reg ister ( array ( ’ Doctrine ’ , ’ autoload ’) ) ;
require_once ( ’ User . php ’) ;
// set up a connection
Doctrine_Manager : : connection ( ’ mysql : // user : pass @ localhost / test ’) ;
// export the classes
Doctrine : : c r e ateT ables From Array ( array ( ’ User ’) ) ;
?>
We now have a user model that supports basic CRUD opperations!
16
17. Doctrine Manual 1.4. Working with existing databases
1.4 Working with existing databases
1.4.1 Introduction
A common case when looking for ORM tools like Doctrine is that the database and the code
that access it is growing
large/complex. A more substantial tool is needed then manual SQL code.
Doctrine has support for generating Doctrine Record classes from your existing database. There
is no need for you to
manually write all the Doctrine Record classes for your domain model.
1.4.2 Making the first import
Let’s consider we have a mysql database called test with a single table called ’file’.
The file table has been created with the following sql statement:
Listing 1.12:
CREATE TABLE file (
id INT UNSIGNED AUTO_INCREMENT NOT NULL ,
name VARCHAR (150) ,
size BIGINT ,
modified BIGINT ,
type VARCHAR (10) ,
content TEXT ,
path TEXT ,
PRIMARY KEY ( id ) )
Now we would like to convert it into Doctrine record class. It can be achieved easily with the
following code snippet:
Listing 1.13:
<? php
require_once ( ’ path - to - doctrine / lib / Doctrine . php ’) ;
s p l _ a u t oload _reg ister ( array ( ’ Doctrine ’ , ’ autoload ’) ) ;
Doctrine_Manager : : connection ( ’ mysql : // root : dc34 @ localhost / test ’) ;
// import method takes one parameter : the import directory ( the directory where
// the generated record files will be put in
Doctrine : : generateModelsFromDb ( ’ myrecords ’) ;
?>
That’s it! Now there should be a file called BaseFile.php in your myrecords/generated directory.
The file should look like:
Listing 1.14:
<? php
/* *
* This class has been auto - generated by the Doctrine ORM Framework
*/
abstract class BaseFile extends Doctrine_Record
{
public function setTableDefinition ()
{
17
19. Doctrine Manual 1.5. Creating tables
}
This is where you can put your custom finder methods which can be used by calling Doc-
trine::getTable(’User’).
1.5 Creating tables
1.5.1 Introduction
Doctrine supports exporting record classes into database. This means that based on the defini-
tions given in your record
classes Doctrine will create the tables in your database.
Lets say we have a classes called User and Phonenumber with the following definitions:
Listing 1.17:
<? php
// file User . php
class User extends Doctrine_Record
{
public function setTableDefinition ()
{
$this - > hasColumn ( ’ name ’ , ’ string ’ , 20) ;
}
public function setUp ()
{
$this - > hasMany ( ’ Phonenumber ’ , array ( ’ local ’ = > ’ id ’ ,
’ foreign ’ = > ’ user_id ’) ) ;
}
}
// file Phonenumber . php
class Phonenumber extends Doctrine_Record
{
public function setTableDefinition ()
{
$this - > hasColumn ( ’ phonenumber ’ , ’ string ’ , 20) ;
$this - > hasColumn ( ’ user_id ’ , ’ integer ’) ;
}
public function setUp ()
{
$this - > hasOne ( ’ User ’ , array ( ’ local ’ = > ’ user_id ’ ,
’ foreign ’ = > ’ id ’ ,
’ onDelete ’ = > ’ CASCADE ’) ) ;
}
}
?>
Now lets say these classes are in directory ’models/’. We can make Doctrine to iterate through
this directory and
attach these classes into your database structure with the following script:
Listing 1.18:
<? php
require_once ( ’ path - to - doctrine / lib / Doctrine . php ’) ;
s p l _ a u t oload _reg ister ( array ( ’ Doctrine ’ , ’ autoload ’) ) ;
19
20. Chapter 1. Getting started Doctrine Manual
// in order to export we need a database connection
Doctrine_Manager : : connection ( ’ mysql : // user : pass @ localhost / test ’) ;
Doctrine : : c r ea te Tab le sF rom Mo de ls ( ’ models ’) ;
?>
This would execute the following queries on mysql.
Listing 1.19:
CREATE TABLE user ( id BIGINT AUTO_INCREMENT , name VARCHAR (20) , PRIMARY KEY ( id ) ,
INDEX ( id ) ) ;
CREATE TABLE phonenumber ( id INT AUTO_INCREMENT , phonenumber VARCHAR (20) ,
user_id BIGINT , PRIMARY KEY ( id ) , INDEX ( user_id ) ) ;
ALTER TABLE phonenumber ADD CONSTRAINT FOREIGN KEY ( user_id ) REFERENCES user ( id )
ON DELETE CASCADE ;
Pay attention to the following things:
1. The autoincrement primary key columns are auto-added since we didn’t specify any pri-
mary key columns
2. Doctrine auto-adds indexes to the referenced relation columns (this is needed in mysql)
1.5.2 Getting export queries
There might be situations where you don’t want to execute the export queries immediately
rather you want to get the
query strings and maybe attach them to a build.sql file. This can be easily achieved as follows:
Listing 1.20:
<? php
require_once ( ’ path - to - doctrine / lib / Doctrine . php ’) ;
sp l _ a u t o l o a d _reg ister ( array ( ’ Doctrine ’ , ’ autoload ’) ) ;
Doctrine_Manager : : connection ( ’ mgsql : // user : pass @ localhost / test ’) ;
$queries = Doctrine : : gen erat eSqlF romM odels ( ’ models ’) ;
echo $queries ;
?>
Consider the same situation and you want to get the string of sql queries needed to perform the
exporting. It can be
achieved with Doctrine::generateSqlFromModels().
1.5.3 Export options
Listing 1.21:
<? php
// export everything , table definitions and constraints
$manager = Doctrine_Manager : : getInstance () ;
20
21. Doctrine Manual 1.6. Generating models
$manager - > setAttribute ( Doctrine : : ATTR_EXPORT , Doctrine : : EXPORT_ALL ) ;
// export classes without constraints
$manager - > setAttribute ( Doctrine : : ATTR_EXPORT , Doctrine : : EXPORT_TABLES ^
Doctrine : : EXPORT_CONSTRAINTS ) ;
// turn off exporting
$manager - > setAttribute ( Doctrine : : ATTR_EXPORT , Doctrine : : EXPORT_NONE ) ;
$sql = Doctrine : : gen erat eSqlF romM odels () ;
?>
1.6 Generating models
Doctrine offers the ability to generate models from existing databases, or from YAML schema
files. You already read about
generating models from an existing database in the 1.4
section.
Here is a simple example of how to generate your models from yaml schema files.
Create a schema files/user.yml and place the following yaml in the file
Listing 1.22:
---
User :
columns :
username : string (255)
password : string (255)
Now we need can use a little script to generate the Doctrine Record definition.
Listing 1.23:
<? php
require_once ( ’/ path / to / Doctrine . php ’) ;
s p l _ a u t oload _reg ister ( array ( ’ Doctrine ’ , ’ autoload ’) ) ;
Doctrine : : ge ne ra teM od el sFr om Ya ml ( ’/ path / to / schema_files / ’ , ’/ path / to / generate /
models ’) ;
?>
Now you will have models/User.php and models/generated/BaseUser.php. User.php is for you
to add custom code to, it is
only generated once, and BaseUser.php is regenerated each time you call generateModels-
FromYaml()
1.7 Auto loading models
Doctrine offers two ways of loading models. We have conservative(lazy) loading, and aggressive
loading. Conservative loading
will not require the PHP file initially, instead it will cache the path to the class name and this
21
22. Chapter 1. Getting started Doctrine Manual
path is then used in the
Doctrine::autoload() we registered earlier with spl autoload register(array(’Doctrine’, ’autoload’)).
Below are some examples
using the both types of model loading.
1.7.1 Conservative
Conservative model loading is going to be the ideal model loading method for a production
environment. This method will lazy
load all of the models instead of loading them all when model loading is executed.
Conservative model loading requires that each file contain only one class, and the file must be
named after the class. Example,
if you have a class named User, it must be contained in a file named User.php
Here is an example of a basic Doctrine implementation using conservative model loading.
Listing 1.24:
<? php
// require the base Doctrine class
require_once ( ’ path - to - doctrine / lib / Doctrine . php ’) ;
// register the autoloader
sp l _ a u t o l o a d _reg ister ( array ( ’ Doctrine ’ , ’ autoload ’) ) ;
Doctrine_Manager : : getInstance () - > setAttribute ( ’ model_loading ’ , ’ conservative ’) ;
Doctrine : : loadModels ( ’/ path / to / models ’) ; // This call will not require the found
. php files
$user = new User () ; // This will invoke Doctrine : : autoload () to include the file
so the User class is present .
?>
1.7.2 Aggressive
Aggressive model loading is the default model loading method and is very simple, it will look
for all files with a .php
extension and will include it. Doctrine can not satisfy any inheritance and if your models extend
another model, it cannot
include them in the correct order so it is up to you to make sure all dependencies are satisfied
in each class.
With aggressive model loading you can have multiple classes per file, one class per file, and the
file name is not
required to be related to the name of the class inside of the file.
The downside of aggressive model loading is that every php file is included in every request, so
if you have lots of models
it is recommended you use conservative model loading.
Here is an example of a basic Doctrine implementation using aggressive model loading.
Listing 1.25:
<? php
// require the base Doctrine class
22