??I
REVISION
OF
CAIMAVALIA,
1962
Subgenus
Canavalia
Canavalia
maritima
(Aubl.)
Thou,
Det.
J.D.
Sauer
NEW
YORK
BOTANICAL
GARDEN
ACADEMY
OF
NATURAL
SCIENCES
OF
PHILADELPHIA
EXPLORATION
Of
.BERMUDA
h,
*
,
A^
NO.
A
7Os
ctewardson
Brown
t
STewakuouČ
.
Collectors,
AUG.
31-Sept.
20,
1905
N.
L.
Britton
I
1616377
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high


In the Censoring Statistic, group, choose either the label or the numbers button.
Due to some changes in how label components are handled between Statistics versions, it may happen that the censoring statistic is not found by its label. In that case, it is necessary to use the numbers.
Select the type of comparison to be done from the dropdown
list. The test carried out is
abs(cell value) testtype critvalue.
For example, abs(cell count) < 5.
List the cells to be censored in the Neighboring rows or columns to censor field. The cells to be censored are indicated by their position relative to the censoring statistic. Negative numbers are to the left or above the censoring cell, and positive numbers are to the right or below that cell. Include 0 in the list to censor the censoring statistic itself.
For example, if a table has columns count, mean, and standard
deviation, you could censor the mean and standard deviation based
on the count by entering
1 2
in the list.
You can specify the OMS subtype of the table to process in the Table OMS Subtype field. You can find the subtype by right clicking in the outline on an instance or from Utilties/OMS identifiers. Case and white space do not matter.
By default, the censoring will be applied to the last pivot table in the Viewer. You can specify All to censor all tables. If an OMS table subtype is specified, the censoring is limited to tables of that type.
Check the box Hide criterion row or column to hide the entire row or column containing the censoring statistic.
By default, caption text is added showing the number of cells censored and the name of the censoring statistic. Uncheck Add caption with censoring information to prevent this.
You can control whether the caption always appears or only if any cells are actually censored by choosing the appropriate radio button.
Check Custom caption text and enter text below to have custom caption text.
By default, censored cells are made blank. Enter a string of one or more characters in Symbol for Censored Cells to specify different replacement text.
© Copyright IBM Corp. 1989, 2015


|
Dexter is a detail-oriented individual
experienced in a fast-paced design environment
with a background in Graphic Design, Layout,
Typography, Online Content Management,
Photography, Color Correction and Retouching,
Management, Prepress, Computer Trouble Shooting.
|


catalogo
menu
pesquisa
cole abaixo o lobby de entrada
player 1:
player 2:
player 3:
player 4:
player 5:


Mu
Published: 2020-09-18A monk asked Joshu, "Has the dog the Buddha nature?"
A monk asked Joshu, "Has the dog the Buddha nature?"
Gutei raised his finger whenever he was asked a question about Zen. A boy attendant began to imitate him in this way. When a visitor asked the boy what his master had preached about, the boy raised his finger.
Nansen saw the monks of the eastern and western halls fighting over a baby cat. He seized the cat and said, "If (any of) you can say (a word of Zen), you can spare the cat.


{% extends 'base.html'%} {% load static %} {% block content %}
| File Input |
{{error_message}}
Upload your input data:
|
Nucleotide sequence alignment ?The alignment in the fasta file format. The following character states are considered: (1) “A, C, G, T” for nucleotides; (2) “–“ for gaps (deletions), and (3) “N” for missing information. :
|
|
|
(Optional) Phylogenetic tree ?The tree file to the corresponding alignment in the newick file format. Identical labels for the taxa are required in the tree and alignment. :
|
|
| Use example dataset ?The example dataset comprises the alignment and tree shown in the publication (Figure 1). : |
|
| Consider gaps (deletions) ?Choose if deletions should be classified as signature characters and coloured accordingly. : |
Search parameter settings:


Project REsearch
Eco-Commitment
Initial Value
Actual value
Submitted by:
. Current deadline:
Green energy consumption commited [kWh]
Deposit commitment [eth]
Value transfered to beneficiary:


Youtube Video Link/URL
Please enter a valid URL.
Video Duration
A valid duration is required
No. of tabs
A valid no. is required
Frequency
Valid last name is required.
Begin


