---
layout: null
order: 1
section-type: about
title: About
---
## About
Hey! I'm Stuart, and I've put this page together to showcase some of my work and accomplishments for you. Hopefully, you'll learn a little bit about me and get to see some of the cool stuff I've done.
Besides attending the second-best mechanical engineering college in the country and working in one of the world's most progressive and revered engineering firms, I've got plenty of other crazy business going on. I love sports -- I've been an avid volleyball player for about 7 years now. I also really like to travel, particularly when it means getting to check out Formula One cars in Italy. On an average Sunday evening you can find me either relentlessly chipping away at engineering homework in the library or sitting at home, sipping a local IPA and playing video games with friends.


Internationally, civil protection, police forces and emergency response agencies are under increasing pressure to more quickly and effectively respond to emergency situations. Moreover, such emergencies are common and recurring. For example, 50,000 people per-year on average die during natural disasters internationally.
The mass adoption of mobile internet-enabled devices paired with wide-spread use of social media platforms for communication and coordination has created ways for the public on-the-ground to contact response services. Moreover, a recent study reported that 63% of people expect responders to answer calls for help on social media.
With the rise of social media, emergency service operators are now expected to monitor those channels and answer questions from the public However, they do not have adequate tools or manpower to effectively monitor social media, due to the large volume of information posted on these platforms and the need to categorise, cross-reference and verify that information.
The Text Retrieval Conference is a combined conference and evaluation campaign that aims to encourage research into information retrieval technologies from large test collections. It is co-sponsored by the National Institute of Standards and Technology (NIST) Information Technology Laboratory's (ITL) Retrieval Group of the Information Access Division (IAD), and has run annually for over 25 years.
TREC consists of a set tracks, areas of focus in which particular retrieval tasks are defined. The tracks serve several purposes. First, tracks act as incubators for new research areas: the first running of a track often defines what the problem really is, and a track creates the necessary infrastructure (test collections, evaluation methodology, etc.) to support research on its task. The tracks also demonstrate the robustness of core retrieval technology in that the same techniques are frequently appropriate for a variety of tasks. Finally, they make TREC attractive to a broader community by providing tasks that match the research interests of more groups.
Incident Streams is a TREC track designed to bring together academia and industry to research technologies to automaticaly process social media streams during emergency situations with the aim of categorizing information and aid requests made on social media for emergency service operators.
The TREC-IS task is to produce a series of curated feeds containing social media posts, where each feed corresponds to a particular type of information request, aid request, or report containing a particular type of information. These ‘types’ are defined based on existing hierarchical incident management information ontologies, such as MOAC (Management of a Crisis), For instance, for a flash flooding event, feeds might include, ‘requests for food/water’, ‘reports of road blockages’, and ‘evacuation requests’. In this way, during an emergency, individual emergency management operators and other stakeholders can register to access to the subset of feeds within their domain of responsibility providing access to relevant social media content.
The TREC-IS track is currently in its set-up phase for the 2017-2018 edition. We are currently building the test collection that participants will experiment with, with a target release in early 2018.
You can join our Google Group with the button below to recieve updates and ask questions about the track.