| Home | Class XRef | The List Class | The IndexedList Class | The TimeSeries Class |
The Collection class is an abstract class that is used to organize classes in the hierarchy whose instances represent sets of objects. The major subclasses of Collection are: List, IndexedList, and TimeSeries.
Instances of the class List represent collections of objects that are accessed either by position or as a set. Instances of the class IndexedList represent collections of objects that are accessed by a user-defined index or as a set. Instances of the class TimeSeries represent collections of objects that are accessed by date or as a set. The elements in a collection do not need to be from the same class.
The Collection class is an indirect subclass of Object:
Object
|
Function
|
EnumeratedFunction
|
Collection
|
IndexedCollection
| |-- IndexedList
| |-- TimeSeries
|
SequencedCollection
|-- List
The Collecton classes have been optimized to organize and
query large sets of data. A large number of the messages defined
for these classes have been written in Vision and can therefore be
modified and expanded as needed. As always, you can define any
number of new messages for these classes.
Many of the frequently used List, IndexedList, and TimeSeries messages are defined at the class Collection. Each subclass defines additional messages that are unique for the specific class. You can send the toList message to an instance of any of the Collecton subclasses to return an instance of the List class. You cannot directly convert instances of one of these subclasses to a TimeSeries or an IndexedList object.
All Collection objects respond to the message count. For example:
Currency instanceList count print ;prints the number of instances in the Currency class.
The do: message has been redefined at the Collection class. It performs the same function as the version defined at Object; however, instead of applying to a single object, the version defined for the Collection class applies the block supplied as the parameter to each element in the recipient object. For example:
Currency instanceList do: [ code print: 10 ; name printNL ] ;displays the value of code and name for each instance in the Currency class. The supplied block is evaluated for each element in the collection. Messages within the block are sent to the individual elements in the collection.
The send: message has also been redefined at the Collection class. It works identically to the do: message except for the value returned. The block is evaluated for each object in the recipient collection. Unlike the do: message, the result of evaluating the block is returned, not the original object. Blocks return the value of the last statement exectued. The send: message is defined to return this object for each object in the recipient collection. For example:
!names <- Currency instanceList send: [ name ] ; names count printNL ;In this example, the currency name is returned for each instance in the Currency class. The variable names represents a collection where each element in this collection is the name of a currency. If the do: message had been used instead of send:, the variable names would represent the list of all currency instances. The collection returned by the send: message has the same number of elements in the same order as the original collection. If the original collection is a List or an IndexedList, the send: message returns a List. If the original collection is a TimeSeries, the send: message returns a TimeSeries containing the same dates as the original TimeSeries. The do: message always returns the original collection.
The extendBy: message has been redefined at the Collection class. It performs the same function as the version defined at Object. Instead of applying to a single object, the version defined for the Collection class applies the block supplied as the parameter to each element in the recipient object, returning a collection where each element of the collection is extended by the variables defined within the block. For example:
!xlist <- Currency instanceList extendBy: [ !nameLength <- name count ; !name10 <- name take: 10 ; ] ;defines xlist to represent a list of all currency instances that respond to the new variables nameLength and name10 in addition to the currency messages. For example:
xlist do: [ name print: 30 ; nameLength printNL ; ] ;All objects in xlist respond to the nameLength message just like any other message. All objects in the list continue to respond to the messages already defined such as name.
Within the square brackets, you can define as many variables as you would like. Each variable should be introduced with the symbol ! followed by a variable name. If the original collection is a List or an IndexedList, the extendBy: message returns a List. If the original collection is a TimeSeries, the extendBy: message returns a TimeSeries containing the same dates as the original TimeSeries.
The collect: message is used to create an extension of the original list that always defines a variable named value. This variable is set to the result of evaluating the block supplied as a parameter to the collect: message.
The messages do:, send:, and extendBy: have been redefined for the Collection classes to operate on the elements of the collection. The messages basicDo:, basicSend:, and basicExtend: are available if you want to run any of these operations on the collection as a whole. For example:
Currency instanceList basicDo: [ whatAmI print: 30 ; count printNL ] ;sends the messages inside the block to the collection object itself, not to the individual elements.
The message numberElements can be used to extend each element in a collection by the variable position which corresponds to its position number in the collection. For example:
Currency instanceList numberElements #- extend by !position do: [ code print: 10 ; position printNL ; ] ;
The message linkElements can be used to extend each element in a collection by the two variables: prior and next. These variables will return the elements in the recipient that are before or after each element in the recipient. For example:
3 sequence linkElements do: [ print ; prior print ; next printNL ] ; displays: 1 NA 2 2 1 3 3 2 NA
It is often useful to restrict a collection to objects that meet certain criteria. For example, you may wish to find the currencies with a US exchange rate greater than 2 and produce a report for those currencies:
Currency instanceList #- start with all currencies select: [ usExchange > 2 ]. #- return subset meeting criteria do: [ name print: 30 ; #- display name and exchange usExchange printNL ; #- for members of subset ] ;
The select: message returns a collection of those elements in the original collection that meet the criteria specified.
The select: message returns a new Collection object that contains a subset of the objects in the original Collection. This subset can be empty (i.e., contain no objects) and will never have more elements than the original collection. If the original collection is a List or an IndexedList, the select: message returns a List. If the original collection is a TimeSeries, the select: message returns a TimeSeries containing a subset of the dates in the original TimeSeries.
The block supplied as the parameter to the select: message can contain any valid Vision program. You can create local variables in this block and use the && and || messages to produce multi-part criteria. For example:
Currency instanceList select: [ !firstLetter <- name take: 1 ; (usExchange > 2 ) && (firstLetter < "B" || firstLetter > "U") ] .The value returned by the selection block is the value used to perform the selection. The subset will include all elements that return the value TRUE when this block is evaluated. Since the object returned by the select: message is another Collection, you can send another select: message to it. The previous example could have been written using:
Currency instanceList select: [ usExchange > 2 ] . select: [ !firstLetter <- name take: 1 ; firstLetter < "B" || firstLetter > "U" ] .
The message first: is used to select the specified number of elements in the recipient that are not the default value, starting from the beginning of the collection. The message last: is used to select the specified number of elements in the recipient that are not the default value, starting from the end of the collection. For example:
Currency instanceList last: 10 . select: [ usExchange > 2 ] .This expression selects the last 10 currencies in the Currency class and then selects those with an exchange rate greater than 2 from this subset.
The message nonDefaults can be used to eliminate any default values from a Collection. For example:
Currency instanceList nonDefaultsreturns a list of all currencies excluding the default instance. It is equivalent to:
Currency instanceList select: [ isntDefault ] .
The messages sortUp: and sortDown: return the recipient collection as a List object in ascending or descending order. The collection is sorted by the value returned by the block supplied as a parameter. For example:
Currency instanceList sortUp: [ name ] . do: [ name printNL ] ;This program sorts the currency objects by name and prints them in alphabetical order.
You can perform multiple sorts using the sortUpBy:then: and sortDownBy:then: messages and supplying two criteria. For example, to sort by exchange rate, then name, use:
Currency instanceList sortUpBy: [ usExchange ] then: [ name ] . do: [ name print: 30 ; usExchange printNL ] ;The messages sortUpBy:then:then:, sortUpBy:then:then:then:, sortDownBy:then:then:, and sortDownBy:then:then:then: have also been defined to perform sorts with additional criteria.
Since these messages assume all your sorts are ascending or descending, they cannot be used to sort the currencies from highest to lowest score and then alphabetically by name for ties. To accomplish this, you need to take advantage of the fact that the sort messages produce "stable" sorts. This means that when a sort message is applied to a collection, the original order of the collection is preserved if the sort produces a tied value. If you apply several sort criteria in reverse order (i.e., the most detailed level of sort first), you can produce the desired results. For example:
Currency instanceList sortUp: [ name ] . sortUp: [ usExchange ] . do: [ name print: 30 ; usExchange printNL ] ;is identical to the previous example, producing an ascending sort by exchange rate, sorting alphabetically when the exchange rates are the same. The expression:
Currency instanceList sortUp: [ name ] . sortDown: [ usExchange ] . do: [ name print: 30 ; usExchange printNL ] ;produces a descending sort by exchange rate, sorting alphabetically when the exchange rates are the same.
The rankUp: and rankDown: messages are defined to rank the elements in a Collection based on the value returned by evaluating the parameter supplied as a block. These message return a List or TimeSeries extended by the variable rank which represents the element's rank in the collection. The value of rank will be an integer between 1 and the number of elements in the recipient object. The returned object will have the same number of elements and will be in the same order as the recipient. For example:
Currency instanceList rankUp: [ usExchange ] . do: [ code print: 5 ; usExchange print ; rank printNL ] ;The displayed rank indicates the currency's position in the collection by ascending exchanging rate.
The messages rankDown:usingCollector: and rankUp:usingCollector: provide a way to define a different variable name to the hold the value of the rank. The second parameter is a named block that defines the variable name to use as a parameter and returns the value of ^current. For example, to name the variable alt instead of rank use:
Currency instanceList rankUp: [ usExchange ] usingCollector: [ | :alt | ^current ] . do: [ code print: 5 ; usExchange print ; alt printNL ] ;
The groupedBy: message provides you with a powerful tool for aggregation, enabling you to simultaneously analyze information at a detailed and aggregate level. The groupedBy: message is used to organize your original Collecton into a List of groups, sublists that are generated based on the criteria supplied. You can perform summary analysis on each group and analyze the individual elements in each group.
The groupedBy: message groups the recipient collection based on the value returned by the block supplied as a parameter. It returns a List of the unique instances of this value found in the recipient collection, extended by the variable groupList, which returns the List of elements from the original collection that are associated with the specific group.
For example, if the variable companyList contains a list of companies that respond to the message sector, and each sector responds to the message name, then the expression:
companyList groupedBy: [ sector ] . do: [ name printNL ; ] ;can be used to group the companies into sectors and display the name of each sector present.
By asking Vision to group companyList by sector, Vision returns a List of the sectors that exist in companyList. The original set of companies is not lost. Each element in the List formed by the groupedBy: message responds to the message groupList. This message returns the List of companies from the original collection associated with the specific group. For example:
companyList groupedBy: [ sector ] . do: [ name print ; groupList count printNL ; ] ;displays the number of elements in the group after each sector's name. Since groupList returns a List object, you can send any of the List messages to it. For example, you could display the companies in each sector using:
companyList groupedBy: [ sector ] . do: [ name print ; groupList count printNL ; groupList do: [ # for each company in sector displayInfo ; # print standard company info ] ; # end of groupList do: [] ]; # end of sector do: []In this example, the summary information is displayed about the sector followed by an entry for each element in the sector.
Pictorially the groupedBy: message works as follows:
Grouping introduces a concept known as nested lists. In this case, the outer list represents a list of sectors. Each element in this outer list in turn responds to the message groupList which returns the set of elements from the original list that are in the current group. Since this subset is itself a list, you can perform any list operations on it, including grouping it further. For example:
companyList groupedBy: [ sector ] . # group by sector do: [ "SECTOR: " print; name printNL; # print sector's name groupList groupedBy: [ industry ] . # group companies in sector do: [ # by industry "INDUSTRY: " print; name printNL; # print industry's name groupList # for each company do: [ # in industry "Company: " print ; name printNL ; # print company's name ] ; # end of companies in ind. ] ; # end of industries in sector ] ; # end of sectors
This report groups companyList into sectors. The companies within a sector are then grouped into industries. The companies are listed under their corresponding industry. This example uses the groupedBy: message twice; once to group the original list into sectors; the second time to group the companies in a given sector into industries.
Note: The message groupedByString: is used to correctly group lists using a criteria block that generates a String value. By default, strings that are distinct objects will be grouped into separate groups even if they have the same content. This version of the groupedBy: message groups strings with the same content into the same group, even if the initial strings are distinct objects.
A number of additional variations of the groupedBy: message have been defined and are summarized below:
| Message | Definition |
| groupedBy:in: | Groups recipient using parameter1 and returns List containing one element for each value in the List supplied as parameter2 |
| groupedBy:intersect: | Groups recipient using parameter1 and returns List containing one element for each value that appears in both recipient and parameter2 |
| groupedBy:union: | Groups recipient using parameter1 and returns List containing one element for each value that appears in either recipient or parameter2 |
| groupedBy:usingCutoffs: | Groups recipient using parameter1 into partitions based on List of Numbers supplied in parameter2 |
| groupedByCriteria: | Groups recipient based on List of Blocks supplied as parameter, returning a List extended by keyList as well as groupList |
| groupPrintUsing: | Groups recipient using parameter, displaying the count for each group |
| mgroupedBy: | Groups recipient using parameter1 which can return a List of objects. Elements in the recipient may be included in one or more groupLists. |
A number of messages have been defined to compute summary statistics for a Collection. For example:
companyList average: [ sales ]computes the average sales value for the companies in companyList.
The following table summarizes the various statistical messages that have been defined. Note that most of these messages are defined in Vision and can therefore be copied or modified to create other variations as needed. These messages can be sent to an instance of any Collection subclass and return a numeric value of NA. Parameters are Blocks except where explicitly noted.
| Message | Definition | Sample |
| average | Simple average | 5 sequence average |
| average: | Simple average based on value returned by parameter | list average: [ sales ] |
| average:withWeights: | Weighted average using parameter2 to weight the value returned by parameter1 | list average: [sales] withWeights: [mktCap] |
| compound | Compounded value | 5 sequence compound |
| compound: | Compounded value based on value returned by parameter | list compound: [sales] |
| correlate:with: | Correlation based on evaluation of blocks supplied as two parameters | list correlate: [sales] with: [profit] |
| gMean | Geometric Mean | 5 sequence gMean |
| gMean: | Geometric mean based on value returned by parameter | list gMean: [sales] |
| harmonicMean | Harmonic Mean | 5 sequence harmonicMean |
| harmonicMean: | Harmonic mean based on value returned by parameter | list harmonicMean: [sales] |
| harmonicMean:withWeights: | Harmonic mean using parameter2 to weight the value returned by parameter1 | list harmonicMean: [sales] withWeights: [mktCap] |
| max | Maximum value in recipient | 5 sequence max |
| max: | Maximum based on value returned by parameter | list max: [sales] |
| median | Median value in recipient | 5 sequence median |
| median: | Median based on value returned by parameter | list median: [sales] |
| min | Minimum value in recipient | 5 sequence min |
| min: | Minimum based on value returned by parameter | list min: [sales] |
| mode | Mode value in recipient | 5 sequence mode |
| mode: | Mode based on value returned by parameter | list mode: [sales] |
| product | Product of values in recipient | 5 sequence product |
| product: | Product of values returned by parameter | list product: [sales] |
| rankCorrelate:with: | Correlation between relative ranks of values returned by the two parameters | list rankCorrelate: [sales] with: [profit] |
| regress: | Performs linear regression between recipient and parameter, returning object that responds to beta, alpha, pearson, rsq, and stdErr. | (2,3,9,1,8,7,5) regress: (6,5,11,7,5,4,4) . |
| stdDev | Standard deviation of values in recipient | 5 sequence stdDev |
| stdDev: | Standard deviation based on value returned by parameter | list stdDev: [sales] |
| total | Total value in recipient | 5 sequence total |
| total: | Total based on value returned by parameter | list total: [sales] |
The decileUp: and decileDown: messages have been implemented to assign a value from 1 to 10 to each element in the recipient Collecton. The decileUp: message assigns the value 1 to the first 10% of the elements with the lowest values, the value 2 to the next 10%, and so on with the value 10 assigned to the elements in the top 10%. The decileDown: message assigns the value 1 to the first 10% of the elements with the highest values and the value 10 to the elements in the bottom 10%. When you send one of these messages to a Collection, Vision returns the recipient extended by the variable named decile. For example:
companyList decileDown: [ sales ] . do: [ name print: 30 ; sales print: 10 ; decile printNL ; ] ;displays the decile value from 1 to 10 for each company in companyList.
The quintileUp: and quintileDown: messages are identical to the decile messages except they assign a value from 1 to 5, returned in a variable named quintile. The percentileUp: and percentileDown: messages are identical to the decile messages except they assign a value from 1 to 100, returned in a variable named percentile.
The messages tileUp:tiles: and tileDown:tiles: can be used to provide an arbitrary number of tiles. The extended variable is named tile. For example, to group a company list into fractiles (20 groups), you could use:
companyList tileUp: [ sales ] tiles: 20 . do: [ name print: 30 ; sales print: 10 ; tile printNL ; #- number from 1-20 ] ;
If you want to define a different name for the extended variable representing the tile, you can use the messages decileUp:using:, decileDown:using:, quintileUp:using:, quintileDown:using:, percentileUp:using:, percentileDown:using:, tileUp:using:tiles:, and tileDown:using:tiles:. For example:
companyList decileUp: [ sales ] using: "d1" . decileUp: [ profit ] using: "d2" . do: [ name print: 30 ; d1 print ; # sales decile d2 printNL ; # profit decile ] ;
These various "tiling" messages have all been defined in Vision using the messages tileUp:usingCollector:tiles: and tileDown:usingCollector:tiles:. The first parameter is the block to be evaluated. The second parameter defines the name of the extended variable. The third parameter indicates the number of "tiles" to create. For example, to define the message fractileUp:, use:
Collection defineMethod: [ | fractileUp: block | ^self tileUp: block usingCollector: [ |:fractile| ^current ] tiles: 20 ] ;
The message runningTotal: returns the recipient Collection extended by the variable runningTotal which represents the running sum of the elements in the collection to that point. For example:
20 sequence runningTotal: [ ^self ] . do: [ print ; runningTotal printNL ; ];The message runningAverage: returns the recipient Collection extended by the variable runningAverage which represents the running average of the elements in the collection to that point.
Several additional Collection messages return the recipient collection extended by a new variable. The message normalize: returns the recipient extended by the variable norm, representing the normalized value of the element relative the mean and standard deviation of the collection. The message weightedDecile: returns the recipient extended by the variable decile, a number from 1 to 10. The message weightedQuintile: returns the recipient extended by the variable quintile, a number from 1 to 5.
A number of messages have been defined to perform operations between two lists. The messages can be sent to an instance of any Collection subclass and return a List object unless otherwise noted.
| Message | Definition | Sample |
| + | Add parameter to recipient (List or TimeSeries only); parameter can be a scalar number or a list of numbers | 5 sequence + 5 sequence |
| - | Subtract parameter from recipient (List or TimeSeries only); parameter can be a scalar number or a list of numbers | 5 sequence - 3 |
| * | Multiply recipient by parameter (List or TimeSeries only); parameter can be a scalar number or a list of numbers | 5 sequence * 5 sequence |
| / | Divide recipient by parameter (List or TimeSeries only); parameter can be a scalar number or a list of numbers | 5 sequence / 2 |
| isEquivalentTo: | Returns Boolean indicating if recipient and parameter have equivalent content | 5 sequence isEquivalentTo: 1,2,3,4,5 . |
| union: | Returns List of elements in either or both the recipient and parameter | 5 sequence union: 3 sequence . |
| union:using: | Returns List of elements in either or both the recipient and parameter1 using block supplied as parameter2 to modify the elements before comparing for equality | list1 union: list2 using: [ asSelf ] . |
| intersect: | Returns List of elements in both the recipient and parameter | 5 sequence intersect: 3 sequence . |
| intersect:using: | Returns List of elements in both the recipient and parameter1 using block supplied as parameter2 to modify the elements before comparing for equality | list1 intersect: list2 using: [ asSelf ] . |
| exclude: | Returns List of elements in recipient that are not in parameter | 5 sequence exclude: 3 sequence . |
| exclude:using: | Returns List of elements in recipient that are not in parameter1 using block supplied as parameter2 to modify the elements before comparing for equality | list1 exclude: list2 using: [ asSelf ] . |
| difference: | Returns a List of 2 elements: the first contains the List of elements that are in recipient and not in parameter; the second contains the List of elements that are in parameter and not in recipient | list1 difference: list2 . |
Many of the messages described in this document implicitly create new instances of one of the Collection subclasses. Messages such as send:, select:, groupedBy:, sortUp:, decileDown:, and extendBy: all create and return new Collection objects.
There is normally no reason to create new instances of the Collection class directly. You can explicitly create a new instance of any of the Collection subclasses by sending the new message to the specific class. For example:
!list <- List new ; !ilist <- IndexedList new ; !ts <- TimeSeries new ;The variables list, ilist, and ts can be accessed and updated using the rules defined for the List, IndexedList, and TimeSeries, respectively.
The copyListElements message can be used to create a copy of a Collection. The returned object is a new Collection containing the same elements as the original. When this message is sent to a List or IndexedList, a new List is created and returned. When this message is sent to a TimeSeries, a new TimeSeries object is created and returned.
The append: message can be used to append objects to a Collection. The returned object is always a new List.
The collectListElementsFrom: message is used to create a single List from a Collection of Lists. The supplied parameter should be a Block. This message evaluates the block for each element and creates a "running list" of the objects returned by the block. If the returned object is a Collection, the individual elements in the collection are appending the "running list". For example:
5 sequence collectListElementsFrom: [ ^self sequence ] . do: [ printNL ] ;returns a single List containing the elements 1, 1, 2, 1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5.
A common requirement when working with Collections is to apply a series of operations in succession. Starting with a list, you may wish to perform a series of extensions, selections, and groupings, then sort and print the result. There are a number of different techniques that can be used to produce the same result. For example:
!myList <- Currency instanceList ; !xList <- myList extendBy: [ !rate <- 1 / usExchange ] ; !subset1 <- xList select: [ rate < 1.5 ] ; !subset2 <- subset1 first: 5 ; !final <- subset2 sortUp: [ name ] ; final do: [ code print: 5 ; name print: 15 ; rate printNL ; ] ;This example uses a large number of temporary variables. Although there is nothing wrong with this approach, you need not save each of the intermediate steps. For example:
Currency instanceList extendBy: [ !rate <- 1 / usExchange ] . select: [ rate < 1.5 ] . first: 5 . sortUp: [ name ] . do: [ code print: 5 ; name print: 15 ; rate printNL ; ] ;This example produces the same result without any intermediate variables.
Note that the . operator is used to terminate the keyword messages such as select: and do:. A common misassumption is that this operator is automatically inserted after each collection operation. Although this particular example may look as though that is the case, the purpose of the operator is to terminate the parameters and evaluate the expression up until that point. For example, if you were using the unary message numberElements in the previous expression it would not be followed by the .:
Currency instanceList numberElements #- . not needed since no parameters extendBy: [ !rate <- 1 / usExchange ] . #- . terminates block select: [ rate < 1.5 ] . #- . terminates block first: 5 . #- . terminates count sortUp: [ name ] . #- . terminates block do: [ code print: 5 ; name print: 15 ; rate printNL ; ] ;The . operator provides an alternative to using parentheses in expressions containing numerous keywords applied in succession such as this one. The same expression using parentheses could be written as:
((((Currency instanceList numberElements extendBy: [ !rate <- 1 / usExchange ] ) select: [ rate < 1.5 ] ) first: 5 ) sortUp: [ name ] ) do: [ code print: 5 ; name print: 15 ; rate printNL ; ] ;
The do: message is defined to evaluate its block parameter for each element in the collection. Although this operation may appear to operate an element at a time, collection operations are actually optimized internally and do not execute by sequential evaluation.
Warning!! Because collections are not evaluated sequentially, you do not have control over the order in which the collection is processed nor can you assume that the number of evaluations is equal to the number of elements in the list. For example:!count <- 0 ; list do: [ ^global :count <- ^global count + 1 ] ; count printNL ;will not produce the results you expect. Although you might expect count to equal the number of elements in list, it would actually equal the number of internal passes needed to process the list.
The iterate: message can be used instead of do: when you want to evaluate the list in order, an element at a time. Although there are situations when you may need to do this, this message is much slower than the do: message since it does not benefit from the optimizations available. For example:
!count <- 0 ; list iterate: [ ^global :count <- ^global count + 1 ] ; count printNL ;
For additional information see:
| Copyright © 1997 Innovative Systems Techniques, Inc. | Updated June 19, 1997 |


More Help Here
IRC
Developers and users idle on Freenode.net's IRC network in #just on freenode
Bugs?
If you've found any bug or you did not get any help through other channels please file your issue here
Need to contact us?
Feel free to write us by email at just@extremeprog.com.


Northumberland pervert admits stashing sick images of children
Michael Garry is facing a prison sentence after pleading guilty to making and possessing indecent or prohibited pictures of kids
by Sara NicholA Northumberland pervert is facing time behind bars after he was found with collection of vile images of children.
Michael Garry, formerly of Bedlington but now living in Acklington, was found by police to have nearly 70 of the sick pictures, including 23 of the most serious kind.
A court was told that the 35-year-old downloaded the photos or moving images on or before April 22 last year at his then-home in The Wynding, Bedlington .
Garry, who now lives at The Village, Acklington, appeared in the dock at South East Northumberland Magistrates' Court on Thursday, where he pleaded guilty to one count of possessing a prohibited image of a child and three of making indecent images of a child.
James Long, prosecuting, said: "This is a matter, in any view, that is out of your powers of sentence.
"There are 23 category A images, which are the most serious kind.
"I don't think there's any point outlining the case to you as the charges speak for themselves."
The court heard Garry also had 12 category B and 33 category C images.
Kyle Patterson, defending, made no representations at this stage.
Magistrates committed Garry to Newcastle Crown Court for sentence on December 19 and released him on unconditional bail until that date.


for i : 0 .. 12
const arg := i / 4
put "Arc tangent of ", arg, " is ",
arctan (arg), " radians"
end for
the arctand function which finds the arc tangent of a value with the result given in degrees. (2p radians are the same as 360 degrees.)
See also predefined unit Math.


check-runtime-env / check-runtime-env.js
Node.js implementation of a checker for some runtime environment properties.
The purpose of this library is to simplify some check in the environment where the code is running (at runtime).
Usage
Get a reference to the library:
// Node.js example
const assert = require('assert').strict
// reference the library, not needed if using destructuring assignment, see below
const RuntimeEnvChecker = require('../src/') // from local path
assert(RuntimeEnvChecker !== null)
get some runtime data and version constraints, optional:
const nodeVersion = process.version
assert(nodeVersion !== null)
const npmVersion = RuntimeEnvChecker.getVersionOfNpm()
assert(npmVersion !== null)
const engines = require('../package.json').engines
assert(engines !== null)
const expectedNodeVersion = engines.node
assert(expectedNodeVersion !== null)
const expectedNPMVersion = engines.npm
assert(expectedNPMVersion !== null)
console.log(`Node.js current version: ${nodeVersion}`)
console.log(`Node.js version expected in 'package.json': ${engines.node}`)
console.log(`NPM current version: ${npmVersion}`)
console.log(`NPM version expected in 'package.json': ${engines.npm}`)
call some static method exposed by the class:
console.log(`Doing some tests; note that a check not satisfied will throw Error ...`)
console.log(`Check version of Node, using defaults, success: ${RuntimeEnvChecker.checkVersionOfNode()}`)
console.log(`Check version of Node, using explicit values, success: ${RuntimeEnvChecker.checkVersionOfNode(nodeVersion, expectedNodeVersion)}`)
console.log(`Check version of NPM, using NPM release found, and NPM expected value implicit, success: ${RuntimeEnvChecker.checkVersionOfNpm(npmVersion)}`)
console.log(`Check version of NPM, using explicit values, success: ${RuntimeEnvChecker.checkVersionOfNpm(npmVersion, expectedNPMVersion)}`)
console.log(`Check version (generic), using explicit values, success: ${RuntimeEnvChecker.checkVersion('10.13.0', '>=8.9.0 <12.0.0')}`)
try {
console.log(`Sample failure in check version (generic): expected error`)
console.log(`Check version (generic), using explicit values, success: ${RuntimeEnvChecker.checkVersion('10.13.0', '>=12.0.0')}`)
} catch (e) {
console.log(e)
}
console.log(`Tell the given version '10.13.0', if it's compatible with the constraint '>=12.0.0': ${RuntimeEnvChecker.isVersionCompatible('10.13.0', '>=12.0.0')}, but anyway no error raised here`)
console.log(`Check that the given string is not empty (generic), success: ${RuntimeEnvChecker.checkStringNotEmpty('10.13.0')}`)
console.log(`Node.js environment is: '${process.env.NODE_ENV}'`)
console.log(`Node.js environment from the library is: '${RuntimeEnvChecker.getNodeEnv()}'`)
console.log(`Node.js environment is defined: ${RuntimeEnvChecker.isEnvVarDefined('NODE_ENV')}`)
console.log(`Node.js environment is production: ${RuntimeEnvChecker.isNodeEnvProduction()}`)
// console.log(`Check that Node.js environment is production: ${RuntimeEnvChecker.checkNodeEnvProduction()}`)
console.log('Ensure JavaScript strict mode is enabled (or an Exception will be thrown):')
const checkSafeMode = RuntimeEnvChecker.checkStrictMode()
console.log(`strict mode enabled : ${checkSafeMode}`)
console.log(`No more tests.`)
Look into the example folder for more sample scripts that uses the library (inline but it's the same using it from npm registry).
A sample usage could be to check if current Node.js release satisfies the release wanted, and if not throw an Error (or instead log a Warning).
Requirements
Node.js 14 LTS (14.15.0) or later; NPM 6.8.0 or later.
Sources
Source code is all inside main repo: check-runtime-env.js.
Documentation generated from source code (library API): here.
Note
The library exposes some static methods useful at runtime; for example to check the given version, if it's compatible with an expected version, using the semver syntax for constraints.
Current Node.js version if read from the memory as a default value; NPM version must be retrieved by executing it, so if needed it has to be done by calling related method (could take some time).
The general behavior of check/checker methods here is to throw Error if the check does not pass (if it's false); or return true if successful, or even false
You can find Code Documentation for the API of the library here.
The package name is simplified into 'check-runtime-env', so it will be easier to get it at npm.
See the Semantic Versioning Specification at semver.
More features will be added later to the library.
Contributing
- Fork it ( https://github.com/smartiniOnGitHub/check-runtime-env.js/fork )
- Create your feature branch (git checkout -b my-new-feature)
- Commit your changes (git commit -am 'Add some feature')
- Push to the branch (git push origin my-new-feature)
- Create a new Pull Request
License
Licensed under Apache-2.0.


This switch is provided to help users spot potential
division by zero problems. If this switch is selected, every division
except by a constant will be flagged. (It is assumed that the user is
intelligent enough not to divide by a constant which is equal to zero!)
Default = no.
See also: -portability, -truncation.


Revised: 20 May 2017 (removed defunct and added new items, noted transfers to and from EcoProTem)
All items with serial numbers are identified here. When equipment (>$300 value) that has no serial number is identified, it shall be recorded in here and some form of identification (SA and drivers licence number, or Delta Environmental Consulting) shall be permanently applied to the item.
| Category | Description | Serial Number |
| Camera gear | 1 tripod | n/a |
| Panasonic Lumix semi-SLR digital camera | sn:A6SS02174R | |
| Pentax K10 digital SLR camera and microscope attachments | sn: 2838666 | |
| Communications | 1 x iPhone 4S, 16GB | IMEI:013042005715708 sn:C38H1M99DT9Y |
| Assorted wireless and wired phone handsets | n/a | |
| Computing equipment | HP mini netbook (model 110-3627TU) for field work | sn: 5CB112000T |
| 1x Dell laptop, docking station and separate DVD drive for office | Service Tag 2557YZ1 |
|
| BenQ and AOC flat screen monitors | AOC flat screen 2436Vwh sn:AKQB3HA013495; BenQ flat screen Q7C4 sn:ETG5509937SLO T | |
| HP mini netbook (model 110-3744TU) for laboratory | sn:5CB1221MSG | |
| Canoscan lide 25 scanner | sn: FB6-7200-DB01-02 | |
| Brother MFC-L8600CDW scanner/printer | sn: E73373B7J384214 | |
| Small items; ADSL modem and firewall system, wireless and cabled network hubs, USB hubs etc | n/a | |
| Wacom Sapphire CTE-630 graphic tablet | sn: 3KZ033354 | |
| 2 X iPad mini tablet devices for field work | sn: DLXLM0QGFH12, sn: | |
| Field gear | Horiba U-10 Water Checker | sn: 606046 |
| 1 x Hanna Instruments HI8733 Conductivity meter | sn: 999753 | |
| 1 x Hanna Instruments HI8424 pH meter | sn: 1191739 | |
| Field hydrometer/thermometer kits, assorted | n/a | |
| TPS pocket EC meter | sn: 317 | |
| Binoculars, assorted | n/a | |
| Ciel bat detector model CDB105 | sn: 1050130mo | |
| Digital recorder, Sony ICD-B17 V-O-R | sn: 424103 | |
| Global Water Electronic flow meter for streams, model FP101 | sn: 42591 | |
| Citizen Ecodrive Diving watch model 280183 | sn: 7828-H09971 TA GN-4W-UL | |
| Garmin ETREX global positioning system | sn: 1DG017819 | |
| Assorted nets (plankton, dip, D, kick) | n/a | |
| Pogostick soil corer | n/a | |
| Assorted nylex tanks | n/a | |
| Safety gear | Fire extinguishers (x3) | n/a |
| Vehicle oil spill clean up kit | n/a | |
| Vehicle tool kit | n/a | |
| SPOT-2 personal tracker | ||
| Hi-vis safety cones, men working signs | n/a | |
| First aid kits - to AS2675 (x 3 - lab, office, vehicle) | n/a | |
| Battery powered flashing safety bollard | n/a | |
| WorkZone Safety road traffic control signage | n/a | |
| Safety PPE - overalls, hi-vis vests, safety & sun glasses, hard hats, laboratory PPE, field gear | n/a | |
| Lab equipment | 2 sets NATA calibrated masses | sn: 10304; sn:6903 |
| AND Analytical balance | sn: J8020046 | |
| AND Analytical balance - 4 decimal place | sn: 123101188 | |
| BHD Laboratory Spill Kit | n/a | |
| Bioanalytical Systems benchtop centrifuge, 6 place, model MFC | sn: 416 | |
| Breville fan forced convection oven model CVN30 | n/a | |
| Merck incubator, model 13311 | sn: 102748 | |
| Merck Vega 400 Spectrophotometer | sn: | |
| Merk TR300 Thermoreactor | sn: 01290018 | |
| Merck UV lamp model 13203 | n/a | |
| Sarstedt DESAGA GS100 Microbial air sampler | sn: 02197 | |
| Chateau oven | sn: 100325 | |
| Daewoo variable wattage microwave oven model KOR6305 | sn: KJ93DA0787 | |
| Hach arsenic testing kit cat no 2800000 | lot n: A3076 | |
| Javac vacumn pump model DD40 | sn: B01316 | |
| Laboratory glassware and plastic ware - assorted | n/a | |
| Lovibond natural waters testing kit (Delta kit) with 2 x comparators, multiple disks | sn: 422940 | |
| Maggylamp | sn: 2141 | |
| Namco pressure cooker | n/a | |
| Oxitop IS6 complete BOD system (including induction stirrer, 6 bottles, 6 oxitops etc) | sn: 00130022 | |
| Palintest complete pool test mobile lab kit | n/a | |
| IDEXX Quantitray sealer unit, model 2X | sn: 02139 | |
| RemediAid TPH mobile kit for testing oil in soils, incl AZUR A9310 meter | sn: 225483 | |
| Salter electronic scale | sn: N1932 | |
| Sartorius filter system, type SM 16510/11 (x2) | n/a | |
| Spectroline E series ultraviolet lamp (Spectronic Corp) | sn: 1103322 | |
| Thermo regulated envirochamber for BOD etc | n/a | |
| Thermoline incubator, Type 42300, 142320 | sn:<PHONE_NUMBER>26 | |
| Tyler sieves assorted | many serial numbers | |
| 3 x Viscometers, each engraved with its calibration co-efficient | n/a | |
| Winchester transporter (cane) | n/a | |
| Refrigerator, HiSense | sn: H9C10300BIB | |
| Microscopes | Nikon SMZ10A dissecting scope on diascopic stand | sn: 137309 |
| Nikon Eclipse E600 research scope | sn: 771237 | |
| Nikon drawing tube attachment for SMZ10A, model MNB25400 | sn: 240347 | |
| Nikon camera tube attachment for SMZ10A, custom made | n/a | |
| Kaiser Bass digital microscope for field use (attaches to netbooks) | sn KBA03030000934 | |
| Olympus VE-3 field dissecting microscope | sn: J56007 | |
| Olympus CHS compound microscope (transferred to EcoProTem) | sn: 4M0273 | |
| Olympus drawing attachment for the CHS, model BHZ-DA (transferred to EcoProTem) | sn: 305047 | |
| Olympus camera attachment for the CHS (OM system adapter) (transferred to EcoProTem) | n/a | |
| Maintenance | Assorted non-powered handtools (hammers, pliers, nails, screwdrivers etc) | n/a |
| Battery charger for 12 volt vehicle batteries | n/a | |
| Cordless drill | n/a | |
| Sander | n/a | |
| Nursery & revegetation gear | Hand tools (pottiputke, rakes, spades, shovels, mattocks, picks, hoes, hedge shears, secateurs, trowels, water cans, pots & stands) | n/a |
| Office equipment | Carl A3 rolling cutter model DC-230(A3) | sn: 301178 stamped underneath |
| Epson data projector, model EMP-S1 (transferred to EcoProTem) | sn: FCNG370726F | |
| Fellowes confetti cut shredder PS8OC-2 | sn: 36180-71 (inside) | |
| Ibico ibibaby binding machine | sn: 167967 | |
| Jastek A3 laminator model A3R | n/a | |
| Map magnifiers and steroviewers (10 mag glass, 10x illuminated magnifier and stereoviewer) | n/a | |
| Powertran universal battery charger for all sizes of NiMH batteries | n/a | |
| Office furniture | 3 Laboratory cupboards (dresser type, bookcase type) | n/a |
| 1 Laboratory sink/cupboard | n/a | |
| 3 Laboratory cupboards/benchtops | n/a | |
| 1 Microscope table | n/a | |
| Bookcases x6 | n/a | |
| 2 x Desks - Baltic pine and hardwoods | n/a | |
| LG inverter split system airconditioner model R12AWN (NB10 inside, UB10 outside) | sn: 004KATM00033 (inside); 008KAWQ00409 (outside) | |
| Laboratory stool | n/a | |
| Office swivel chairs (x4) | n/a | |
| Step stool for library | n/a | |
| Security alarm system for lab/office | n/a | |
| Wooden vertical pigeon holes | n/a | |
| Dimplex mobile refrigerative airconditioner model DAC9000 (trans from EcoProTem) | sn: 0129795 | |
| Reference | Professional library (approx 1800 books) | n/a |
| Micocrosoft Windows (ver 10) and MS Office 365 subscription for all computers | n/a | |
| TNTmips GIS software (transferred to EcoProTem) | serial numbers kept with installation disks | |
| AQQA water chemistry software | serial numbers kept with installation disks | |
| A wide variety of data logging, bore logging, chemistry, graphics, mathematics and taxonomic software packages | serial numbers kept with installation disks | |
| Vehicle & camp | Mercedes MB 140D 29 Campervan | Engine number:<PHONE_NUMBER>2173 Registration: S825ABB |
| Tents, mats, sleeping bags and camp kitchen gear |


We connect less privileged yet curious and developing artists with teachers who are willing to offer lessons at a cheaper price!
We believe all people should have an equal access to the arts, regardless of economic classes.
Although lessons are signifciantly cheaper and negotiable prices, we charge a $3.99 per month subscription fee per family. This charge grants you access to our premium database of teachers.


ZIP: 203 Title: Transaction Expiry Owners: Daira Emma Hopwood<EMAIL_ADDRESS>Original-Authors: Jay Graber Status: Final Category: Consensus Created: 2018-01-09 License: MIT
This is a Standards ZIP describing a new consensus rule to set an expiration time after which a transaction cannot be mined. If it is not mined within that time, the transaction will be removed from nodes' mempools.
Transactions that have insufficient fees are often not mined. This indeterminism is a source of confusion for users and wallets. Allowing a transaction to set a block height after which it cannot be mined would provide certainty around how long a transaction has to confirm before it is rejected by the network and must be re-sent.
Advantages include optimizing mempool performance by removing transactions that will not be mined, and potentially simplifying bidirectional payment channels by reducing the need to store and compress revocations for past states, since transactions not committed to the chain could expire and become invalid after a period of time.
If the expiry is at block height \(N\) , then the transaction must be included in block \(N\) or earlier. Block \(N+1\) will be too late, and the transaction will be removed from the mempool.
The new consensus rule will enforce that the transaction will not be considered valid if included in block of height greater than \(N\) , and blocks that include expired transactions will not be considered valid.
Transactions will have a new field, nExpiryHeight
, which will set the block height after which transactions will be removed from the mempool if they have not been mined.
The data type for nExpiryHeight
will be uint32_t
. nExpiryHeight
will never be a UNIX timestamp, unlike nLockTime
values, and thus the maximum expiry height will be 499999999 (but see the exception for coinbase transactions described in Changes for NU5).
Note: a previous version of this ZIP incorrectly specified an interaction between nExpiryHeight
and nLockTime
that was never implemented.
For the example below, the last block that the transaction below could possibly be included in is 3539. After that, it will be removed from the mempool.
"txid": "17561b98cc77cd5a984bb959203e073b5f33cf14cbce90eb32b95ae2c796723f", "version": 3, "locktime": 2089, "expiryheight": 3539,
Default: (Before Blossom) 20 blocks from the current height, or about 50 minutes at 2.5-minute target block spacing. A configuration option can be used to set the user's default.
Minimum: No minimum
Maximum: 499999999, which is about 1185 years from now at 75 seconds/block.
No limit: To set no limit on transactions (so that they do not expire), nExpiryHeight
should be set to 0.
Coinbase: nExpiryHeight
on coinbase transactions is ignored, and is set to 0 by convention.
Every time a transaction expires and should be removed from the mempool, so should all of its dependent transactions.
On Blossom activation 2, the default changes to 40 blocks from the current height, which still represents about 50 minutes at the revised 75-second target block spacing.
As mentioned above, nExpiryHeight
is ignored for coinbase transactions. However, from NU5 activation 3, the nExpiryHeight
field of a coinbase transaction MUST be set equal to the block height. Also, for coinbase transactions only, the bound of 499999999 on nExpiryHeight
is removed. The motivation is to ensure that transaction IDs remain unique, as explained in more detail in a note in Section 7.1 of the protocol specification 4.
With the addition of this feature, zero-confirmation transactions with an expiration block height set will have even less guarantee of inclusion. This means that UIs and services must never rely on zero-confirmation transactions in Zcash.
Wallet should notify the user of expired transactions that must be re-sent.
For Overwinter, transaction expiry will be set to a default that can be overridden by a flag txexpirydelta set in the config file.
-txexpirydelta=
set the number of blocks after which a transaction that has not been mined will become invalid
To view: listtransactions has a new filter attribute, showing expired transactions only:
listtransactions "*" 10 0 "expired"
WalletTxToJSON shows a boolean expired true/false.
The default will be user-configurable with the option txexpirydelta.
--txexpirydelta=100
This feature will be deployed with Overwinter. The activation blockheight proposal is in 1.
| 1 | ZIP 201: Network Peer Management for Overwinter |
|---|
| 2 | ZIP 206: Deployment of the Blossom Network Upgrade |
|---|
| 3 | ZIP 252: Deployment of the NU5 Network Upgrade |
|---|
| 4 | Zcash Protocol Specification, Version 2021.2.16. Section 7.1: Transaction Encoding and Consensus |
|---|


Error: {{ error.message }}
{{loginError}}
The Secret you entered is wrong. Please try again
{{signupError}}
{{ error.message }}


StatiCrypt uses AES-256 with WebCrypto to encrypt your html string with your long password, in your browser (client side).
Download your encrypted string in a HTML page with a password prompt you can upload anywhere (see example).
The tool is also available as a CLI on NPM and is open source on GitHub.

StatiCrypt generates a static, password protected page that can be decrypted in-browser: just send or upload the generated page to a place serving static content (github pages, for example) and you're done: the javascript will prompt users for password, decrypt the page and load your HTML.
The page is encrypted with AES-256 in CBC mode (see why this mode is appropriate for StatiCrypt in #19). The password is hashed with PBKDF2 (599k iterations with SHA-256, plus 1k with SHA-1 for legacy reasons (see #159), for the added recommended total of 600k) and used to encrypt the page.
It basically encrypts your page and puts everything with a user-friendly way to use a
password in the new file. AES-256 is state of the art but
brute-force/dictionary attacks would be easy to do at a really fast pace: use a long,
unusual password!
=> To be safe, we recommend 16+ alphanum characters, and using a password manager like the
open-source Bitwarden.
Feel free to contribute or report any thought to the GitHub project.


{% extends "base.html" %} {% block content %}
| You’ve been invited to join the team {{ teamname }} in the organization {{ organization }} by user {{ inviter | user_reference }}. |
| Join Team |
| If you were not expecting this invitation, you can safely ignore this email. |


Golden Gate Headlands Marathon
Sausaliuto CA/USA
Website: www.envirosports.com
Race Winners (28
runnings)
31
Mar 2007
01 Apr 2006
02
Apr 2005
03
Apr 2004
05
Apr 2003
06
Apr 2002
07
Apr 2001
22
Apr 2000
24
Apr
1999
25
Apr
1998
05
Apr 1997
30
Mar 1996
15
Apr 1995
02
Apr 1994
10
Apr 1993
26 Apr
1992
1991
14
Apr 1990
22 Apr
1989
23 Apr
1988
18
Apr
1987
Notes: 1987 was the inaugural year.
This race is on trails.
25
Mar 2017
3:29:00
Joshua Lerner (CA/USA)
4:09:24
Betsy Platt (OR/USA)
02
Apr 2016
3:36:18
Jobie Williams (TN/USA)
4:25:30
Annika Brakebill (CA/USA)
28
Mar 2015
3:15:01
David Niblack (CA/USA)
4:23:08
Laurel Larsen (CA/USA)
30
Mar 2014
3:33:23
Adam Coates (AUS)
4:29:34
Emilee Goldberg (CA/USA)
06
Apr 2013
3:35:32
Scott Kunz (CA/USA)
4:13:53
Rebekah Adams (CO/USA)
2012
---
not held
---
not held
02
Apr 2011
3:29:25
Raymond
Sanchez-2
4:07:43
Caitlin Johnson (USA)
03
Apr 2010
3:11:06
Brendan Lunty (AB/CAN)
3:42:50
Juliana Cremeans (CA/USA)
04
Apr 2009
4:09:29
Eric Smith (CA/USA)
4:09:53
Nicole Duke (CA/USA)
05
Apr 2008
3:02:39
Dan Dehlin (MI/USA)
5:05:19
Kathy Fleig (OK/USA)
3:29:05
Raymond Sanchez (CA/USA)
3:58:22
Kristi Dowler (USA)
3:22:48
Asker Jeukendrup (AL/USA)
3:39:30
Lauren Kretz (GA/USA)
3:17:00
Tom Brennan (OK/USA)
4:23:59
Lisa Kallio (BC/CAN)
3:22:53
Christopher Mazza (CA/USA)
4:04:11
Maria Johnson (OR/USA)
3:05:40
Justin Coffeen (CA/USA)
3:47:15
Annie Duprey (UT/USA)
3:09:50
Zeus Gallardo (USA)
3:33:40
Julie Greenberg (USA)
3:13:10
Andrew Patel (CA/USA)
3:32:15
Deborah Leyh (CA/USA)
3:25:00
Manish
Desai-2
3:37:07
Hazel Bilbao (CA/USA)
3:13:20
Grant Palmer (CA/USA)
3:34:10
Katie Gengler (CA/USA)
3:36:21
Manish Desai (CA/USA)
4:31:35
Karen White (CA/USA)
3:28:55
Michael Rose (USA)
3:44:05
Sharon Patrick (CA/USA)
3:08:54
Larry Goodman (CA/USA)
3:47:43
Gayla Johnson (CA/USA)
3:17:10
Mike Sweeney (CA/USA)
5:04:16
Jane Colman (CA/USA)
3:27:30
Glenn Sullivan (CA/USA)
4:01:45
Martha Cederstrom (CA/USA)
2:55:38
Anthony Beron (CA/USA)
3:31:35
Charles
Greene-2
4:35:50
Merja Laitinen (FIN)
---
not held
---
not held
4:06:35
Charles Greene (CA/USA)
5:48:05
Paula Beard (CA/USA)
---
not held
---
not held
3:33:54
Michael Duncan (CA/USA)
5:02:10
Pam Neronha (USA)
3:08:14
Damien Xavier Curry (USA)
4:30:26
Debbie Ingram (USA)
Most Wins
(1987-date)
Men
2
Charles Greene (CA/USA)
1990,1992
Manish Desai (CA/USA)
1998.2000
Raymond Sanchez (CA/USA)
2007,2011
Women
No woman has won more than
once.
Prize Money
(ADR qualified runners)
No prize money has been awarded at this race.
Race Time Bias
(sec/km)
Insufficient data to calculate the race time bias.
Competitive Level
(1990-date)
Insufficient data to calculate the competitive level.
Quality Performances
Men No men under 2:20 Women No women under 2:50
Finishers
Year Men Women M+F
2017 21 11 32
2016 21 20 41
2015 29 12 41
2014 26 7 33
2013 20 7 27
2011 23 16 39
2010 18 16 34
2009 13 8 21
2008 22 5 27
2007 22 14 36
2006 28 17 45
2005 37 8 45
2004 31 16 47
2003 37 17 54
2002 31 15 46
2001 21 10 31
2000 33 20 53
1999 21 14 35
1998 5 3 8
1997 14 5 22
1996 13 5 18
1995 8 1 9
1994 13 2 15
1993 10 10
1992 6 3 9
1990 16 2 18
1988 14 7 21
1987 64 12 76
Sums 618 273 891
M/F 2.26
Last Updated on 27 Mar 2017
Contributor: Michelle Ruettinger


Oh My! Suddenly you are no longer in at Startup Institute!
 What will you do?
Your shoes aren't even magical. What are you doing?
Your clicking only manages to attract a pack of hungry wolves.

There's a vending machine in the cave. But you can't see the contents.
In fact, there's only a slot for money and not much else.
You realized you haven't had lunch yet.
Maybe if you put money into the machine it'll give you something to boost your HP.
You eat it and gain HP.
Your current HP is now .
and you end up solving some complex puzzles and collecting all manner of colorful gemstones.
But suddenly...
There's no where to run.
The Fire Fox bites you from behind and you lose 10 HP.
The Fire Fox has eaten you.
You have bested the Fire Fox in battle!
As it fades away it opens up a portal back to Startup Institute.
Apparently weeks have passed and it's time to give your 60 second pitch! At least you'll have a crazy story to tell!


???
Home
About us
Login
Doubts and live sessions
Having a tough time being stuck at home? Not able to find perfect mentors for learning your new hobby? We got you.
All your favorite hobbies and subjects with the perfect mentor for you.
Coding
Programming Languages
Web design and developement
App developement
Fitness
Yoga
Aerobics
Interests
Art and Painting
Music(Vocal)
Dance
Maths
Statistics
Application of Derivatives
Calculas
Mechanical Engineering
Strength of Materials
Mechanics
Manufacturing
Donations
Buy Notes : Digital as well as Handwritten