One of the issues involved when attempting to use multiple testing tools; or when trying to migrate from one tool to another; is that each tool has devised a unique way of specifying or locating application components. Some tools, like IBM Rational Robot and Mercury's WinRunner, allow you to specify a simple string that contains information about the target component. Other tools, like IBM Rational RobotJ/XDE Tester, require that you provide a valid instance of a proxy "TestObject" or a similar component object--or the component itself--in order to perform an action on the component.
This document attempts to explain how the SAFS framework is evolving a standardized mechanism for specifying, locating, and then retrieving these component references for each tool-specific technology. It is important to note that this assumes the tool in use provides an API that allows you to retrieve and examine the component hierarchy of your application.
Goto: The Problem, SAFS Solution, Key Superclasses, A Walk-Thru.
Each GUI testing tool defines a unique mechanism for specifying and locating components in the tested application. Testers or frameworks wishing to exploit multiple tools, or migrating from one tool to another, must develop or maintain separate application-specific component maps for each testing tool in use. The extra effort for such development and maintenance causes testers or frameworks to avoid taking advantage of multiple tools; or from migrating from one tool to another.
Our current solution is to use a generic syntax that can identify key component attributes within the application component hierarchy. We then provide classes with an extendable algorithm that can interpret this syntax, and locate the desired component using tool-specific subclasses.
Several years ago RRAFS (Rational Robot) became our first SAFS Engine. The technology used to identify components was simple text strings. There were no proprietary classes or objects involved and the syntax of the strings crossed environments (C, VB, Java, Web, etc..)
In 2003 we developed and deployed the RobotJ engine. This was our first STAF-based engine and was intended to augment--not replace--the existing RRAFS engine. In order to minimize the workload of test automators, we developed the classes and the algorithms that would allow our RobotJ engine to dynamically locate components using the same simple text strings used by Rational Robot.
These Java classes and algorithms can do the same thing when we go to develop new Java-based SAFS engines for different testing tools. The associated classes, files, and how to provide appropriate tool-specific subclasses are discussed below.
Note: These classes have not been around long, and some refactoring will occur. We are still in the process of refactoring and improving the implementation originally coded for Rational RobotJ. In some cases, functionality may exist in org.safs.rational.*
subclasses that can and should be moved into the appropriate org.safs.*
superclass.
DDGUIUtilities
Superclass of tool-specific classes to store and locate application maps in a tool-specific manner, among other things.
ApplicationMap
Superclass of tool-specific classes to store and locate application components in a tool-specific manner. These app maps represent a local store of tool-specific information and objects cached from previous calls to locate components.
GUIObjectRecognition
Superclass of tool-specific class to manage and manipulate component recognition string information.
GUIClassData
Superclass of tool-specific classes to retrieve tool-specific classname and classtype information for application components. These provide the routines to lookup our object mapping information stored in files like:
GUIObjectVector
Superclass of tool-specific classes to identify application components in a tool-specific manner. In reality, it looks like there is some refactoring necessary here. This is currently an empty class and ALL functionality currently exists in the RGuiObjectVector subclass. This will definitely need to be rectified!
So how do we get different tools to actually respond to the same type of recognition information? How does a string that works for IBM Rational Robot also work for IBM Rational XDE Tester, or Mercury's WinRunner, or JRex? Well, lets walk through an example.
We have a test record that tells us what window and what component we want to act on:
Test Record:
T, LoginWindow, OKButton, Click
App Map A:
[LoginWindow]
LoginWindow="Type=Window;Caption=Login"
OKButton="Type=JavaWindow;Caption=Login;\;Type=Pushbutton;Name=cmdOK"
Our hypothetical testing tool of choice is "GUITest" by GUISRUS, but this walk-thru applies to any gui testing tool.
GUITest can use component proxies. These are tool-specific objects that relay information and actions to the real application component. The tool provides an Object Map that allows user-defined names for these to be used in our tests. So, "LoginWindow" could be the user-defined name of such an object in the tool-specific Object Map. In our SAFS lingo, the Object Map is just a tool-specific App Map.
We CAN use the Object Map:
The quick GUITest version of AppMap lookup would be to take "LoginWindow" from the test record and retrieve the "LoginWindow" component from the GUITest Object Map. Which is fine if you have a predefined Object Map, if the names of those objects match the names in your tests, and you don't care to use any tool but GUITest. An augmentation of this is to still use a SAFS App Map file to map AppMap names to Object Map names like below:
App Map B:
[LoginWindow]
LoginWindow="LoginWindow"
OKButton="oddcmdOK3"
This can be beneficial if the tool's Object Map names change (shame on them!); or if maintenance in the tool is too difficult.
As mentioned, this means you have to create a tool-specific Object Map. And if the component you want to reference hasn't been captured in the Object Map, then you can't play with it. It is better to not have to make a tool-specific Object Map if we can dynamically find the objects at runtime. And that is where "standard" recognition strings come into play.
We CAN use "standard" Recognition Strings:
Instead of making a tool-specific Object Map, and doing this again for every additional tool or platform; let's instead try an App Map with recognition strings and make that work for all tools. For this, we are back to using App Map A shown previously.
To make this work, we implement the Key Subclasses mentioned earlier for our GUITest tool.
A GTDDGUIUtilities or GTApplicationMap function could provide that Object Map lookup mechanism before resorting to the more dynamic lookup mechanism. You can have multiple lookup mechanisms, as shown below in VERY simplified pseudocode with little or no error detection.
Example of org.safs.guisrus.GTDDGUIUtilities:
public guisrus.GUIObj getGUIObj(String mapname, String windowname, String compname){
appmap = (GTApplicationMap) getAppMap(mapname);
// is the target the window?
if (windowname.equalsIgnoreCase(compname)){
// try to see if we cached it in our GTTestRecordHelper
guiobj = ((GTTestRecordHelper)trdata).getWindowGUIObject();
// if not cached in GTTestRecordHelper
if (guiobj == null) {
// perform primary lookup mechanisms
guiobj = appmap.findMappedParent(windowName);
// assuming found, cache it in GTTestRecordHelper for later use
((GTTestRecordHelper)trdata).setWindowGUIObject( guiobj );
}
return guiobj;
}
// otherwise the target is a child of the window
else {
// try to see if we cached it in our GTTestRecordHelper
guiobj = ((GTTestRecordHelper)trdata).getCompGUIObject();
// if not cached in GTTestRecordHelper
if (guiobj == null) {
// perform primary lookup mechanisms
guiobj = appmap.findMappedChild(windowName, compname);
// assuming found, cache it in GTTestRecordHelper for later use
((GTTestRecordHelper)trdata).setCompGUIObject( guiobj );
}
return guiobj;
}
}
The routine first attempts to locate a cached guisrus.guiobj that might have been stored in the current instance of GTTestRecordHelper. While that would be nice, more than likely we are not going to be that lucky. The GTTestRecordHelper may have this cached value reset at the beginning of processing for this new record. So odds are, we will be going down the findMappedParent path provided by our GTApplicationMap instance.
So, we are going to see what it takes to find the LoginWindow using the recognition strings in App Map A. We continue in GTApplicationMap.findMappedParent()
. We start in tool-specific code because we are still searching for items stored in a tool-specific manner. But as you will see, we begin the use of predefined functions in superclasses to help locate the desired component.
Example of org.safs.guisrus.GTApplicationMap:
public guisrus.GUIObj findMappedParent(String windowname){
// check standard local ApplicationMap cache for the object
guiobj = (GUIObj) super.getParentObject(windowname);
if (guiobj != null) return guiobj;
// try any GUITest Object Map storage with the provided windowname
guiobj = GUITest.getObjectMapItem( windowname );
if (guiobj != null) return guiobj;
// retrieve the recognition string (or Object Map lookup value) from SAFSMAPS app map
windowPath = staf.getAppMapItem(mapname, windowname, windowname);
// try any GUITest Object Map storage again, this time with the app map lookup value
guiobj = GUITest.getObjectMapItem( windowPath );
if (guiobj != null) return guiobj;
// OK. We can't find a cached guiobj anywhere. Time for our dynamic SAFS search!
// instance our subclass of GuiObjectVector
guivector = new GTGuiObjectVector(windowname, windowname, windowPath);
// perform the search
guiobj = guivector.getParentGUIObject();
return guiobj;
}
We can now see how a GuiObjectVector is going to start us down the dynamic search path. Our GTGuiObjectVector subclass has a tool-specific getParentGUIObject() function, but the code will quickly be calling our predefined search algorithm.
Example of org.safs.guisrus.GTGuiObjectVector:
public guisrus.GUIObj getParentGUIObject(){
// perform any tool-specific prep here
// then jump right in to the superclass search
return (guisrus.GUIObje) getMatchingParentObject();
}
Example of "pseudo" org.safs.GuiObjectVector:
public Object getMatchingParentObject(){
// your GTGuiObjectVector subclass provides an array of all known toplevel parents (windows)
Object[] parents = getParentObjects();
Object child = null;
// see if one matches our recognition string
while(( !done )&&( child==null )){
// is the indexed parent a match?
if (! isMatchingParent(parents[parentIndex])) {
// no, try the next
parentIndex++;}
else {
// YES! return it
child = parents[parentIndex];
}
return child;
}
Example of "pseudo" org.safs.GuiObjectVector:
public boolean isMatchingParentObject(Object parent){ // your GTGuiObjectRecognition subclass answers the following queries GuiObjectRecognition parentInfo = getParentGuiObjectRecognition(); // Is the parent showing/visible on the screen? if(! parentInfo.isObjectShowing(parent)) return false; // Does the parent class or a superclass match our recognition string Type? if(! parentInfo.isMatchingClass(parent)) return false; // Does the Caption match that of our recognition string? return parentInfo.isMatchingCaption(parent); }
As you can see, the generic superclasses will handle most of the algorithm logic that searches for matching components. The tool-specific subclasses mostly provide the information requested about a given object. The object is whatever the tool, or your subclass implementations, needs to use. This could be Strings, or things like Rational GuiTestObjects. The generic algorithm simply passes them along as needed.
The hunt for matching child objects is essentially the same. Once we match the parent window, we ask for arrays of child objects and process those in the same manner. That is, we loop through the children and query your subclasses to provide the necessary information, or the true or false answers.
Reviewing the Rational RobotJ subclass implementations may (or may not?) make this easier to digest. They have the necessary implementation, but they also have additional functions used by the Rational implementation that would not be necessary for other engines.


|
1st TURN - White player
places 3 stones on empty cells (never in the marked cells) and
protects one of them by placing a pawn on it. Then Black places 3
stones on empty cells, and protects one of them by placing a pawn on
it. |
|
TURNS - On each turn, each player
removes two unprotected enemy stones, and places 3 new stones,
protecting 2 of them with the two pawns on the board (i.e., the two
pawns are shared).
|
If all stones are placed on the
board, without a victory, players continue the game by
repositioning 2 enemy stones and 3 friendly stones on each turn. |
|
The removed stones returns to each
player in order to be used again. |
|
|
GOAL
- A player wins if he surrounds one or more of the seven marked cells on the board with stones of
his color. |
|


Tables¶
There are two types of tables with different syntax, Grid Tables, and Simple Tables.
Grid Tables¶
Grid Tables are described with a visual grid made up of the characters “-“, “=”, “|”, and “+”. The hyphen (“-“) is used for horizontal lines (row separators). The equals sign (“=”) may be used to separate optional header rows from the table body. The vertical bar (“|”) is used for vertical lines (column separators). The plus sign (“+”) is used for intersections of horizontal and vertical lines.
Here is example code for a grid table in a .rst file:
+------------------------+------------+----------+----------+
| Header row, column 1 | Header 2 | Header 3 | Header 4 |
| (header rows optional) | | | |
+========================+============+==========+==========+
| body row 1, column 1 | column 2 | column 3 | column 4 |
+------------------------+------------+----------+----------+
| body row 2 | Cells may span columns. |
+------------------------+------------+---------------------+
| body row 3 | Cells may | - Table cells |
+------------------------+ span rows. | - contain |
| body row 4 | | - body elements. |
+------------------------+------------+---------------------+
This example code generates a grid table that looks like this:
Header row, column 1 (header rows optional) |
Header 2 |
Header 3 |
Header 4 |
|---|---|---|---|
body row 1, column 1 |
column 2 |
column 3 |
column 4 |
body row 2 |
Cells may span columns. |
||
body row 3 |
Cells may span rows. |
|
|
body row 4 |
Simple Tables¶
Simple tables are described with horizontal borders made up of “=” and “-” characters. The equals sign (“=”) is used for top and bottom table borders, and to separate optional header rows from the table body. The hyphen (“-“) is used to indicate column spans in a single row by underlining the joined columns, and may optionally be used to explicitly and/or visually separate rows.
Simple tables are “simpler” to create than grid tables, but are more limited.
Here is example code for a simple table in a .rst file.
===== ===== =======
A B A and B
===== ===== =======
False False False
True False False
False True False
True True True
===== ===== =======
This example code generates a simple table that looks like this:
A |
B |
A and B |
|---|---|---|
False |
False |
False |
True |
False |
False |
False |
True |
False |
True |
True |
True |


Tim - Current Lambda School student studying Web Development. Game Designer, Game Inventor.
Jorge - I like spicy food and tropical weather.
Karina - Former veterinary professional trying to break into tech.
William - Music producer pivoting to software development.
Hung - Love video games, loving code as a beginner, and love working with designs.
Brandon - Currently learning how to code at Lambda School!
Sage - Previously worked in fine dining, but Lambda School’s opportunity combined with my passion for video games lead me to this exciting career transition to software development!


You have plenty of examples contributed by the community, easily browseable here:
http://angular-ui.github.io/ui-leaflet/examples/0000-viewer.html#/basic/tiles-example.
Let's see some progressive examples showing how to use the library on your AngularJS code. Before continue, we must have some notions of how to initialize an AngularJS app. You can find more information about a basic setup of an AngularJS application on the official AngularJS page.


Aapki Seva Mein!
You decide,
We provide
Order From Your Favourites
Find the best near you.

Everytime. On time.
Guaranteed availability
Genuine products
Faster home delivery
Order Now
Ready to get started? Sign up now!
Sign up!


Mins walk to Harbourfront MRT / Heart of Greater Southern Waterfront.
city fringe project with huge potential, first mover's advantage in the area
Learn more
There is only one - THE JOYCE RESIDENCE -
Browse gallery
D01 $900,000 945sqt 3B2T
D02 $780,000 1,040sqf 3B2T
D04 $560,000 989sqf 2B2T


One method of using templates in Laravel is via controller layouts. By specifying the layout
property on the controller, the view specified will be created for you and will be the assumed response that should be returned from actions.
class UserController extends BaseController {
/**
* The layout that should be used for responses.
*/
protected $layout = 'layouts.master';
/**
* Show the user profile.
*/
public function showProfile()
{
$this->layout->content = View::make('user.profile');
}
}

Blade is a simple, yet powerful templating engine provided with Laravel. Unlike controller layouts, Blade is driven by template inheritance and sections. All Blade templates should use the .blade.php
extension.

@section('sidebar')
This is the master sidebar.
@show

@yield('content')

@extends('layouts.master')
@section('sidebar')
@parent

This is appended to the master sidebar.

@stop
@section('content')

This is my body content.

@stop
Note that views which extend
a Blade layout simply override sections from the layout. Content of the layout can be included in a child view using the @parent
directive in a section, allowing you to append to the contents of a layout section such as a sidebar or footer.
Sometimes, such as when you are not sure if a section has been defined, you may wish to pass a default value to the @yield
directive. You may pass the default value as the second argument:
@yield('section', 'Default Content');

Hello, {{{ $name }}}.
The current UNIX timestamp is {{{ time() }}}.
Sometimes you may wish to echo a variable, but you aren't sure if the variable has been set. Basically, you want to do this:
{{{ isset($name) ? $name : 'Default' }}}
However, instead of writing a ternary statement, Blade allows you to use the following convenient short-cut:
{{{ $name or 'Default' }}}
If you need to display a string that is wrapped in curly braces, you may escape the Blade behavior by prefixing your text with an @
symbol:
@{{ This will not be processed by Blade }}
Of course, all user supplied data should be escaped or purified. To escape the output, you may use the triple curly brace syntax:
Hello, {{{ $name }}}.
If you don't want the data to be escaped, you may use double curly-braces:
Hello, {{ $name }}.
Note: Be very careful when echoing content that is supplied by users of your application. Always use the triple curly brace syntax to escape any HTML entities in the content.
@if (count($records) === 1)
I have one record!
@elseif (count($records) > 1)
I have multiple records!
@else
I don't have any records!
@endif
@unless (Auth::check())
You are not signed in.
@endunless
@for ($i = 0; $i < 10; $i++)
The current value is {{ $i }}
@endfor
@foreach ($users as $user)

This is user {{ $user->id }}

@endforeach
@while (true)

I'm looping forever.

@endwhile
@include('view.name')
You may also pass an array of data to the included view:
@include('view.name', array('some'=>'data'))
By default, sections are appended to any previous content that exists in the section. To overwrite a section entirely, you may use the overwrite
statement:
@extends('list.item.container')
@section('list.item.content')

This is an item of type {{ $item->type }}

@overwrite
@lang('language.line')
@choice('language.line', 1);
{{-- This comment will not be in the rendered HTML --}}

Blade even allows you to define your own custom control structures. When a Blade file is compiled, each custom extension is called with the view contents, allowing you to do anything from simple str_replace
manipulations to more complex regular expressions.
The Blade compiler comes with the helper methods createMatcher
and createPlainMatcher
, which generate the expression you need to build your own custom directives.
The createPlainMatcher
method is used for directives with no arguments like @endif
and @stop
, while createMatcher
is used for directives with arguments.
The following example creates a @datetime($var)
directive which simply calls ->format()
on $var
:
Blade::extend(function($view, $compiler)
{
$pattern = $compiler->createMatcher('datetime');
return preg_replace($pattern, '$1<?php echo $2->format(\'m/d/Y H:i\'); ?>', $view);
});


test
header main
header sub
inpage header
blablblabla
sidemenu
Entry 1
Entry 2
Entry 3
Entry 4
Entry 5
this page content is
just for display
it helps to
show the offset
not the last container
sadfdsfa


{% extends "layout.html" %} {% block page_title %} Check your answers {% endblock %} {% block content %} Finding answers quickly Submit your enquiry and we will try to answer {{passport}} {{visa}} {{assault}} Your name Your email address Country Enquiry {{enquirytext_display}} We'll use the information you provide to answer your enquiry and improve our service The Foreign and Commonwealth Office will use the information you provide to answer your enquiry. We may also use it to improve the service we offer to other people by analysing common questions and updating the content available on GOV.UK. {% endblock %}
{{passport}}
{{visa}}
{{assault}}
Your name
Your email address
Country
Enquiry {{enquirytext_display}}
We'll use the information you provide to answer your enquiry and improve our service The Foreign and Commonwealth Office will use the information you provide to answer your enquiry. We may also use it to improve the service we offer to other people by analysing common questions and updating the content available on GOV.UK.
The Foreign and Commonwealth Office will use the information you provide to answer your enquiry. We may also use it to improve the service we offer to other people by analysing common questions and updating the content available on GOV.UK.


| influence.gam {mgcv} | R Documentation |
Extracts the leading diagonal of the influence matrix (hat
matrix) of a fitted gam
object.
## S3 method for class 'gam' influence(model,...)
model |
fitted model objects of class |
... |
un-used in this case |
Simply extracts hat
array from fitted model. (More may follow!)
An array (see above).
Simon N. Wood simon.wood@r-project.org


Fake School Student Manager
Oops! Can't find what your looking for
click here to go home and try again.


| GEOS SDK TechDocs
The following documents contain information about communicating.
- Access Point Library
- Repository of information about the user's ISPs and other providers of communication media.
- Contacts Database
- The Nokia 9000i Communicator has a database which acts as a
repository for contact information, including phone numbers.
- Socket Library
- The GEOS Socket API, TCP/IP and PPP connections.
- Modem Connections
- The Nokia 9000i Communicator supports a sort of "virtual modem"
which you may use to make a modem connection.
- SMS Guide
- The Nokia 9000i Communicator has specialized classes for
working with SMS (the Short Message System).
- Printing
- Creating printed hardcopy output.
- Mailbox Library
- The Mailbox Library underlies inbox/outbox functions. Most programmers
won't do much with Mailbox directly, using just a few functions depending
on what and how they're communicating.
- Sending Faxes
- How to send a fax: prompting the user for a phone number, drawing the contents.
- Distributing Your Application
- The Nokia 9000i Communicator has protocols set up for the distribution
of software packages.
- PCCom Library
- Low-level API used to communicate with another device over a serial
connection.
- Using Streams
- Low-level stream-based communication API.
| GEOS SDK TechDocs


|
PREFACE OF THE DEDICATION OF A CHURCH I (II) It is
truly right and just, our duty and our salvation, always and
everywhere to give you thanks, Lord, holy
Father, almighty and eternal God, through Christ our Lord. For in this visible house that you have let us build and where you never cease to show favour to the family on pilgrimage to you in this place, you wonderfully manifest and accomplish the mystery of your communion with us. Here you build up for yourself the temple that we are and cause your Church, spread throughout the world, to grow ever more and more as the Lordís own Body, till she reaches her fullness in the vision of peace, the heavenly city of And so, with the countless ranks of the blessed, in the temple of your glory we praise you, we bless you and proclaim your greatness as we acclaim: Holy, holy, holy Lord... |
|
PREFACE OF THE DEDICATION OF A CHURCH II It is
truly right and just, our duty and our salvation, always and
everywhere to give you thanks, Lord, holy
Father, almighty and eternal God. For in your benevolence you are pleased to dwell in this house of prayer in order to perfect us as the temple of the Holy Spirit, supported by the perpetual help of your grace and resplendent with the glory of a life acceptable to
you. Year by year you sanctify the Church, the Bride of Christ, foreshadowed in visible buildings, so that, rejoicing as the mother of countless children, she may be given her place in your heavenly glory. And so, with all the Angels and Saints, we praise you as without end we acclaim: Holy, holy, holy Lord... |


Optic Smeefo
What it
BE
what it
DO
Its ya boi
OPTIC SMEEFO
click
here
to see my favorite place to go, and
here
to go to my favorite website!
MY FAVORITE PLACES TO EAT
Taco Bell
Taco Bell
Pizza Hut
Taco Bell


tech (5)
- Raspberry Pi 3 'No Wireless Interface Found' - August 7, 2017
- New website is here! - May 12, 2017
- Botbuilder middleware package for custom analytics and telemetry - November 6, 2017
- Chatbots: Button Dialogs - May 30, 2017
- Intelligent Nerf Turret Part I: The Idea - May 31, 2017
- Botbuilder middleware package for custom analytics and telemetry - November 6, 2017
- Chatbots: Button Dialogs - May 30, 2017
- New website is here! - May 12, 2017
- Raspberry Pi 3 'No Wireless Interface Found' - August 7, 2017
- Intelligent Nerf Turret Part I: The Idea - May 31, 2017


STEEM Web API Documentation
Post #1
MORE TO COME!!!
Follow me on Steemit:
https://steemit.com/@moisesmcardona
Also, vote me for Witness!
Click here to vote me by using SteemConnect 🙂


2018-10-22 12:00:29,700 Test worker WARN Unable to instantiate org.fusesource.jansi.WindowsAnsiOutputStream
2018-10-22 12:00:29,712 Test worker WARN Unable to instantiate org.fusesource.jansi.WindowsAnsiOutputStream
[INFO ] 12:00:32,021 [Test worker] (CordappLoader.kt:137) cordapp.CordappLoader.createDevCordappJar - Generating a test-only cordapp of classes discovered in com.insuranceClaim.contract at build\tmp\generated-test-cordapps\com.insuranceClaim.contract-25ef49c1-66d2-4654-bb05-dcf7ac04074d.jar {}
[INFO ] 12:00:32,270 [Test worker] (CordappLoader.kt:137) cordapp.CordappLoader.createDevCordappJar - Generating a test-only cordapp of classes discovered in com.insuranceClaim.contract at build\tmp\generated-test-cordapps\com.insuranceClaim.contract-7889e615-ec36-4823-ad0e-71aa41358416.jar {}
[INFO ] 12:00:32,317 [Test worker] (CordappLoader.kt:53) cordapp.CordappLoader.<init> - Loading CorDapps from file:/D:/corda/cordapp-insuranceClaim/kotlin-source/build/tmp/generated-test-cordapps/com.insuranceClaim.contract-25ef49c1-66d2-4654-bb05-dcf7ac04074d.jar, file:/D:/corda/cordapp-insuranceClaim/kotlin-source/build/tmp/generated-test-cordapps/com.insuranceClaim.contract-7889e615-ec36-4823-ad0e-71aa41358416.jar {}
[INFO ] 12:00:32,493 [Test worker] (CordappLoader.kt:270) cordapp.CordappLoader.scanCordapp - Scanning CorDapp in file:/D:/corda/cordapp-insuranceClaim/kotlin-source/build/tmp/generated-test-cordapps/com.insuranceClaim.contract-25ef49c1-66d2-4654-bb05-dcf7ac04074d.jar {}
[INFO ] 12:00:32,834 [Test worker] (CordappLoader.kt:270) cordapp.CordappLoader.scanCordapp - Scanning CorDapp in file:/D:/corda/cordapp-insuranceClaim/kotlin-source/build/tmp/generated-test-cordapps/com.insuranceClaim.contract-7889e615-ec36-4823-ad0e-71aa41358416.jar {}
[WARN ] 12:00:33,207 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:49,455 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:49,631 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:49,780 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:50,114 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:50,326 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:50,439 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:50,596 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:51,217 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}
[WARN ] 12:00:51,399 [Test worker] (CordappProviderImpl.kt:40) cordapp.CordappProviderImpl.verifyInstalledCordapps - The network parameters don't specify any whitelisted contract implementations. Please contact your zone operator. See https://docs.corda.net/network-map.html {}


{% extends "bootstrap/base.html" %} {% import "bootstrap/wtf.html" as wtf %} {% import "bootstrap/fixes.html" as fixes %} {% import "bootstrap/utils.html" as util %} {% block content %}
This service resolves CURIEs to their labels and builds Identifiers.org URLs when possible.
It has a single endpoint /resolve/<curie>
that gives back JSON.
Here are a few examples:
| CURIE | Description |
|---|---|
| DOID:14330 | 🟢 exact |
| doid:14330 | 🟢 capitalization variant |
| DO:14330 | 🟢 synonym identified in metaregistry |
| apo:0000155 | 🟡 able to look up name, but prefix is not listed on Identifiers.org |
| wikidata:Q42 | 🟡 able to generate Identifiers.org link, but name unavailable |
| DOID:00000 | 🔴 valid prefix, but invalid identifier |
| NNN:00000 | 🔴 invalid prefix |


TUTORIAL: Manage XSCHEM design / symbol libraries
There are 2 ways to describe symbols in xschem,
- first approach: define a XSCHEM_LIBRARY_PATH that is a list of paths to last level directories containing .sym /.sch files
- second approach: define a XSCHEM_LIBRARY_PATH that is a list of paths one or more levels above the directories containing .sym/.sch files
In the first approach a 'npn.sym' symbol placed in a schematic will be saved as 'npn.sym' in the .sch file, when loading back the parent schematic xschem will go through the elements of XSCHEM_LIBRARY_PATH and look for a directory containing npn.sym.
In the second approach the 'npn.sym' will be saved as 'devices/npn.sym' (assuming devices/ is the directory containing this symbol) . This is because the XSCHEM_LIBRARY_PATH is pointing to something like /some/path/xschem_library/ and xschem_library/ contains devices/ (names are just given as examples, any dir name is allowed for xschem_library/ and devices/)
The first approach is preferred by pcb hobbysts, people working on
small designs.
the second approach is preferred for big designs where a one or more directory level
indirection is desired for symbols, so any symbol in xschem is given
as 'libname/symname.sym' (one level directory specification in symbol references)
or 'libgroup/libname/symname.sym' (2 level directory specification in symbol references)
instead of just 'symname.sym'
In any case the real path of the symbol reference is obtained by prepending the XSCHEM_LIBRARY_PATH paths to the symbol reference until the resulting file is found in the machine filesystem.
For VLSI / big designs I strongly suggest using the second approach, just as an example i have the following dirs:
~/share/xschem/xschem_library/ containing: devices/ TECHLIB/ ~/xschem_library/ containing: stdcell_stef/ ~/share/doc/xschem/ containing: library_t9/ dram/
then in my xschemrc i have the following:
set XSCHEM_LIBRARY_PATH \
$env(HOME)/share/xschem/xschem_library:$env(HOME)/share/doc/xschem/:$env(HOME)/xschem_library


Here are Some More Great Tech Deals You Can Get in Amazon's Black Friday Sale From Today (25/11)
by Tom PritchardThe Black Friday sales never end, and with them come hundreds, and thousands of deals from companies who want you to buy their products for yourself. Seriously, there are so many things to choose from, it's so difficult to sift through them all.
Not that we didn't give it a try, and unlike the weekend there are plenty of fantastic bargains to be had from what we've seen. Here's a taste of what's available, including some deals we'd thinking of exploiting for ourselves.
 There's too much for us to get through, so if you know you want something, you better head over to Amazon and browse through the sales pages for yourself.


Chapter 12 Evernote
Evernote offers a suite of software and services that are designed to allow note taking and archiving across a wide range of devices and operating systems. The company launched its closed beta in 2008 and gained 1 million users in 446 days. (The closed beta alone drew 250,000 in four months capitalizing on the sense of exclusivity such invitations carry.)
From there the growth curve grew steadily shorter: 222 days to reach 2 million 133 days to reach 3 million 108 days to reach 4 million 83 days to reach 5 million 52 days to reach 6 million
It is now estimated that just under 20,000 new users sign up for Evernote daily. The developers at Evernote have, since the beginning, focused on the user experience, but in all honesty, the company benefited enormously from timing. They came along just as smartphones were taking off and quality, useful apps were in exceptionally high demand. They had their first app out of beta and ready for the launch of the iPhone App Store in June 2008. As more app stores followed, they proved to be high-quality distribution channels for Evernote. Regardless of the device or operating system, Evernote was there when the store opened for business, prominently featured and ready for download. This is a policy Evernote continues to follow. They already have an app for the much hyped Google Glass wearable computer. Timing was not the only component of Evernote’s success, however. Their designers have created an impressive cross-platform experience with no file size limitations and no complex rules. Regardless of the device or operating system, all platforms sync up seamlessly.
Evernote is totally customizable, allowing users to organize and archive their data into what the company calls their “second brain.” The value proposition is so clear and so simple that early in the company’s existence, a dedicated user in Switzerland floated Evernote a $500,000 loan based purely on his own passionate use of the product. These are the kinds of users that can become Evernote Ambassadors, representing the company at meet ups and events where they demonstrate how they use the product and hand out premium trial coupons. Clearly the word of mouth for the service is excellent. Evernote puts so much emphasis on product superiority, they spend nothing on user acquisition through traditional channels like SEO (search engine optimization) or SEM (search engine marketing). Finally, Evernote works on a “freemium” model. Users receive access to free, basic service at sign up with an option to upgrade, with more features and storage space. This gets people in the door and in a position to become invested. The longer someone uses Evernote, the more likely they are to pay for the service. The company also employs a referral program. New users who sign up on referral get a month of the premium service, while the referring member earns points toward various perks like more space, gift cards, or even lunch with the teach at headquarters. Most recently Evernote has begun to develop product extensions like Evernote Hello for contact management, Evernote clearly for distraction free reading and writing, and even an Evernote Moleskine notebook (each page can be photographed and uploaded to the user’s account.) By keeping the emphasis on the user experience, Evernote built an exceptionally loyal user community. Certainly the company benefited from superior timing, but they have also engineered and consistently improved a cross platform application with true long-term functionality.


Summoner Celestiel:
Watch out Phantasm! ...Are you hurt?
  You forfeit the match for that... Give me your crude little card...
Ask for another battle.


This page is being shown because you have not yet logged in. This page, or rather this session does not have any information about the logged in user yet.
{{msg.message}}


class CMAEvolutionStrategy(interfaces.OOOptimizer):
CMA-ES stochastic optimizer class with ask-and-tell interface.
Calling Sequences
es = CMAEvolutionStrategy(x0, sigma0)
es = CMAEvolutionStrategy(x0, sigma0, opts)
es = CMAEvolutionStrategy(x0, sigma0).optimize(objective_fct)
res = CMAEvolutionStrategy(x0, sigma0, opts).optimize(objective_fct).result
Arguments
x0
initial solution, starting point.
x0
is given as "phenotype" which means, if:opts = {'transformation': [transform, inverse]}
is given and inverse is None, the initial mean is not consistent with
x0
in that transform(mean) does not equal tox0
unless transform(mean) equals mean.sigma0
- initial standard deviation. The problem variables should
have been scaled, such that a single standard deviation
on all variables is useful and the optimum is expected to
lie within about
x0
+- 3*sigma0. Often one wants to check for solutions close to the initial point. This allows, for example, for an easier check of consistency of the objective function and its interfacing with the optimizer. In this case, a much smallersigma0
is advisable. opts
- options, a dictionary with optional settings,
see class
CMAOptions
.
Main interface / usage
The interface is inherited from the generic OOOptimizer
class (see also there). An object instance is generated from:
es = cma.CMAEvolutionStrategy(8 * [0.5], 0.2)
The least verbose interface is via the optimize method:
es.optimize(objective_func) res = es.result
More verbosely, the optimization is done using the
methods stop
, ask
, and tell
:
while not es.stop(): solutions = es.ask() es.tell(solutions, [cma.ff.rosen(s) for s in solutions]) es.disp() es.result_pretty()
where ask
delivers new candidate solutions and tell
updates
the optim
instance by passing the respective function values
(the objective function cma.ff.rosen
can be replaced by any
properly defined objective function, see cma.ff
for more
examples).
To change an option, for example a termination condition to continue the optimization, call:
es.opts.set({'tolfacupx': 1e4})
The class CMAEvolutionStrategy
also provides:
(solutions, func_values) = es.ask_and_eval(objective_func)
and an entire optimization can also be written like:
while not es.stop(): es.tell(*es.ask_and_eval(objective_func))
Besides for termination criteria, in CMA-ES only the ranks of the
func_values
are relevant.
Attributes and Properties
inputargs
: passed input argumentsinopts
: passed optionsopts
: actually used options, some of them can be changed any time via opts.set, see classCMAOptions
popsize
: population size lambda, number of candidate solutions returned byask
()logger
: aCMADataLogger
instance utilized byoptimize
Examples
Super-short example, with output shown:
>>> import cma >>> # construct an object instance in 4-D, sigma0=1: >>> es = cma.CMAEvolutionStrategy(4 * [1], 1, {'seed':234}) ... # doctest: +ELLIPSIS (4_w,8)-aCMA-ES (mu_w=2.6,w_1=52%) in dimension 4 (seed=234...)
and optimize the ellipsoid function
>>> es.optimize(cma.ff.elli, verb_disp=1) # doctest: +ELLIPSIS Iterat #Fevals function value axis ratio sigma min&max std t[m:s] 1 8 2.09... >>> assert len(es.result) == 8 >>> assert es.result[1] < 1e-9
The optimization loop can also be written explicitly:
>>> es = cma.CMAEvolutionStrategy(4 * [1], 1) # doctest: +ELLIPSIS (4_w,8)-aCMA-ES (mu_w=2.6,w_1=52%) in dimension 4 (seed=... >>> while not es.stop(): ... X = es.ask() ... es.tell(X, [cma.ff.elli(x) for x in X]) ... es.disp() # doctest: +ELLIPSIS Iterat #Fevals function value axis ratio sigma min&max std t[m:s] 1 8 ...
achieving the same result as above.
An example with lower bounds (at zero) and handling infeasible solutions:
>>> import numpy as np >>> es = cma.CMAEvolutionStrategy(10 * [0.2], 0.5, ... {'bounds': [0, np.inf]}) #doctest: +ELLIPSIS (5_w,... >>> while not es.stop(): ... fit, X = [], [] ... while len(X) < es.popsize: ... curr_fit = None ... while curr_fit in (None, np.NaN): ... x = es.ask(1)[0] ... curr_fit = cma.ff.somenan(x, cma.ff.elli) # might return np.NaN ... X.append(x) ... fit.append(curr_fit) ... es.tell(X, fit) ... es.logger.add() ... es.disp() #doctest: +ELLIPSIS Itera... >>> >>> assert es.result[1] < 1e-9 >>> assert es.result[2] < 9000 # by internal termination >>> # es.logger.plot() # will plot data >>> # cma.s.figshow() # display plot window
An example with user-defined transformation, in this case to realize a lower bound of 2.
>>> import warnings >>> with warnings.catch_warnings(record=True) as warns: ... es = cma.CMAEvolutionStrategy(5 * [3], 0.1, ... {"transformation": [lambda x: x**2+1.2, None], ... "verbose": -2,}) >>> warns[0].message # doctest:+ELLIPSIS UserWarning('in class GenoPheno: user defined transformations have not been tested thoroughly ()'... >>> warns[1].message # doctest:+ELLIPSIS UserWarning('computed initial point... >>> es.optimize(cma.ff.rosen, verb_disp=0) #doctest: +ELLIPSIS <cma... >>> assert cma.ff.rosen(es.result[0]) < 1e-7 + 5.54781521192 >>> assert es.result[2] < 3300
The inverse transformation is (only) necessary if the BoundPenalty
boundary handler is used at the same time.
The CMAEvolutionStrategy
class also provides a default logger
(cave: files are overwritten when the logger is used with the same
filename prefix):
>>> es = cma.CMAEvolutionStrategy(4 * [0.2], 0.5, {'verb_disp': 0}) >>> es.logger.disp_header() # annotate the print of disp Iterat Nfevals function value axis ratio maxstd minstd >>> while not es.stop(): ... X = es.ask() ... es.tell(X, [cma.ff.sphere(x) for x in X]) ... es.logger.add() # log current iteration ... es.logger.disp([-1]) # display info for last iteration #doctest: +ELLIPSIS 1 ... >>> es.logger.disp_header() Iterat Nfevals function value axis ratio maxstd minstd >>> # es.logger.plot() # will make a plot
Example implementing restarts with increasing popsize (IPOP):
>>> bestever = cma.optimization_tools.BestSolution() >>> for lam in 10 * 2**np.arange(8): # 10, 20, 40, 80, ..., 10 * 2**7 ... es = cma.CMAEvolutionStrategy(6 - 8 * np.random.rand(4), # 4-D ... 5, # initial std sigma0 ... {'popsize': lam, # options ... 'verb_append': bestever.evalsall}) ... # logger = cma.CMADataLogger().register(es, append=bestever.evalsall) ... while not es.stop(): ... X = es.ask() # get list of new solutions ... fit = [cma.ff.rastrigin(x) for x in X] # evaluate each solution ... es.tell(X, fit) # besides for termination only the ranking in fit is used ... ... # display some output ... # logger.add() # add a "data point" to the log, writing in files ... es.disp() # uses option verb_disp with default 100 ... ... print('termination:', es.stop()) ... cma.s.pprint(es.best.__dict__) ... ... bestever.update(es.best) ... ... # show a plot ... # logger.plot(); ... if bestever.f < 1e-8: # global optimum was hit ... break #doctest: +ELLIPSIS (5_w,... >>> assert es.result[1] < 1e-8
On the Rastrigin function, usually after five restarts the global optimum is located.
Using the multiprocessing
module, we can evaluate the function in
parallel with a simple modification of the example (however
multiprocessing seems not always reliable):
>>> from cma.fitness_functions import elli # cannot be an instance method >>> from cma.optimization_tools import EvalParallel2 >>> es = cma.CMAEvolutionStrategy(22 * [0.0], 1.0, {'maxiter':10}) # doctest:+ELLIPSIS (6_w,13)-aCMA-ES (mu_w=... >>> with EvalParallel2(elli, es.popsize + 1) as eval_all: ... while not es.stop(): ... X = es.ask() ... es.tell(X, eval_all(X)) ... es.disp() ... # es.logger.add() # doctest:+ELLIPSIS Iterat...
The final example shows how to resume:
>>> import pickle >>> >>> es0 = cma.CMAEvolutionStrategy(12 * [0.1], # a new instance, 12-D ... 0.12) # initial std sigma0 ... #doctest: +ELLIPSIS (5_w,... >>> es0.optimize(cma.ff.rosen, iterations=100) #doctest: +ELLIPSIS I... >>> s = es0.pickle_dumps() # return pickle.dumps(es) with safeguards >>> # save string s to file like open(filename, 'wb').write(s) >>> del es0 # let's start fresh >>> # s = open(filename, 'rb').read() # load string s from file >>> es = pickle.loads(s) # read back es instance from string >>> # resuming >>> es.optimize(cma.ff.rosen, verb_disp=200) #doctest: +ELLIPSIS 200 ... >>> assert es.result[2] < 15000 >>> assert cma.s.Mh.vequals_approximately(es.result[0], 12 * [1], 1e-5) >>> assert len(es.result) == 8
Details
The following two enhancements are implemented, the latter is only turned on by default for very small population sizes.
Active CMA is implemented with option CMA_active and conducts an update of the covariance matrix with negative weights. The negative update is implemented, such that positive definiteness is guarantied. A typical speed up factor (number of f-evaluations) is between 1.1 and two.
References: Jastrebski and Arnold, Improving evolution strategies through active covariance matrix adaptation, CEC 2006. Hansen, The CMA evolution strategy: a tutorial, arXiv 2016.
Selective mirroring is implemented with option CMA_mirrors
in the method get_mirror
and get_selective_mirrors
.
The method ask_and_eval
(used by fmin
) will then sample
selectively mirrored vectors within the iteration
(CMA_mirrormethod==1). Otherwise, or if CMA_mirromethod==2,
selective mirrors are injected for the next iteration.
In selective mirroring, only the worst solutions are mirrored. With
the default small number of mirrors, pairwise selection (where at
most one of the two mirrors contribute to the update of the
distribution mean) is implicitly guarantied under selective
mirroring and therefore not explicitly implemented.
Update: pairwise selection for injected mirrors is also applied in the covariance matrix update: for all injected solutions, as for those from TPA, this is now implemented in that the recombination weights are constrained to be nonnegative for injected solutions in the covariance matrix (otherwise recombination weights are anyway nonnegative). This is a precaution to prevent failure when injected solutions are systematically bad (see e.g. https://github.com/CMA-ES/pycma/issues/124), but may not be "optimal" for mirrors.
References: Brockhoff et al, PPSN 2010, Auger et al, GECCO 2011.
| See Also | |
fmin (), OOOptimizer , CMAOptions , plot (), ask (),
tell (), ask_and_eval () |
| Method | __init__ |
see class CMAEvolutionStrategy |
| Method | alleviate |
pass conditioning of C to linear transformation in self.gp . |
| Method | alleviate |
pass scaling from C to sigma_vec . |
| Method | ask |
get/sample new candidate solutions. |
| Method | ask |
sample number solutions and evaluate them on func . |
| Method | ask |
get new candidate solutions in genotyp. |
| Method | disp |
print current state variables in a single-line. |
| Method | disp |
print annotation line for disp () |
| Method | feed |
Resume a run using the solution history. |
| Method | get |
return pheno(self.mean - (geno(x) - self.mean)). |
| Method | get |
get mirror genotypic directions from worst solutions. |
| Method | inject |
inject list of one or several genotypic solution(s). |
| Method | mahalanobis |
return Mahalanobis norm based on the current sample distribution. |
| Method | manage |
increase sigma by sigma_fac in case of a plateau. |
| Method | pickle |
return pickle.dumps(self), |
| Method | plot |
plot current state variables using matplotlib . |
| Method | random |
change x like for injection, all on genotypic level |
| Method | repair |
make sure that solutions fit to the sample distribution. |
| Method | result |
pretty print result. |
| Method | stop |
return the termination status as dictionary. |
| Method | tell |
pass objective function values to prepare for next iteration. This core procedure of the CMA-ES algorithm updates all state variables, in particular the two evolution paths, the distribution mean, the covariance matrix and a step-size. |
| Instance Variable | adapt |
Undocumented |
| Instance Variable | archive |
Undocumented |
| Instance Variable | ary |
Undocumented |
| Instance Variable | B |
Undocumented |
| Instance Variable | best |
Undocumented |
| Instance Variable | boundary |
Undocumented |
| Instance Variable | C |
Undocumented |
| Instance Variable | callbackstop |
return values of callbacks, used like if any(callbackstop) |
| Instance Variable | const |
Undocumented |
| Instance Variable | count |
Undocumented |
| Instance Variable | countevals |
Undocumented |
| Instance Variable | countiter |
Undocumented |
| Instance Variable | D |
Undocumented |
| Instance Variable | d |
Undocumented |
| Instance Variable | evaluations |
Undocumented |
| Instance Variable | fit |
Undocumented |
| Instance Variable | gp |
Undocumented |
| Instance Variable | hsiglist |
Undocumented |
| Instance Variable | inopts |
Undocumented |
| Instance Variable | inputargs |
Undocumented |
| Instance Variable | itereigenupdated |
Undocumented |
| Instance Variable | last |
Undocumented |
| Instance Variable | logger |
Undocumented |
| Instance Variable | mean |
Undocumented |
| Instance Variable | mean0 |
Undocumented |
| Instance Variable | mean |
Undocumented |
| Instance Variable | mean |
Undocumented |
| Instance Variable | mean |
Undocumented |
| Instance Variable | mean |
Undocumented |
| Instance Variable | mirrors |
Undocumented |
| Instance Variable | more |
Undocumented |
| Instance Variable | N |
Undocumented |
| Instance Variable |
|
Undocumented |
| Instance Variable | noise |
Undocumented |
| Instance Variable | number |
Undocumented |
| Instance Variable | number |
Undocumented |
| Instance Variable | number |
Undocumented |
| Instance Variable | opts |
Undocumented |
| Instance Variable | pc |
Undocumented |
| Instance Variable | pc2 |
Undocumented |
| Instance Variable | pc |
Undocumented |
| Instance Variable | pop |
Undocumented |
| Instance Variable | pop |
Undocumented |
| Instance Variable | pop |
Undocumented |
| Instance Variable | pop |
Undocumented |
| Instance Variable | sent |
Undocumented |
| Instance Variable | sigma |
Undocumented |
| Instance Variable | sigma0 |
Undocumented |
| Instance Variable | sigma |
Undocumented |
| Instance Variable | sigma |
Undocumented |
| Instance Variable | sm |
Undocumented |
| Instance Variable | sp |
Undocumented |
| Instance Variable | sp0 |
Undocumented |
| Instance Variable | time |
Undocumented |
| Instance Variable | timer |
Undocumented |
| Instance Variable | times |
Undocumented |
| Instance Variable | x0 |
Undocumented |
| Property | condition |
condition number of the statistical-model sampler. |
| Property | isotropic |
normalized last mean shift, under random selection N(0,I) |
| Property | popsize |
number of samples by default returned by ask () |
| Property | result |
return a CMAEvolutionStrategyResult namedtuple . |
| Property | stds |
return array of coordinate-wise standard deviations (phenotypic). |
| Method | _copy |
tentative copy of self, versatile (interface and functionalities may change). |
| Method | _prepare |
provide genotypic directions for TPA and selective mirroring, with no specific length normalization, to be used in the coming iteration. |
| Method | _random |
self.mean + self._random_rescaling_factor_to_mahalanobis_size(y) * y is guarantied to appear like from the sample distribution. |
| Method | _record |
do nothing by default, otherwise assign to _record_rankings_ after instantiation |
| Method | _record |
compute ranks of vals in function_values and |
| Method | _set |
Assign self.x0 from argument x0 . |
| Method | _stds |
set self.sigma_vec.scaling to respect opts['max/minstd'] |
| Method | _tfg |
Undocumented |
| Method | _tfp |
Undocumented |
| Method | _try |
call sm.update_now like sm.sample would do. |
| Method | _update |
helper function for a smooth transition to sampling classes. |
| Instance Variable | _flgtelldone |
Undocumented |
| Instance Variable | _indices |
Undocumented |
| Instance Variable | _injected |
Undocumented |
| Instance Variable | _mirrormethod1 |
Undocumented |
| Instance Variable | _recorded |
Undocumented |
| Instance Variable | _stopdict |
attribute for stopping criteria in function stop |
| Property | _stds |
return array of coordinate-wise standard deviations (genotypic). |
Inherited from OOOptimizer
:
| Method | initialize |
(re-)set to the initial state |
| Method | optimize |
find minimizer of objective_fct. |
| Instance Variable | more |
Undocumented |
| Instance Variable | optional |
Undocumented |
| Instance Variable | xcurrent |
Undocumented |
| Instance Variable | xstart |
Undocumented |
| Method | _force |
try force the logger to log NOW |
| Method | _prepare |
return a list of callbacks including self.logger.add. |
pass conditioning of C
to linear transformation in self.gp
.
Argument condition
defines the limit condition number above
which the action is taken.
>>> import cma >>> for dd in [0, 1]: ... es = cma.CMA(2 * [1], 0.1, {'CMA_diagonal_decoding' : dd, 'verbose':-9}) ... es = es.optimize(cma.ff.elli, iterations=4) ... es.alleviate_conditioning(1.1) # check that alleviation_conditioning "works" ... assert all(es.sigma_vec.scaling == [1, 1]), es.sigma_vec.scaling ... assert es.sm.condition_number < 1.01, es.sm.C
Details: the action applies only if self.gp.isidentity
. Then,
the covariance matrix C
is set (back) to identity and a
respective linear transformation is "added" to self.gp
.
cma.interfaces.OOOptimizer.ask
get/sample new candidate solutions.
Solutions are sampled from a multi-variate normal distribution and transformed to f-representation (phenotype) to be evaluated.
Arguments
number
- number of returned solutions, by default the population size popsize (AKA lambda).
xmean
- distribution mean, phenotyp?
sigma_fac
- multiplier for internal sample width (standard deviation)
gradf
- gradient, len(gradf(x)) == len(x), if gradf is not None the third solution in the returned list is "sampled" in supposedly Newton direction np.dot(C, gradf(xmean, *args)).
args
- additional arguments passed to gradf
Return
A list of N-dimensional candidate solutions to be evaluated
Example
>>> import cma >>> es = cma.CMAEvolutionStrategy([0,0,0,0], 0.3) #doctest: +ELLIPSIS (4_w,... >>> while not es.stop() and es.best.f > 1e-6: ... X = es.ask() # get list of new solutions ... fit = [cma.ff.rosen(x) for x in X] # call fct with each solution ... es.tell(X, fit) # feed values
| See Also | |
ask_and_eval , ask_geno , tell |
sample number
solutions and evaluate them on func
.
Each solution s is resampled until self.is_feasible(s, func(s)) is True.
Arguments
func
:- objective function, func(x) accepts a
numpy.ndarray
and returns a scalar if not parallel_mode. Else returns alist
of scalars from alist
ofnumpy.ndarray
. args
:- additional parameters for
func
gradf
:- gradient of objective function, g = gradf(x, *args) must satisfy len(g) == len(x)
number
:- number of solutions to be sampled, by default population size popsize (AKA lambda)
xmean
:- mean for sampling the solutions, by default self.mean.
sigma_fac
:- multiplier for sampling width, standard deviation, for example
to get a small perturbation of solution
xmean
evaluations
:- number of evaluations for each sampled solution
aggregation
:- function that aggregates
evaluations
values to as single value. kappa
:- multiplier used for the evaluation of the solutions, in that func(m + kappa*(x - m)) is the f-value for x.
Details
While not self.is_feasible(x, func(x)) new solutions are
sampled. By default
self.is_feasible == cma.feasible == lambda x, f: f not in (None, np.NaN).
The argument to func
can be freely modified within func
.
Depending on the CMA_mirrors option, some solutions are not sampled independently but as mirrors of other bad solutions. This is a simple derandomization that can save 10-30% of the evaluations in particular with small populations, for example on the cigar function.
Example
>>> import cma >>> x0, sigma0 = 8 * [10], 1 # 8-D >>> es = cma.CMAEvolutionStrategy(x0, sigma0) #doctest: +ELLIPSIS (5_w,... >>> while not es.stop(): ... X, fit = es.ask_and_eval(cma.ff.elli) # handles NaN with resampling ... es.tell(X, fit) # pass on fitness values ... es.disp(20) # print every 20-th iteration #doctest: +ELLIPSIS Iterat #Fevals... >>> print('terminated on ' + str(es.stop())) #doctest: +ELLIPSIS terminated on ...
A single iteration step can be expressed in one line, such that an entire optimization after initialization becomes:
while not es.stop(): es.tell(*es.ask_and_eval(cma.ff.elli))
get new candidate solutions in genotyp.
Solutions are sampled from a multi-variate normal distribution.
- Arguments are
number
- number of returned solutions, by default the
population size
popsize
(AKA lambda). xmean
- distribution mean
sigma_fac
- multiplier for internal sample width (standard deviation)
ask_geno
returns a list of N-dimensional candidate solutions
in genotyp representation and is called by ask
.
Details: updates the sample distribution if needed and might change the geno-pheno transformation during this update.
| See Also | |
ask , ask_and_eval |
cma.interfaces.OOOptimizer.disp
print current state variables in a single-line.
Prints only if iteration_counter % modulo == 0.
Overwrites the line after iteration overwrite
.
| See Also | |
disp_annotation . |
Resume a run using the solution history.
CAVEAT: this hasn't been thoroughly tested or in intensive use.
Given all "previous" candidate solutions and their respective
function values, the state of a CMAEvolutionStrategy
object
can be reconstructed from this history. This is the purpose of
function feed_for_resume
.
Arguments
X
:- (all) solution points in chronological order, phenotypic representation. The number of points must be a multiple of popsize.
function_values
:- respective objective function values
Details
feed_for_resume
can be called repeatedly with only parts of
the history. The part must have the length of a multiple
of the population size.
feed_for_resume
feeds the history in popsize-chunks into tell
.
The state of the random number generator might not be
reconstructed, but this would be only relevant for the future.
Example
import cma # prepare (x0, sigma0) = ... # initial values from previous trial X = ... # list of generated solutions from a previous trial f = ... # respective list of f-values # resume es = cma.CMAEvolutionStrategy(x0, sigma0) es.feed_for_resume(X, f) # continue with func as objective function while not es.stop(): X = es.ask() es.tell(X, [func(x) for x in X])
Credits to Dirk Bueche and Fabrice Marchal for the feeding idea.
| See Also | |
class CMAEvolutionStrategy for a simple dump/load
to resume. |
return pheno(self.mean - (geno(x) - self.mean)).
>>> import numpy as np, cma >>> es = cma.CMAEvolutionStrategy(np.random.randn(3), 1) #doctest: +ELLIPSIS (3_w,... >>> x = np.random.randn(3) >>> assert cma.utilities.math.Mh.vequals_approximately(es.mean - (x - es.mean), es.get_mirror(x, preserve_length=True)) >>> x = es.ask(1)[0] >>> vals = (es.get_mirror(x) - es.mean) / (x - es.mean) >>> assert cma.utilities.math.Mh.equals_approximately(sum(vals), len(vals) * vals[0])
TODO: this implementation is yet experimental.
TODO: this implementation includes geno-pheno transformation, however in general GP-transformation should be separated from specific code.
Selectively mirrored sampling improves to a moderate extend but overadditively with active CMA for quite understandable reasons.
Optimal number of mirrors are suprisingly small: 1,2,3 for maxlam=7,13,20 where 3,6,10 are the respective maximal possible mirrors that must be clearly suboptimal.
get mirror genotypic directions from worst solutions.
Details:
To be called after the mean has been updated.
Takes the last number=sp.lam_mirr entries in the self.pop[self.fit.idx] as solutions to be mirrored.
Do not take a mirror if it is suspected to stem from a previous mirror in order to not go endlessly back and forth.
inject list of one or several genotypic solution(s).
This is the preferable way to pass outside proposal solutions
into CMAEvolutionStrategy
. Passing (bad) solutions directly
via tell
is likely to fail when CMA_active is True as by
default.
Unless force is True, the solutions
are used as direction
relative to the distribution mean to compute a new candidate
solution returned in method ask_geno
which in turn is used in
method ask
. Even when force is True, the update in tell
takes later care of possibly trimming the update vector.
inject
is to be called before ask
or after tell
and can be
called repeatedly.
>>> import cma >>> es = cma.CMAEvolutionStrategy(4 * [1], 2) #doctest: +ELLIPSIS (4_w,... >>> while not es.stop(): ... es.inject([4 * [0.0]]) ... X = es.ask() ... if es.countiter == 0: ... assert X[0][0] == X[0][1] # injected sol. is on the diagonal ... es.tell(X, [cma.ff.sphere(x) for x in X])
Details: injected solutions are not used in the "active" update which would decrease variance in the covariance matrix in this direction.
return Mahalanobis norm based on the current sample distribution.
The norm is based on Covariance matrix C times sigma**2, and includes sigma_vec. The expected Mahalanobis distance to the sample mean is about sqrt(dimension).
Argument
A genotype difference dx
.
Example
>>> import cma, numpy >>> es = cma.CMAEvolutionStrategy(numpy.ones(10), 1) #doctest: +ELLIPSIS (5_w,... >>> xx = numpy.random.randn(2, 10) >>> d = es.mahalanobis_norm(es.gp.geno(xx[0]-xx[1]))
d
is the distance "in" the true sample distribution,
sampled points have a typical distance of sqrt(2*es.N),
where es.N is the dimension, and an expected distance of
close to sqrt(N) to the sample mean. In the example,
d
is the Euclidean distance, because C = I and sigma = 1.
increase sigma
by sigma_fac
in case of a plateau.
A plateau is assumed to be present if the best sample and popsize * sample_fraction-th best sample have the same fitness.
Example:
>>> import cma >>> def f(X): ... return (len(X) - 1) * [1] + [2] >>> es = cma.CMAEvolutionStrategy(4 * [0], 5, {'verbose':-9, 'tolflatfitness':1e4}) >>> while not es.stop(): ... X = es.ask() ... es.tell(X, f(X)) ... es.manage_plateaus() >>> if es.sigma < 1.5**es.countiter: print((es.sigma, 1.5**es.countiter, es.stop()))
return pickle.dumps(self),
if necessary remove unpickleable (and also unnecessary) local function reference beforehand.
The resulting bytes
string-object can be saved to a file like:
import cma es = cma.CMAEvolutionStrategy(3 * [1], 1) es.optimize(cma.ff.elli, iterations=22) filename = 'es-pickle-test' open(filename, 'wb').write(es.pickle_dumps())
and recovered like:
import pickle es = pickle.load(open(filename, 'rb'))
or:
es = pickle.loads(open(filename, 'rb').read()) es.optimize(cma.ff.elli, iterations=22) # continue optimizing
make sure that solutions fit to the sample distribution.
This interface is versatile and likely to change.
The Mahalanobis distance x - self.mean is clipping at N**0.5 + 2 * N / (N + 2), but the specific repair mechanism may change in future.
cma.interfaces.OOOptimizer.stop
return the termination status as dictionary.
With check == False, the termination conditions are not checked
and the status might not reflect the current situation.
check_on_same_iteration == False (new) does not re-check during
the same iteration. When termination options are manually changed,
it must be set to True
to advance afterwards.
stop().clear() removes the currently active termination
conditions.
As a convenience feature, keywords in ignore_list
are removed from
the conditions.
If get_value
is set to a condition name (not the empty string),
stop
does not update the termination dictionary but returns the
measured value that would be compared to the threshold. This only
works for some conditions, like 'tolx'. If the condition name is
not known or cannot be computed, None
is returned and no warning
is issued.
Testing get_value
functionality:
>>> import cma >>> es = cma.CMAEvolutionStrategy(2 * [1], 1e4, {'verbose': -9}) >>> with warnings.catch_warnings(record=True) as w: ... es.stop(get_value='tolx') # triggers zero iteration warning ... assert len(w) == 1, [str(wi) for wi in w] >>> es = es.optimize(cma.ff.sphere, iterations=4) >>> assert 1e3 < es.stop(get_value='tolx') < 1e4, es.stop(get_value='tolx') >>> assert es.stop() == {} >>> assert es.stop(get_value='catch 22') is None
cma.interfaces.OOOptimizer.tell
pass objective function values to prepare for next iteration. This core procedure of the CMA-ES algorithm updates all state variables, in particular the two evolution paths, the distribution mean, the covariance matrix and a step-size.
Arguments
solutions
- list or array of candidate solution points (of
type
numpy.ndarray
), most presumably before delivered by methodask()
orask_and_eval()
. function_values
- list or array of objective function values
corresponding to the respective points. Beside for termination
decisions, only the ranking of values in
function_values
is used. check_points
- If check_points is None, only solutions that are not generated
by
ask()
are possibly clipped (recommended). False does not clip any solution (not recommended). If True, clips solutions that realize long steps (i.e. also those that are unlikely to be generated withask()
).check_points
can be a list of indices to be checked in solutions. copy
- solutions can be modified in this routine, if copy is False
Details
tell()
updates the parameters of the multivariate
normal search distribution, namely covariance matrix and
step-size and updates also the attributes countiter and
countevals. To check the points for consistency is quadratic
in the dimension (like sampling points).
Bugs
The effect of changing the solutions delivered by ask()
depends on whether boundary handling is applied. With boundary
handling, modifications are disregarded. This is necessary to
apply the default boundary handling that uses unrepaired
solutions but might change in future.
Example
>>> import cma >>> func = cma.ff.sphere # choose objective function >>> es = cma.CMAEvolutionStrategy(np.random.rand(2) / 3, 1.5) ... # doctest:+ELLIPSIS (3_... >>> while not es.stop(): ... X = es.ask() ... es.tell(X, [func(x) for x in X]) >>> es.result # result is a `namedtuple` # doctest:+ELLIPSIS CMAEvolutionStrategyResult(xbest=array([...
| See Also | |
class CMAEvolutionStrategy , ask , ask_and_eval , fmin |
normalized last mean shift, under random selection N(0,I)
distributed.
Caveat: while it is finite and close to sqrt(n) under random selection, the length of the normalized mean shift under systematic selection (e.g. on a linear function) tends to infinity for mueff -> infty. Hence it must be used with great care for large mueff.
cma.interfaces.OOOptimizer.result
return a CMAEvolutionStrategyResult
namedtuple
.
| See Also | |
cma.evolution_strategy.CMAEvolutionStrategyResult
or try help(...result) on the result property
of an CMAEvolutionStrategy instance or on the
CMAEvolutionStrategyResult instance itself. |
return array of coordinate-wise standard deviations (phenotypic).
Takes into account geno-phenotype transformation, step-size,
diagonal decoding, and the covariance matrix. Only the latter three
apply to self.mean
.
tentative copy of self, versatile (interface and functionalities may change).
sigma
overwrites the original initial sigma
.
inopts
allows to overwrite any of the original options.
This copy may not work as expected depending on the used sampler.
Copy mean and sample distribution parameters and input options. Do not copy evolution paths, termination status or other state variables.
>>> import cma >>> es = cma.CMAEvolutionStrategy(3 * [1], 0.1, ... {'verbose':-9}).optimize(cma.ff.elli, iterations=10) >>> es2 = es._copy_light() >>> assert es2.sigma == es.sigma >>> assert sum((es.sm.C - es2.sm.C).flat < 1e-12) >>> es3 = es._copy_light(sigma=10) >>> assert es3.sigma == es3.sigma0 == 10 >>> es4 = es._copy_light(inopts={'CMA_on': False}) >>> assert es4.sp.c1 == es4.sp.cmu == 0
self.mean + self._random_rescaling_factor_to_mahalanobis_size(y) * y is guarantied to appear like from the sample distribution.
compute ranks of vals
in function_values
and
in self.fit.fit
and store the results in _recorded_rankings
.
The ranking differences between two solutions appear to be similar
in the current and last iteration.
Assign self.x0
from argument x0
.
Input x0
may be a callable
or a list
or numpy.ndarray
of
the desired length.
Below an artificial example is given, where calling x0
delivers in the first two calls dimension * [5] and in
succeeding calls``dimension * [0.01]``. Only the initial value of
0.01 solves the Rastrigin function:
>>> import cma >>> class X0: ... def __init__(self, dimension): ... self.irun = 0 ... self.dimension = dimension ... def __call__(self): ... ... self.irun += 1 ... return (self.dimension * [5] if self.irun < 3 ... else self.dimension * [0.01]) >>> xopt, es = cma.fmin2(cma.ff.rastrigin, X0(3), 0.01, ... {'verbose':-9}, restarts=1) >>> assert es.result.fbest > 1e-5 >>> xopt, es = cma.fmin2(cma.ff.rastrigin, X0(3), 0.01, ... {'verbose':-9}, restarts=2) >>> assert es.result.fbest < 1e-5 # third run succeeds due to x0
call sm.update_now like sm.sample would do.
This avoids a bias when using
_random_rescaling_factor_to_mahalanobis_size
which was visible
with TPA line samples.
helper function for a smooth transition to sampling classes.
By now all tests run through without this method in effect. Gradient injection and noeffectaxis however rely on the non-documented attributes B and D in the sampler.


Elasticsearch
Edit (pull request)Prerequisite
Generate certificates for your elasticsearch cluster (see Certificate Generation), and download premium distribution of Alien4Cloud
Configuration of elasticsearch nodes
- Download elasticsearch 6.6.2 here, and install it at $ELASTIC_SEARCH_HOME
- Copy your certificates to $ELASTIC_SEARCH_HOME/config
- Modify $ELASTIC_SEARCH_HOME/config/elasticsearch.yml :
xpack.security.transport.ssl.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.key:
xpack.security.transport.ssl.certificate:
xpack.security.transport.ssl.certificate_authorities: [""]
xpack.security.http.ssl.enabled: true
xpack.security.http.ssl.verification_mode: certificate
xpack.security.http.ssl.key:
xpack.security.http.ssl.certificate:
xpack.security.http.ssl.certificate_authorities: [""]
xpack.security.authc.anonymous.roles: superuser
- Perform the same operations for all your elasticsearch cluster nodes
- Start your elasticsearch cluster
Configuration of Alien
- In $ALIEN_HOME/config/alien4cloud-config.yml, configure Alien as an elasticsearch transport client:
elasticSearch:
clusterName: my-cluster
local: false
client: true
prefix_max_expansions: 10
transportClient: true
resetData: false
# a comma separated list of host:port couples
hosts: <IP_ADDRESS>:9300,<IP_ADDRESS>:9300
- Modify the configuration of searchguard in $ALIEN_HOME/config/alien4cloud-config.yml :
searchguard:
ssl:
transport:
enabled: true
keystore_filepath: <keystore file>
keystore_password: <password>
truststore_filepath: <truststore file>
truststore_password: <password>
- SSL is only available with a remote Elastic Search.
- Start Alien, if index is created then your configuration is correct and working !
Using alien4cloud-spray to secure Elastic Search
The alien4Cloud spray available on Alien4Cloud spray gives scripts to generate CA, hosts keys and certificates elasticsearch_tls parameter in the alien4cloud-spray configuration file must be set to true, generated certificates have to be put in certificates_path (parameter of the same configuration file)
Edit (pull request)


I am styled with Basic appBasicHighlighter custom directive
I am styled with appBetterHighlighter custom directive
I am styled with appEvenBetterHighlighter custom directive
I am styled with appEeevenBetterHighlighter custom directive
I am styled with appEeevenBetterHighlighter-11212 custom directive
Current Value is: {{manyValues}}
Current Value is: {{manyValues}}
Current Value is: {{manyValues}}
Current Value is: {{manyValues}}


Discord ID to Creation Date
See the creation date of a server, channel, message or user using their Discord ID!
Place the ID in the Discord ID field. Example:<PHONE_NUMBER>82312982
Discord ID:
Result:
Creation Date(24H format):
Creation Date(12H format):
Your timezone:
Time ago:
Unix timestamp:


A normal link. Note: Apple does not like these use the button below.
google
A button as a link
A button as a link to an internal app or webpage. Note you must have a file called mypage.html in the same folder
An online image
Attempt an in app image using file:///android_asset/www/myImage1.jpg
Attempt an in app image using myImage1.jpg
An embedded youtube video. In youtube click share --> embedded --> paste the code but be careful you might have to add http: to the code
That works but does this not youtube video:
or this online video tag:
or this on iframe confusing thins calling a new page using the video
Another weird attempt using
"file:///sdcard/Android/data/com.example.application/image.jpg"
page finished


{% extends 'base.html' %} {% block title %} Whoops! {% endblock %} {% block analytics %} {% endblock %} {% block content %}
This is known as an HTTP500 error. Our technicians have been informed and will look into it.


End of Project Gutenberg's The Son of Tarzan, by Edgar Rice Burroughs *** END OF THIS PROJECT GUTENBERG EBOOK THE SON OF TARZAN *** ***** This file should be named 90-h.htm or 90-h.zip ***** This and all associated files of various formats will be found in: http://www.gutenberg.org/9/90/ Updated editions will replace the previous one--the old editions will be renamed. Creating the works from public domain print editions means that no one owns a United States copyright in these works, so the Foundation (and you!) can copy and distribute it in the United States without permission and without paying copyright royalties. Special rules, set forth in the General Terms of Use part of this license, apply to copying and distributing Project Gutenberg-tm electronic works to protect the PROJECT GUTENBERG-tm concept and trademark. Project Gutenberg is a registered trademark, and may not be used if you charge for the eBooks, unless you receive specific permission. If you do not charge anything for copies of this eBook, complying with the rules is very easy. You may use this eBook for nearly any purpose such as creation of derivative works, reports, performances and research. They may be modified and printed and given away--you may do practically ANYTHING with public domain eBooks. Redistribution is subject to the trademark license, especially commercial redistribution. *** START: FULL LICENSE *** THE FULL PROJECT GUTENBERG LICENSE PLEASE READ THIS BEFORE YOU DISTRIBUTE OR USE THIS WORK To protect the Project Gutenberg-tm mission of promoting the free distribution of electronic works, by using or distributing this work (or any other work associated in any way with the phrase "Project Gutenberg"), you agree to comply with all the terms of the Full Project Gutenberg-tm License (available with this file or online at http://gutenberg.net/license). Section 1. General Terms of Use and Redistributing Project Gutenberg-tm electronic works 1.A. By reading or using any part of this Project Gutenberg-tm electronic work, you indicate that you have read, understand, agree to and accept all the terms of this license and intellectual property (trademark/copyright) agreement. If you do not agree to abide by all the terms of this agreement, you must cease using and return or destroy all copies of Project Gutenberg-tm electronic works in your possession. If you paid a fee for obtaining a copy of or access to a Project Gutenberg-tm electronic work and you do not agree to be bound by the terms of this agreement, you may obtain a refund from the person or entity to whom you paid the fee as set forth in paragraph 1.E.8. 1.B. "Project Gutenberg" is a registered trademark. It may only be used on or associated in any way with an electronic work by people who agree to be bound by the terms of this agreement. There are a few things that you can do with most Project Gutenberg-tm electronic works even without complying with the full terms of this agreement. See paragraph 1.C below. There are a lot of things you can do with Project Gutenberg-tm electronic works if you follow the terms of this agreement and help preserve free future access to Project Gutenberg-tm electronic works. See paragraph 1.E below. 1.C. The Project Gutenberg Literary Archive Foundation ("the Foundation" or PGLAF), owns a compilation copyright in the collection of Project Gutenberg-tm electronic works. Nearly all the individual works in the collection are in the public domain in the United States. If an individual work is in the public domain in the United States and you are located in the United States, we do not claim a right to prevent you from copying, distributing, performing, displaying or creating derivative works based on the work as long as all references to Project Gutenberg are removed. Of course, we hope that you will support the Project Gutenberg-tm mission of promoting free access to electronic works by freely sharing Project Gutenberg-tm works in compliance with the terms of this agreement for keeping the Project Gutenberg-tm name associated with the work. You can easily comply with the terms of this agreement by keeping this work in the same format with its attached full Project Gutenberg-tm License when you share it without charge with others. 1.D. The copyright laws of the place where you are located also govern what you can do with this work. Copyright laws in most countries are in a constant state of change. If you are outside the United States, check the laws of your country in addition to the terms of this agreement before downloading, copying, displaying, performing, distributing or creating derivative works based on this work or any other Project Gutenberg-tm work. The Foundation makes no representations concerning the copyright status of any work in any country outside the United States. 1.E. Unless you have removed all references to Project Gutenberg: 1.E.1. The following sentence, with active links to, or other immediate access to, the full Project Gutenberg-tm License must appear prominently whenever any copy of a Project Gutenberg-tm work (any work on which the phrase "Project Gutenberg" appears, or with which the phrase "Project Gutenberg" is associated) is accessed, displayed, performed, viewed, copied or distributed: This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.net 1.E.2. If an individual Project Gutenberg-tm electronic work is derived from the public domain (does not contain a notice indicating that it is posted with permission of the copyright holder), the work can be copied and distributed to anyone in the United States without paying any fees or charges. If you are redistributing or providing access to a work with the phrase "Project Gutenberg" associated with or appearing on the work, you must comply either with the requirements of paragraphs 1.E.1 through 1.E.7 or obtain permission for the use of the work and the Project Gutenberg-tm trademark as set forth in paragraphs 1.E.8 or 1.E.9. 1.E.3. If an individual Project Gutenberg-tm electronic work is posted with the permission of the copyright holder, your use and distribution must comply with both paragraphs 1.E.1 through 1.E.7 and any additional terms imposed by the copyright holder. Additional terms will be linked to the Project Gutenberg-tm License for all works posted with the permission of the copyright holder found at the beginning of this work. 1.E.4. Do not unlink or detach or remove the full Project Gutenberg-tm License terms from this work, or any files containing a part of this work or any other work associated with Project Gutenberg-tm. 1.E.5. Do not copy, display, perform, distribute or redistribute this electronic work, or any part of this electronic work, without prominently displaying the sentence set forth in paragraph 1.E.1 with active links or immediate access to the full terms of the Project Gutenberg-tm License. 1.E.6. You may convert to and distribute this work in any binary, compressed, marked up, nonproprietary or proprietary form, including any word processing or hypertext form. However, if you provide access to or distribute copies of a Project Gutenberg-tm work in a format other than "Plain Vanilla ASCII" or other format used in the official version posted on the official Project Gutenberg-tm web site (www.gutenberg.net), you must, at no additional cost, fee or expense to the user, provide a copy, a means of exporting a copy, or a means of obtaining a copy upon request, of the work in its original "Plain Vanilla ASCII" or other form. Any alternate format must include the full Project Gutenberg-tm License as specified in paragraph 1.E.1. 1.E.7. Do not charge a fee for access to, viewing, displaying, performing, copying or distributing any Project Gutenberg-tm works unless you comply with paragraph 1.E.8 or 1.E.9. 1.E.8. You may charge a reasonable fee for copies of or providing access to or distributing Project Gutenberg-tm electronic works provided that - You pay a royalty fee of 20% of the gross profits you derive from the use of Project Gutenberg-tm works calculated using the method you already use to calculate your applicable taxes. The fee is owed to the owner of the Project Gutenberg-tm trademark, but he has agreed to donate royalties under this paragraph to the Project Gutenberg Literary Archive Foundation. Royalty payments must be paid within 60 days following each date on which you prepare (or are legally required to prepare) your periodic tax returns. Royalty payments should be clearly marked as such and sent to the Project Gutenberg Literary Archive Foundation at the address specified in Section 4, "Information about donations to the Project Gutenberg Literary Archive Foundation." - You provide a full refund of any money paid by a user who notifies you in writing (or by e-mail) within 30 days of receipt that s/he does not agree to the terms of the full Project Gutenberg-tm License. You must require such a user to return or destroy all copies of the works possessed in a physical medium and discontinue all use of and all access to other copies of Project Gutenberg-tm works. - You provide, in accordance with paragraph 1.F.3, a full refund of any money paid for a work or a replacement copy, if a defect in the electronic work is discovered and reported to you within 90 days of receipt of the work. - You comply with all other terms of this agreement for free distribution of Project Gutenberg-tm works. 1.E.9. If you wish to charge a fee or distribute a Project Gutenberg-tm electronic work or group of works on different terms than are set forth in this agreement, you must obtain permission in writing from both the Project Gutenberg Literary Archive Foundation and Michael Hart, the owner of the Project Gutenberg-tm trademark. Contact the Foundation as set forth in Section 3 below. 1.F. 1.F.1. Project Gutenberg volunteers and employees expend considerable effort to identify, do copyright research on, transcribe and proofread public domain works in creating the Project Gutenberg-tm collection. Despite these efforts, Project Gutenberg-tm electronic works, and the medium on which they may be stored, may contain "Defects," such as, but not limited to, incomplete, inaccurate or corrupt data, transcription errors, a copyright or other intellectual property infringement, a defective or damaged disk or other medium, a computer virus, or computer codes that damage or cannot be read by your equipment. 1.F.2. LIMITED WARRANTY, DISCLAIMER OF DAMAGES - Except for the "Right of Replacement or Refund" described in paragraph 1.F.3, the Project Gutenberg Literary Archive Foundation, the owner of the Project Gutenberg-tm trademark, and any other party distributing a Project Gutenberg-tm electronic work under this agreement, disclaim all liability to you for damages, costs and expenses, including legal fees.   LIMITED RIGHT OF REPLACEMENT OR REFUND - If you discover a defect in this electronic work within 90 days of receiving it, you can receive a refund of the money (if any) you paid for it by sending a written explanation to the person you received the work from. If you received the work on a physical medium, you must return the medium with your written explanation. The person or entity that provided you with the defective work may elect to provide a replacement copy in lieu of a refund. If you received the work electronically, the person or entity providing it to you may choose to give you a second opportunity to receive the work electronically in lieu of a refund. If the second copy is also defective, you may demand a refund in writing without further opportunities to fix the problem. 1.F.4. Except for the limited right of replacement or refund set forth in paragraph 1.F.3, this work is provided to you 'AS-IS' WITH NO OTHER WARRANTIES OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTIBILITY OR FITNESS FOR ANY PURPOSE. 1.F.5. Some states do not allow disclaimers of certain implied warranties or the exclusion or limitation of certain types of damages. If any disclaimer or limitation set forth in this agreement violates the law of the state applicable to this agreement, the agreement shall be interpreted to make the maximum disclaimer or limitation permitted by the applicable state law. The invalidity or unenforceability of any provision of this agreement shall not void the remaining provisions. 1.F.6. INDEMNITY - You agree to indemnify and hold the Foundation, the trademark owner, any agent or employee of the Foundation, anyone providing copies of Project Gutenberg-tm electronic works in accordance with this agreement, and any volunteers associated with the production, promotion and distribution of Project Gutenberg-tm electronic works, harmless from all liability, costs and expenses, including legal fees, that arise directly or indirectly from any of the following which you do or cause to occur: (a) distribution of this or any Project Gutenberg-tm work, (b) alteration, modification, or additions or deletions to any Project Gutenberg-tm work, and (c) any Defect you cause. Section 2. Information about the Mission of Project Gutenberg-tm Project Gutenberg-tm is synonymous with the free distribution of electronic works in formats readable by the widest variety of computers including obsolete, old, middle-aged and new computers. It exists because of the efforts of hundreds of volunteers and donations from people in all walks of life. Volunteers and financial support to provide volunteers with the assistance they need, is critical to reaching Project Gutenberg-tm's goals and ensuring that the Project Gutenberg-tm collection will remain freely available for generations to come. In 2001, the Project Gutenberg Literary Archive Foundation was created to provide a secure and permanent future for Project Gutenberg-tm and future generations. To learn more about the Project Gutenberg Literary Archive Foundation and how your efforts and donations can help, see Sections 3 and 4 and the Foundation web page at http://www.pglaf.org. Section 3. Information about the Project Gutenberg Literary Archive Foundation The Project Gutenberg Literary Archive Foundation is a non profit 501(c)(3) educational corporation organized under the laws of the state of Mississippi and granted tax exempt status by the Internal Revenue Service. The Foundation's EIN or federal tax identification number is 64-6221541. Its 501(c)(3) letter is posted at http://pglaf.org/fundraising. Contributions to the Project Gutenberg Literary Archive Foundation are tax deductible to the full extent permitted by U.S. federal laws and your state's laws. The Foundation's principal office is located at 4557 Melan Dr. S. Fairbanks, AK, 99712., but its volunteers and employees are scattered throughout numerous locations. Its business office is located at 809 North 1500 West, Salt Lake City, UT 84116,<PHONE_NUMBER>, email<EMAIL_ADDRESS>Email contact links and up to date contact information can be found at the Foundation's web site and official page at http://pglaf.org For additional contact information: Dr. Gregory B. Newby Chief Executive and Director<EMAIL_ADDRESS>Section 4. Information about Donations to the Project Gutenberg Literary Archive Foundation Project Gutenberg-tm depends upon and cannot survive without wide spread public support and donations to carry out its mission of increasing the number of public domain and licensed works that can be freely distributed in machine readable form accessible by the widest array of equipment including outdated equipment. Many small donations ($1 to $5,000) are particularly important to maintaining tax exempt status with the IRS. The Foundation is committed to complying with the laws regulating charities and charitable donations in all 50 states of the United States. Compliance requirements are not uniform and it takes a considerable effort, much paperwork and many fees to meet and keep up with these requirements. We do not solicit donations in locations where we have not received written confirmation of compliance. To SEND DONATIONS or determine the status of compliance for any particular state visit http://pglaf.org While we cannot and do not solicit contributions from states where we have not met the solicitation requirements, we know of no prohibition against accepting unsolicited donations from donors in such states who approach us with offers to donate. International donations are gratefully accepted, but we cannot make any statements concerning tax treatment of donations received from outside the United States. U.S. laws alone swamp our small staff. Please check the Project Gutenberg Web pages for current donation methods and addresses. Donations are accepted in a number of other ways including including checks, online payments and credit card donations. To donate, please visit: http://pglaf.org/donate Section 5. General Information About Project Gutenberg-tm electronic works. Professor Michael S. Hart is the originator of the Project Gutenberg-tm concept of a library of electronic works that could be freely shared with anyone. For thirty years, he produced and distributed Project Gutenberg-tm eBooks with only a loose network of volunteer support. Project Gutenberg-tm eBooks are often created from several printed editions, all of which are confirmed as Public Domain in the U.S. unless a copyright notice is included. Thus, we do not necessarily keep eBooks in compliance with any particular paper edition. Most people start at our Web site which has the main PG search facility: http://www.gutenberg.net This Web site includes information about Project Gutenberg-tm, including how to make donations to the Project Gutenberg Literary Archive Foundation, how to help produce our new eBooks, and how to subscribe to our email newsletter to hear about new eBooks.