Template loop expansion tokens are used to insert information about the current template being processed within the context of a template loop into the output stream. Template loop tokens can only be used inside a template loop.
|
Field Loop Token |
Description |
|||||||||||||||||||||||||||
|
<TEMPLATE#> |
Inserts the 1-based index of the current template within the collection of templates. |
|||||||||||||||||||||||||||
|
<TEMPLATE#_ZERO> |
Inserts the 0-based index of the current template within the collection of templates. |
|||||||||||||||||||||||||||
|
<TEMPLATE_ALTNAME> |
Inserts the alternate name. Arrays are represented in Synergy format, for example ALTNAME[1]. If no alternate name is available then the real name is used. Alternates: <template_altname> <Template_Altname> <Template_altname> <TemplateAltname> <templateAltname> |
|||||||||||||||||||||||||||
|
<TEMPLATE_ARRIVEM> |
Inserts the name of the arrive method if present, or by nothing if not. Alternates: <template_arrivem> <Template_Arrivem> <Template_arrivem> <TemplateArrivem> <templateArrivem> |
|||||||||||||||||||||||||||
|
<TEMPLATE_BREAK_MODE> |
Inserts a value indicating whether the template defines a break field, and if so what type of break field. Possible Values: "None", "Change", "Always", "Return" (quotes not inserted) |
|||||||||||||||||||||||||||
|
<TEMPLATE_CHANGEM> |
Inserts the name of the change method if present, or by nothing if not. Alternates: <template_changem> <Template_Changem> <Template_changem> <TemplateChangem> <templateChangem> |
|||||||||||||||||||||||||||
|
<TEMPLATE_CLASS>
|
Inserts the name of the templates class, if present. Only date, time and user-defined templates can have a class assigned.
Possible Values: YYMMDD, YYYYMMDD, YYJJJ, YYYYJJJ, YYPP, YYYYPP, HHMMSS, HHMM, UserAlpha, UserBinary, UserDate, UserNumeric |
|||||||||||||||||||||||||||
|
<TEMPLATE_COL> |
Inserts the screen column for placement of field on the screen in a cell-based environment. If the template has a column position specified then this is used, otherwise the default of column 15 is used. |
|||||||||||||||||||||||||||
|
<TEMPLATE_CUSTOM_CONVERT_FUNCTION>
|
Inserts the name of a custom data conversion function associated with a field., if present. Otherwise inserts nothing. The custom convert function should accept a single parameter which is of the actual data type of the real field, and have a return value which is the custom data type as defined by <TEMPLATE_CUSTOM_DBL_TYPE>.
Developers can specify a custom value via a special token in the fields user text or long description, like this:
CUSTOM_CONVERT_FUNCTION=DivideBy100;
The name of the token MUST be specified in upper case and the value MUST be terminated by a semi-colon, as shown above.
You can test if a field has a custom convert function specified with <IF CUSTOM_CONVERT_FUNCTION>.
For example, if a field is a D5 and you wish to process it as a D5.2 then you might set the following values in the long description:
CUSTOM_DBL_TYPE=D5.2; CUSTOM_SQL_TYPE=DECIMAL(5,2); CUSTOM_CONVERT_FUNCTION=DivideBy100; CUSTOM_STRING_FUNCTION=DivideBy100ToString;
And the custom convert function might look like this:
function DivideBy100, d. required in decimalValue, n proc freturn decimalValue / 100.0 endfunction
|
|||||||||||||||||||||||||||
|
<TEMPLATE_CUSTOM_STRING_FUNCTION> |
Inserts the name of a custom data conversion function associated with a field., if present. Otherwise inserts nothing. The custom convert function should accept a single parameter which is of the actual data type of the real field, and have a return value which is the custom data type as defined by <TEMPLATE_CUSTOM_DBL_TYPE> but formatted appropriately into a string value.
Developers can specify a custom value via a special token in the fields user text or long description, like this:
CUSTOM_STRING_FUNCTION=DivideBy100AsString;
The name of the token MUST be specified in upper case and the value MUST be terminated by a semi-colon, as shown above.
You can test if a field has a custom convert function specified with <IF CUSTOM_STRING_FUNCTION>.
For example, if a field is a D5 and you wish to process it as a D5.2 then you might set the following values in the long description:
CUSTOM_DBL_TYPE=D5.2; CUSTOM_SQL_TYPE=DECIMAL(5,2); CUSTOM_CONVERT_FUNCTION=DivideBy100; CUSTOM_STRING_FUNCTION=DivideBy100ToString;
And the string convert function might look like this:
function DivideBy100ToString, string required in decimalValue, n proc freturn %string(decimalValue/100.0) endfunction
|
|||||||||||||||||||||||||||
|
<TEMPLATE_DEFAULT> |
Inserts the fields default value, if present. |
|||||||||||||||||||||||||||
|
<TEMPLATE_DESC> |
Inserts the description of the field. |
|||||||||||||||||||||||||||
|
<TEMPLATE_DESC_DOUBLE>
|
Inserts the description of the field. If any double quote characters are present in the description they are replaced with a single quote. |
|||||||||||||||||||||||||||
|
<TEMPLATE_DESC_SINGLE>
|
Inserts the description of the field. If any single quote characters are present in the description they are replaced with a double quote. |
|||||||||||||||||||||||||||
|
<TEMPLATE_DISPLAY_LENGTH>
|
If the current field has a non-zero display length specified then that length is inserted, otherwise nothing is inserted.
|
|||||||||||||||||||||||||||
|
<TEMPLATE_DRILLM> |
Inserts the name of the fields drill method if present, or by nothing if not. Alternates: <template_drillm> <Template_Drillm> <Template_drillm> <TemplateDrillm> <templateDrillm> |
|||||||||||||||||||||||||||
|
<TEMPLATE_DRILL_PIXEL_COL> |
Inserts the pixel column for placement of a fields drill button on a form. Example Output: 275 |
|||||||||||||||||||||||||||
|
<TEMPLATE_ENUMBASEVAL>
|
For enumerated fields, inserts the enumerated fields base value. The base value is the value assigned to the first member of the enumeration. For non-enumerated fields nothing is inserted.
Note: This token refers to UI Toolkit enumerated fields, which are numeric fields with an enumeration specified via the "Enumerated?" field on the fields Validation tab. This token does NOT refer to fields whose Type is set to Enum on the Field Definition page. Example Output: 1 |
|||||||||||||||||||||||||||
|
<TEMPLATE_ENUMLENGTH>
|
For enumerated fields, inserts the maximum length of the fields’ enumerated values. For non-enumerated fields nothing is inserted.
Example Output: 12 |
|||||||||||||||||||||||||||
|
<TEMPLATE_ENUMSTEPVAL>
|
For enumerated fields, inserts an enumerated fields step value. The step value is the number that is added to or subtracted from the base value for each of the second and subsequent enumeration members. For non-enumerated fields nothing is inserted.
Note: This token refers to UI Toolkit enumerated fields, which are numeric fields with an enumeration specified via the "Enumerated?" field on the fields Validation tab. This token does NOT refer to fields whose Type is set to Enum on the Field Definition page. Example Output: 1 |
|||||||||||||||||||||||||||
|
<TEMPLATE_ENUMWIDTH>
|
Inserts the pixel width for the maximum length of the fields’ enumerated values. Calculated as the maximum length of the fields enumerated values multiplied by 12 pixels per character. This default character width can be overridden using the -cw command line option. Example Output: 144 |
|||||||||||||||||||||||||||
|
<TEMPLATE_FORMATNAME> |
Inserts the name of the fields Repository format, or nothing if no format is specified. |
|||||||||||||||||||||||||||
|
<TEMPLATE_HEADING> |
Inserts the fields report heading. If no heading exists then the field prompt is used. If no prompt exists then the fields SQL name is used. Array fields will have the element number appended (e.g. Phone #1). |
|||||||||||||||||||||||||||
|
<TEMPLATE_HELPID> |
Inserts the fields help identifier if present. |
|||||||||||||||||||||||||||
|
<TEMPLATE_HYPERM> |
Inserts the name of the fields’ hyperlink method if present, or by nothing if not. Alternates: <template_hyperm> <Template_Hyperm> <Template_hyperm> <TemplateHyperm> <templateHyperm> |
|||||||||||||||||||||||||||
|
<TEMPLATE_INFOLINE> |
Inserts the fields’ information line text if present. |
|||||||||||||||||||||||||||
|
<TEMPLATE_INPUT_JUSTIFICATION>
|
Inserts the input justification of the current field.
Possible Values: Left, Right, Center |
|||||||||||||||||||||||||||
|
<TEMPLATE_INPUT_LENGTH> |
Inserts the maximum number of characters that can be typed into a UI input field representing the current field. •For alpha fields the input length is the same as the field size. •For decimal fields the input length will be one byte longer than the field size if the field allows negative values. •For implied decimal fields the input length will be one byte longer than the field size to allow for the entry of a decimal point, and two bytes longer that the field size if the field allows negative values. •For integer fields the input length is based on the maximum number of bytes that are required in order to be able to enter the maximum value supported by the integer field, but bear in mind that this may allow your user to enter a value larger than that supported by the underlying field. For example, an I1 field which allows negative values is capable of storing values in the range of -128 to 127, so the input length for the field is 4, but when used to constrain the length of a UI field this would allows the user to enter a value in the range -999 to 9999. |
|||||||||||||||||||||||||||
|
<TEMPLATE_LDESC> |
Inserts the fields long description. |
|||||||||||||||||||||||||||
|
<TEMPLATE_LDESC2>
|
Inserts a pre-processed version of the fields long description. The long description is actually an A1800 field, but the repository UI treats is as if it is a [30]A60 array. This token returns a string in which each element of the array that contains data is included in the resulting string, separated by two spaces.
For example, the following array:
LDESC, [30]A60, "Option 1", "", "Option 2", "", "Option 3"
Would cause the following data to be inserted:
Option 1 Option2 Option 3
|
|||||||||||||||||||||||||||
|
<TEMPLATE_LEAVEM> |
Inserts the name of the fields leave method if present, or by nothing if not. Alternates: <template_leavem> <Template_Leavem> <Template_leavem> <TemplateLeavem> <templateLeavem> |
|||||||||||||||||||||||||||
|
<TEMPLATE_MAXVALUE> |
Inserts the maximum value which should be associated with a numeric field. The token should only be used for numeric fields, so you should only use it within an <IF NUMERIC> field loop expression. |
|||||||||||||||||||||||||||
|
<TEMPLATE_MINVALUE> |
Inserts the minimum value which should be associated with a numeric field. The token should only be used for numeric fields, so you should only use it within an <IF NUMERIC> field loop expression. if a field does not allow negative values then a minimum value of 0 will normally be returned. However if the field is also marked as required then a value of 1 is returned. |
|||||||||||||||||||||||||||
|
<TEMPLATE_NAME> |
Inserts the name of the field. Array fields are represented in Synergy real array format, and group fields are represented by a full path. Example Output: ACCOUNT_NUMBER Alternates: <template_name> <Template_Name> <Template_name> <TemplateName> <templateName> |
|||||||||||||||||||||||||||
|
<TEMPLATE_NOECHO_CHAR> |
Inserts the character that should be used to represent each character typed into a field, in place of the actual character (think password fields). If the current field being processed is a "no echo" field then the token will be replaced by the no echo character specified in the repository field definition, or by an asterisk (*) if no character is specified. If the field is not a "no echo" field then the token will be replaced by a null string. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PAINTCHAR>
|
Inserts the paint character that would be used to represent each character if the current field is a paint field. The default paint character is an asterisk (*). |
|||||||||||||||||||||||||||
|
<TEMPLATE_PAINTFIELD>
|
Inserts a string indicating whether the current field is a paint field.
Possible values: Yes No
|
|||||||||||||||||||||||||||
|
<TEMPLATE_PII_TYPE>
|
If a special "PII_TYPE" token has been added to the fields long description or user defined text field then this token extracts the specific type from that token and inserts it into the generated code.
The PII_TYPE token looks like this:
PII_TYPE=type;
The type specified can be anything, and that value is what is inserted by this token. Common examples might be:
PII_TYPE=CREDIT_CARD_NUMBER; PII_TYPE=PHONE_NUMBER; PII_TYPE=SOCIAL_SECUTIRY_NUMBER;
|
|||||||||||||||||||||||||||
|
<TEMPLATE_PIXEL_COL> |
Inserts the pixel column for placement of the field within a UI form. If the field has a column position specified then this is used, otherwise the default of column 15 is used. A default width of 12 pixels per character is used, and this can be overridden using the -cw command line option. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PIXEL_ROW> |
Inserts the pixel row for placement of the field within a UI form. If the field has a row position defined then this is used, otherwise the logical field number (which includes array elements) is used to calculate the default row. A default height of 25 pixels per row is used, and this can be overridden using the -ch command line option. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PIXEL_WIDTH> |
Inserts the pixel width for default sizing of the field when represented as a TextBox. Calculated as the size of the field in characters multiplied by 12 pixels per character. This default character width can be overridden using the -cw command line option. |
|||||||||||||||||||||||||||
|
<TEMPLATE_POSITION_COL>
|
If the field has a field position specified, this token inserts the column position or offset value. Otherwise nothing is inserted. |
|||||||||||||||||||||||||||
|
<TEMPLATE_POSITION_MODE>
|
Inserts the field position mode of the current field.
Possible Values: None, Absolute, Relative |
|||||||||||||||||||||||||||
|
<TEMPLATE_POSITION_ROW>
|
If the field has a field position specified, this token inserts the row position or offset value. Otherwise nothing is inserted. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PRECISION> |
Inserts the precision of an implied-decimal field or an empty string. Only the precision is inserted, with no leading period. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PRECISION0> |
Inserts the precision of an implied-decimal field or 0 for non implied decimal fields.
|
|||||||||||||||||||||||||||
|
<TEMPLATE_PRECISION2> |
Inserts the precision of an implied-decimal field including a leading period, or an empty string. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT> |
Inserts the fields prompt. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT_COL>
|
Inserts the screen column for placement of the prompt on the screen in a character based environment. If the prompt has a column position specified in the repository then that value is used, otherwise the default of column 1 is used.
|
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT_PIXEL_COL>
|
Inserts the pixel column for placement of the prompt on a windows form. If the prompt has a column position specified then this is used, otherwise the default of column 1 is used.
A default width of 12 pixels per character is used, and can be overridden using the -cw command line option. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT_PIXEL_ROW>
|
Inserts the pixel row for placement of the prompt on a windows form. If the prompt has a row position defined then this is used, otherwise the logical field number (which includes array elements) is used to calculate the default row.
A default height of 25 pixels per row is used, and can be overridden using the -ch command line option. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT_PIXEL_WIDTH>
|
Inserts the pixel width for default sizing of the prompt when represented as a label. Calculated as the size of the prompt in characters multiplied by 12 pixels per character. This default character width can be overridden using the -cw command line option. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT_POSITION_COL>
|
If the field has a prompt position specified, this token inserts the column position or offset value. Otherwise nothing is inserted. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT_POSITION_MODE>
|
Inserts the prompt position mode of the current field.
Possible Values: None, Absolute, Relative |
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT_POSITION_ROW>
|
If the field has a prompt position specified, this token inserts the row position or offset value. Otherwise nothing is inserted. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PROMPT_ROW>
|
Inserts the screen row for placement of the prompt on the screen in a character based environment. If the prompt has a row position defined in the repository then that value is used, otherwise the logical field number (which includes array elements) is used to calculate the default row.
|
|||||||||||||||||||||||||||
|
<TEMPLATE_RANGE_MAX> |
Inserts the numeric fields’ maximum value. |
|||||||||||||||||||||||||||
|
<TEMPLATE_RANGE_MIN> |
Inserts the numeric fields’ minimum value. |
|||||||||||||||||||||||||||
|
<TEMPLATE_REGEX> |
Inserts a regular expression that can be used to constrain and validate user input to a field based on the repository definition of the field. The regular expression inserted depends on the type of field.
In the table above, the numbers shown in red are based on the size of the field being processed at the time. Integer FieldsThe regular expression for integer fields will constrain the number of characters entered, and restrict those characters to being numeric characters, but it will NOT restrict the user to only entering valid numeric values. For example, an i1 field can store up to 127, the regular expression will constrain the entry to 3 numeric characters but it will still be possible to enter an out of range value (e.g. 256). Required FieldsCurrently CodeGen only takes a fields "required" status into account for alpha fields. If an alpha field is required then the regular expression produced will require at least one character be present. |
|||||||||||||||||||||||||||
|
<TEMPLATE_REPORT_JUSTIFICATION>
|
Inserts the report justification of the current field.
Possible Values: Left, Right, Center |
|||||||||||||||||||||||||||
|
<TEMPLATE_ROW> |
Inserts the screen row for placement of the field on the screen in a cell based environment. If the field has a row position defined then this is used, otherwise the logical field number (which includes array elements) is used to calculate the default row. |
|||||||||||||||||||||||||||
|
<TEMPLATE_SAMPLE_DATA>
|
Inserts sample date for the field. This token is intended to be used for the generation of examples in documentation or API references.
The token first looks in the long description data for sample data defined like this:
SAMPLE_DATA=123 Main Street;
If found then the value between SAMPLE_DATA= and the semi-colon is inserted. If not found then an appropriate generic value (ABC or 123, etc.) is inserted.
Sample data for alpha variables is surrounded by double quotes.
NOTE: This token only currently works with basic field types alpha, decimal, implied decimal, integer and boolean. For other field types nothing is inserted.
Possible Values: "ABC", 123, 1.23, True, "Sample " |
|||||||||||||||||||||||||||
|
<TEMPLATE_SAMPLE_DATA_NOQUOTES>
|
Inserts sample date for the field. This token is intended to be used for the generation of examples in documentation or API references.
The token first looks in the long description data for sample data defined like this:
SAMPLE_DATA=123 Main Street;
If found then the value between SAMPLE_DATA= and the semi-colon is inserted. If not found then an appropriate generic value (ABC or 123, etc.) is inserted.
Sample data for alpha variables is NOT surrounded by double quotes.<TEMPLATE_SELECTIONS1>
NOTE: This token only currently works with basic field types alpha, decimal, implied decimal, integer and boolean. For other field types nothing is inserted.
Possible Values: ABC, 123, 1.23, True, Sample |
|||||||||||||||||||||||||||
|
<TEMPLATE_SELECTION_COUNT> |
Inserts the number of selection list values that are associated with the field. A value of 0 will be inserted for fields that do not have associated selection lists.
Example: 4
|
|||||||||||||||||||||||||||
|
<TEMPLATE_SELECTIONS> |
If the field has a selection list defined, this token inserts a comma separated and quoted list of the fields’ selection list values, otherwise nothing is inserted. Example: "Red","Green","Blue" |
|||||||||||||||||||||||||||
|
<TEMPLATE_SELECTIONS1> |
If the field has a selection list defined, this token inserts a quoted string containing a pipe (|) delimited list of the fields selection list values, otherwise nothing is inserted. Example: "Red|Green|Blue" |
|||||||||||||||||||||||||||
|
<TEMPLATE_SELECTIONS_COL>
|
If the field has a selection list or selection window and selection column defined, this token inserts the column position for the placement of the selection window. Otherwise nothing is inserted. |
|||||||||||||||||||||||||||
|
<TEMPLATE_SELECTIONS_HEIGHT>
|
If the field has a selection list defined, this token inserts the maximum height in rows that the generated selection window should occupy vertically. Otherwise nothing is inserted. |
|||||||||||||||||||||||||||
|
<TEMPLATE_SELECTIONS_ROW>
|
If the field has a selection list or selection window and selection row defined, this token inserts the row position for the placement of the selection window. Otherwise nothing is inserted. |
|||||||||||||||||||||||||||
|
<TEMPLATE_SELLENGTH> |
Inserts the maximum length of the fields’ selection list values. |
|||||||||||||||||||||||||||
|
<TEMPLATE_SELWND> |
Inserts the name of the selection window associated with the current field, always in uppercase.. If the field does not have a selection window then the token inserts nothing. Bear in mind that if the -ws command line option is being used then CodeGen may have removed the selection window name from the field definition and replaced it with a selection list, based on the selection windows entries. In that case you can use a <SELECTION_LOOP> to process the selections. Alternates: <template_selwnd> <Template_Selwnd> <Template_selwnd> <TemplateSelwnd> <templateSelwnd> Note that in repository the name of a fields selection window can be entered in a mixed case format. The <TEMPLATE_SELWND_ORIGINAL> token allows you to use the name of the selection window exactly as it appears in the repository. |
|||||||||||||||||||||||||||
|
<TEMPLATE_SELWND_ORIGINAL>
|
Inserts the name of the selection window associated with the current field exactly as defined in the repository (might be mixed case). If the field does not have a selection window then the token inserts nothing.
|
|||||||||||||||||||||||||||
|
<TEMPLATE_SIZE> |
Inserts the size of the field in bytes. |
|||||||||||||||||||||||||||
|
<TEMPLATE_PARENT_TEMPLATE> |
Inserts the name of the Repository template from which the field inherited its attributes or by a null string if no template is referenced. |
|||||||||||||||||||||||||||
|
<TEMPLATE_TKSCRIPT> |
Inserts a UI Toolkit .field script file command for the field. |
|||||||||||||||||||||||||||
|
<TEMPLATE_USER_TYPE>
|
For user-defined fields, inserts the fields user defined field type string, if present, otherwise inserts nothing. |
|||||||||||||||||||||||||||
|
<TEMPLATE_UTEXT> |
Inserts the fields’ user-defined text string. |
|||||||||||||||||||||||||||
|
<TEMPLATE_VIEW_LENGTH>
|
If the current field has a non-zero view length specified then that length is inserted, otherwise nothing is inserted.
|
Copyright © 2021 Synergex International, Inc.


Hidden Markov Model (HMM) based on symmetric lambda distribution framework is implemented for the study of return time-series in the financial market. Major features in the S&P500 index, such as regime identification, volatility clustering, and anti-correlation between return and volatility, can be extracted from HMM cleanly. Univariate symmetric lambda distribution is essentially a location-scale family of exponential power distribution. Such distribution is suitable for describing highly leptokurtic time series obtained from the financial market. It provides a theoretically solid foundation to explore such data where the normal distribution is not adequate. The HMM implementation follows closely the book: "Hidden Markov Models for Time Series", by Zucchini, MacDonald, Langrock (2016).
| Version: | 0.4.5 |
| Depends: | R (≥ 3.3.0) |
| Imports: | stats, utils, ecd, optimx, xts (≥ 0.10-0), zoo, moments, parallel, graphics, scales, ggplot2, grid, methods |
| Suggests: | knitr, testthat, depmixS4, roxygen2, R.rsp, shape |
| Published: | 2018-02-28 |
| Author: | Stephen H-T. Lihn [aut, cre] |
| Maintainer: | Stephen H-T. Lihn <stevelihn at gmail.com> |
| License: | Artistic-2.0 |
| URL: | https://ssrn.com/abstract=2979516 |
| NeedsCompilation: | no |
| Materials: | NEWS |
| CRAN checks: | ldhmm results |
| Reference manual: | ldhmm.pdf |
| Vignettes: |
ldhmm: Hidden Markov Model for Financial Time Series and In-Depth Analysis on S&P 500 Index |
| Package source: | ldhmm_0.4.5.tar.gz |
| Windows binaries: | r-devel: ldhmm_0.4.5.zip, r-release: ldhmm_0.4.5.zip, r-oldrel: ldhmm_0.4.5.zip |
| OS X binaries: | r-release: ldhmm_0.4.5.tgz, r-oldrel: ldhmm_0.4.5.tgz |
| Old sources: | ldhmm archive |
Please use the canonical form https://CRAN.R-project.org/package=ldhmm to link to this page.


--- layout: post title: Are you a Sussex Flash developer? date: 2006-10-13 00:00:00 categories: business digital-media interfaces-&-interaction mobile ---
Are you a Sussex Flash developer?: "Future Platforms are running "Flash on the Move" which gives all local Flash designers the chance to show off their talent by designing a Flash Lite business card for a mobile phone. Designers will need to use Flash Lite using a canvas size of 176x220 pixels and a maximum file size of 150k."


--- layout: post status: publish published: true title: Update Table Data in Grails using Ajax Calls author: display_name: Geoff Lane login: admin email<EMAIL_ADDRESS>url: http://www.zorched.net author_login: admin author_email<EMAIL_ADDRESS>author_url: http://www.zorched.net date: '2009-03-27 20:03:54 -0400' date_gmt: '2009-03-28 02:03:54 -0400' categories: - Code - Groovy tags: - ajax - groovy - grails comments: - id: 15451 author: Jay Wagner author_email<EMAIL_ADDRESS>author_url: '' date: '2009-06-19 12:18:05 -0400' date_gmt: '2009-06-19 18:18:05 -0400' content: I have tried this and having trouble getting it to work. Can you post the code files? Thx. - id: 15575 author: Nico author_email<EMAIL_ADDRESS>author_url: '' date: '2009-07-22 15:17:03 -0400' date_gmt: '2009-07-22 21:17:03 -0400' content: works very good.. thanks so much.. - id: 15594 author: guigouz author_email<EMAIL_ADDRESS>author_url: '' date: '2009-08-09 18:45:08 -0400' date_gmt: '2009-08-10 00:45:08 -0400' content: "How about deletes ? can you post an example ?\r\n\r\nthanks" - id: 15648 author: Jimmy Liew author_email<EMAIL_ADDRESS>author_url: http://www.zimliu.com date: '2009-09-16 01:04:11 -0400' date_gmt: '2009-09-16 07:04:11 -0400' content: how to update the table? - id: 16017 author: brzemo author_email<EMAIL_ADDRESS>author_url: '' date: '2009-11-25 09:03:55 -0500' date_gmt: '2009-11-25 15:03:55 -0500' content: Very cool, works awesome, thanks a lot! - id: 18327 author: Mikou author_email<EMAIL_ADDRESS>author_url: '' date: '2013-01-18 07:43:51 -0500' date_gmt: '2013-01-18 13:43:51 -0500' content: "In my case, javascript does not receive the data. I get the following error :\r\nUncaught ReferenceError: e is not defined" ---
Using Ajax for simple forms can offer users a very clean, simple and fast way to input data. I came across a situation recently where I was looking into replacing a document based workflow with an application. The documents themselves contained a series of different kinds of transactions that could have occurred. There were not a set number of any of the types and the user needed a simple way to enter many rows of data.
Grails offers some very easy to use simple Ajax controls. The formRemote tag has an update parameter that can be used to specify a DOM element to update after the form is submitted. This is Ajax in it's simplest form. Submit some data and replace the contents of a DOM element with a partial-page update. This works well if you want to update a div for example. But what if you want to add a row to a table? In the standard update method, you would have to re-render the entire table contents. In many cases that will be fine, but I figured I could do better than that and just render the new row and add it to the table.
{% highlight groovy %} class Account { static transients = ['checksTotal'] static hasMany = [checks:Check]
Date date = new Date()
Double getChecksTotal() { if (! checks) return 0 return checks.inject(0) { current, check-> current + check.amount } }
static mapping = { checks joinTable: false } }
class Check { String name Double amount String checkNumber String reason } {% endhighlight %}
{% highlight groovy %} class AccountController {
def scaffold = true
def postCheck = { def account = Account.get(params.id) if(account) { def check = new Check(params) account.addToChecks(check) if(! account.hasErrors() && account.save()) { render template:'check', bean:check, var:'check' } } } } {% endhighlight %}
The postCheck method calls the render method to render a template and return it as the Ajax response. This template contains the markup for a single Check row.
You can see the check template here: {% highlight xml %}
In this case I definitely don't want to replace the entire node because the first row of my table is actually the form itself. This gives it a very nice look where the data is entered under the appropriate header and then immediately shows up as the following row when the user hits enter.
{% highlight xml %}
| Name | Check # | Amount | Reason |
|---|---|---|---|
Luckily the appendTableRow function is made pretty easy by using the prototype APIs. The event returned to us is an HTML snippet, so in this case we just want to insert that snippet directly into the DOM which is accomplished with the insert prototype function. {% highlight javascript %} function appendTableRow(tableId, e) { $(tableId).down('tbody').down('tr').insert({after: e.responseText}); } {% endhighlight %}
In the end you have a data table that allows for easy, fast updates with almost no hassle.


--- layout: documentation title: CampaignReferenceType ---
Characterizes a reference to a campaign.
| Field Name | Type | Description |
|---|---|---|
| @idrefoptional | QName |
Specifies a globally unique identifier for a cyber threat campaign defined elsewhere. |
| @timestampoptional | dateTime |
In conjunction with the idref, this field may be used to reference a specific version of a campaign defined elsewhere. |
| Names0..1 | NamesType |
Specifies one or more campaign names for a cyber threat campaign defined elsewhere. |


Signals in DMP¶
DMP sends several custom signals through the Django signal dispatcher. The purpose is to allow you to hook into the router’s processing and respond to events that occur in DMP.
Before going further with this section’s examples, be sure to read the standard Django signal documentation. DMP signals are simply additional signals in the same dispatching system, so the following examples should be easy to understand once you know how Django dispatches signals.
Available Signals¶
dmp_signal_pre_process_request
- Triggered just before DMP calls a view’s process_request() method.
dmp_signal_post_process_request
- Triggered just after a view’s process_request() method returns.
dmp_signal_pre_render_template
- Triggered just before DMP renders a Mako template.
dmp_signal_post_render_template
- Triggered just after DMP renders a Mako template.
dmp_signal_redirect_exception
- Triggered when a RedirectException is encountered in the DMP controller.
dmp_signal_internal_redirect_exception
- Triggered when an InternalRedirectException is encountered in the DMP controller.
dmp_signal_register_app
- Triggered just after the DMP template engine registers an app as a DMP app (once per app at server start).
See the function documentation in signals.py for more information about each signal and its kwargs.
Enabling DMP Signals¶
Be sure your settings.py file has the following in it:
TEMPLATES = [
{
'NAME': 'django_mako_plus',
'BACKEND': 'django_mako_plus.MakoTemplates',
'OPTIONS': {
'SIGNALS': True,
...
}
}
]
Signal Receivers¶
The following creates two receivers. The first is called just before the view’s process_request function is called. The second is called just before DMP renders .html templates.
from django.dispatch import receiver
from django_mako_plus import signals, get_template_loader
@receiver(signals.dmp_signal_pre_process_request)
def pre_process_request(sender, request, view_args, view_kwargs, **kwargs):
print('>>> process_request signal received!')
@receiver(signals.dmp_signal_pre_render_template)
def pre_render_template(sender, request, context, template, **kwargs):
print('>>> render_template signal received!')
# let's return a different template to be used - DMP will use this instead of kwargs['template']
tlookup = get_template_loader('myapp')
template = tlookup.get_template('different.html')
The above code should be in a code file that is called during Django initialization, such as apps.py
.


{if empty($searchnum)}
{else}
{/if}
Sorry, your search
{$kw}did not match any documents.
Suggestions:
- Make sure all words are spelled correctly.
- Try different keywords.
- Try more general keywords.
- Try fewer keywords.
-
{loop $searchdata $t}
- {function.date("Y-m-d", $t['time'])} · {$t['title']} {/loop}


|
||||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES |
-omitEncoding
-indentSize 3 -newlines -trimText
parseText
parses the given text as an XML document and
returns the newly created Document.
Pattern
defines the behaviour for pattern in the XSLT
processing model.PerThreadSingleton
is an implementation of the
SingletonStrategy used to provide common factory access to a single object
instance based on an implementation strategy for one object instance per
thread.ProcessingInstruction
defines an XML processing instruction.ProxyDocumentFactory
implements a proxy to a DocumentFactory
which is useful for implementation inheritence, allowing the pipelining of
various factory implementations.
|
||||||||||
| PREV LETTER NEXT LETTER | FRAMES NO FRAMES |


| PERLRECHARCLASS(1) | Perl Programmers Reference Guide | PERLRECHARCLASS(1) |
This manual page discusses the syntax and use of character classes in Perl regular expressions.
A character class is a way of denoting a set of characters in such a way that one character of the set is matched. It's important to remember that: matching a character class consumes exactly one character in the source string. (The source string is the string the regular expression is matched against.)
There are three types of character classes in Perl regular expressions: the dot, backslash sequences, and the form enclosed in square brackets. Keep in mind, though, that often the term "character class" is used to mean just the bracketed form. Certainly, most Perl documentation does that.
Here are some examples:
"a" =~ /./ # Match "." =~ /./ # Match "" =~ /./ # No match (dot has to match a character) "\n" =~ /./ # No match (dot does not match a newline) "\n" =~ /./s # Match (global 'single line' modifier) "\n" =~ /(?s:.)/ # Match (local 'single line' modifier) "ab" =~ /^.$/ # No match (dot matches one character)
Here's a list of the backslash sequences that are character classes. They are discussed in more detail below. (For the backslash sequences that aren't character classes, see perlrebackslash.)
\d Match a decimal digit character. \D Match a non-decimal-digit character. \w Match a "word" character. \W Match a non-"word" character. \s Match a whitespace character. \S Match a non-whitespace character. \h Match a horizontal whitespace character. \H Match a character that isn't horizontal whitespace. \v Match a vertical whitespace character. \V Match a character that isn't vertical whitespace. \N Match a character that isn't a newline. \pP, \p{Prop} Match a character that has the given Unicode property. \PP, \P{Prop} Match a character that doesn't have the Unicode property
\N
"\N", available starting in v5.12, like the dot, matches any character that is not a newline. The difference is that "\N" is not influenced by the single line regular expression modifier (see "The dot" above). Note that the form "\N{...}" may mean something completely different. When the "{...}" is a quantifier, it means to match a non-newline character that many times. For example, "\N{3}" means to match 3 non-newlines; "\N{5,}" means to match 5 or more non-newlines. But if "{...}" is not a legal quantifier, it is presumed to be a named character. See charnames for those. For example, none of "\N{COLON}", "\N{4F}", and "\N{F4}" contain legal quantifiers, so Perl will try to find characters whose names are respectively "COLON", "4F", and "F4".
Digits
"\d" matches a single character considered to be a decimal digit. If the "/a" regular expression modifier is in effect, it matches [0-9]. Otherwise, it matches anything that is matched by "\p{Digit}", which includes [0-9]. (An unlikely possible exception is that under locale matching rules, the current locale might not have "[0-9]" matched by "\d", and/or might match other characters whose code point is less than 256. The only such locale definitions that are legal would be to match "[0-9]" plus another set of 10 consecutive digit characters; anything else would be in violation of the C language standard, but Perl doesn't currently assume anything in regard to this.)
What this means is that unless the "/a" modifier is in effect "\d" not only matches the digits '0' - '9', but also Arabic, Devanagari, and digits from other languages. This may cause some confusion, and some security issues.
Some digits that "\d" matches look like some of the [0-9] ones, but have different values. For example, BENGALI DIGIT FOUR (U+09EA) looks very much like an ASCII DIGIT EIGHT (U+0038), and LEPCHA DIGIT SIX (U+1C46) looks very much like an ASCII DIGIT FIVE (U+0035). An application that is expecting only the ASCII digits might be misled, or if the match is "\d+", the matched string might contain a mixture of digits from different writing systems that look like they signify a number different than they actually do. "num()" in Unicode::UCD can be used to safely calculate the value, returning "undef" if the input string contains such a mixture. Otherwise, for example, a displayed price might be deliberately different than it appears.
What "\p{Digit}" means (and hence "\d" except under the "/a" modifier) is "\p{General_Category=Decimal_Number}", or synonymously, "\p{General_Category=Digit}". Starting with Unicode version 4.1, this is the same set of characters matched by "\p{Numeric_Type=Decimal}". But Unicode also has a different property with a similar name, "\p{Numeric_Type=Digit}", which matches a completely different set of characters. These characters are things such as "CIRCLED DIGIT ONE" or subscripts, or are from writing systems that lack all ten digits.
The design intent is for "\d" to exactly match the set of characters that can safely be used with "normal" big-endian positional decimal syntax, where, for example 123 means one 'hundred', plus two 'tens', plus three 'ones'. This positional notation does not necessarily apply to characters that match the other type of "digit", "\p{Numeric_Type=Digit}", and so "\d" doesn't match them.
The Tamil digits (U+0BE6 - U+0BEF) can also legally be used in old-style Tamil numbers in which they would appear no more than one in a row, separated by characters that mean "times 10", "times 100", etc. (See <http://www.unicode.org/notes/tn21>.)
Any character not matched by "\d" is matched by "\D".
Word characters
A "\w" matches a single alphanumeric character (an alphabetic character, or a decimal digit); or a connecting punctuation character, such as an underscore ("_"); or a "mark" character (like some sort of accent) that attaches to one of those. It does not match a whole word. To match a whole word, use "\w+". This isn't the same thing as matching an English word, but in the ASCII range it is the same as a string of Perl-identifier characters.
Which rules apply are determined as described in "Which character set modifier is in effect?" in perlre.
There are a number of security issues with the full Unicode list of word characters. See <http://unicode.org/reports/tr36>.
Also, for a somewhat finer-grained set of characters that are in programming language identifiers beyond the ASCII range, you may wish to instead use the more customized "Unicode Properties", "\p{ID_Start}", "\p{ID_Continue}", "\p{XID_Start}", and "\p{XID_Continue}". See <http://unicode.org/reports/tr31>.
Any character not matched by "\w" is matched by "\W".
Whitespace
"\s" matches any single character considered whitespace.
Which rules apply are determined as described in "Which character set modifier is in effect?" in perlre.
Any character not matched by "\s" is matched by "\S".
"\h" matches any character considered horizontal whitespace; this includes the platform's space and tab characters and several others listed in the table below. "\H" matches any character not considered horizontal whitespace. They use the platform's native character set, and do not consider any locale that may otherwise be in use.
"\v" matches any character considered vertical whitespace; this includes the platform's carriage return and line feed characters (newline) plus several other characters, all listed in the table below. "\V" matches any character not considered vertical whitespace. They use the platform's native character set, and do not consider any locale that may otherwise be in use.
"\R" matches anything that can be considered a newline under Unicode rules. It can match a multi-character sequence. It cannot be used inside a bracketed character class; use "\v" instead (vertical whitespace). It uses the platform's native character set, and does not consider any locale that may otherwise be in use. Details are discussed in perlrebackslash.
Note that unlike "\s" (and "\d" and "\w"), "\h" and "\v" always match the same characters, without regard to other factors, such as the active locale or whether the source string is in UTF-8 format.
One might think that "\s" is equivalent to "[\h\v]". This is indeed true starting in Perl v5.18, but prior to that, the sole difference was that the vertical tab ("\cK") was not matched by "\s".
The following table is a complete listing of characters matched by "\s", "\h" and "\v" as of Unicode 6.3.
The first column gives the Unicode code point of the character (in hex format), the second column gives the (Unicode) name.  One letter property names can be used in the "\pP" form, with the property name following the "\p", otherwise, braces are required. When using braces, there is a single form, which is just the property name enclosed in the braces, and a compound form which looks like "\p{name=value}", which means to match if the property "name" for the character has that particular "value". For instance, a match for a number can be written as "/\pN/" or as "/\p{Number}/", or as "/\p{Number=True}/". Lowercase letters are matched by the property Lowercase_Letter which has the short form Ll. They need the braces, so are written as "/\p{Ll}/" or "/\p{Lowercase_Letter}/", or "/\p{General_Category=Lowercase_Letter}/" (the underscores are optional). "/\pLl/" is valid, but means something different. It matches a two character string: a letter (Unicode property "\pL"), followed by a lowercase "l".
What a Unicode property matches is never subject to locale rules, and if locale rules are not otherwise in effect, the use of a Unicode property will force the regular expression into using Unicode rules, if it isn't already.
Note that almost all properties are immune to case-insensitive matching. That is, adding a "/i" regular expression modifier does not change what they match. There are two sets that are affected. The first set is "Uppercase_Letter", "Lowercase_Letter", and "Titlecase_Letter", all of which match "Cased_Letter" under "/i" matching. The second set is "Uppercase", "Lowercase", and "Titlecase", all of which match "Cased" under "/i" matching. (The difference between these sets is that some things, such as Roman numerals, come in both upper and lower case, so they are "Cased", but aren't considered to be letters, so they aren't "Cased_Letter"s. They're actually "Letter_Number"s.) This set also includes its subsets "PosixUpper" and "PosixLower", both of which under "/i" match "PosixAlpha".
For more details on Unicode properties, see "Unicode Character Properties" in perlunicode; for a complete list of possible properties, see "Properties accessible through \p{} and \P{}" in perluniprops, which notes all forms that have "/i" differences. It is also possible to define your own properties. This is discussed in "User-Defined Character Properties" in perlunicode.
Unicode properties are defined (surprise!) only on Unicode code points. Starting in v5.20, when matching against "\p" and "\P", Perl treats non-Unicode code points (those above the legal Unicode maximum of 0x10FFFF) as if they were typical unassigned Unicode code points.
Prior to v5.20, Perl raised a warning and made all matches fail on non-Unicode code points. This could be somewhat surprising:
chr(0x110000) =~ \p{ASCII_Hex_Digit=True} # Fails on Perls < v5.20. chr(0x110000) =~ \p{ASCII_Hex_Digit=False} # Also fails on Perls # < v5.20
Even though these two matches might be thought of as complements, until v5.20 they were so only on Unicode code points.
Starting in perl v5.30, wildcards are allowed in Unicode property values. See "Wildcards in Property Values" in perlunicode.
Examples
"a" =~ /\w/ # Match, "a" is a 'word' character. "7" =~ /\w/ # Match, "7" is a 'word' character as well. "a" =~ /\d/ # No match, "a" isn't a digit. "7" =~ /\d/ # Match, "7" is a digit. " " =~ /\s/ # Match, a space is whitespace. "a" =~ /\D/ # Match, "a" is a non-digit. "7" =~ /\D/ # No match, "7" is not a non-digit. " " =~ /\S/ # No match, a space is not non-whitespace. " " =~ /\h/ # Match, space is horizontal whitespace. " " =~ /\v/ # No match, space is not vertical whitespace. "\r" =~ /\v/ # Match, a return is vertical whitespace. "a" =~ /\pL/ # Match, "a" is a letter. "a" =~ /\p{Lu}/ # No match, /\p{Lu}/ matches upper case letters. "\x{0e0b}" =~ /\p{Thai}/ # Match, \x{0e0b} is the character # 'THAI CHARACTER SO SO', and that's in # Thai Unicode class. "a" =~ /\P{Lao}/ # Match, as "a" is not a Laotian character.
It is worth emphasizing that "\d", "\w", etc, match single characters, not complete numbers or words. To match a number (that consists of digits), use "\d+"; to match a word, use "\w+". But be aware of the security considerations in doing so, as mentioned above.
Repeating a character in a character class has no effect; it's considered to be in the set only once.
Examples:
"e" =~ /[aeiou]/ # Match, as "e" is listed in the class. "p" =~ /[aeiou]/ # No match, "p" is not listed in the class. "ae" =~ /^[aeiou]$/ # No match, a character class only matches # a single character. "ae" =~ /^[aeiou]+$/ # Match, due to the quantifier. -------
* There are two exceptions to a bracketed character class matching a single character only. Each requires special handling by Perl to make things work:
'ss' =~ /\A\N{LATIN SMALL LETTER SHARP S}\z/i # Matches 'ss' =~ /\A[aeioust\N{LATIN SMALL LETTER SHARP S}]\z/i # Matches
For this to happen, the class must not be inverted (see "Negation") and the character must be explicitly specified, and not be part of a multi-character range (not even as one of its endpoints). ("Character Ranges" will be explained shortly.) Therefore,
'ss' =~ /\A[\0-\x{ff}]\z/ui # Doesn't match 'ss' =~ /\A[\0-\N{LATIN SMALL LETTER SHARP S}]\z/ui # No match 'ss' =~ /\A[\xDF-\xDF]\z/ui # Matches on ASCII platforms, since # \xDF is LATIN SMALL LETTER SHARP S, # and the range is just a single # element
Note that it isn't a good idea to specify these types of ranges anyway.
"\N{TAMIL LETTER KA}\N{TAMIL VOWEL SIGN AU}" =~ / ^ [\N{TAMIL SYLLABLE KAU}] $ /x;
matches, because "\N{TAMIL SYLLABLE KAU}" is a named sequence consisting of the two characters matched against. Like the other instance where a bracketed class can match multiple characters, and for similar reasons, the class must not be inverted, and the named sequence may not appear in a range, even one where it is both endpoints. If these happen, it is a fatal error if the character class is within the scope of "use re 'strict", or within an extended "(?[...])" class; otherwise only the first code point is used (with a "regexp"-type warning raised).
Special Characters Inside a Bracketed Character Class
Most characters that are meta characters in regular expressions (that is, characters that carry a special meaning like ".", "*", or "(") lose their special meaning and can be used inside a character class without the need to escape them. For instance, "[()]" matches either an opening parenthesis, or a closing parenthesis, and the parens inside the character class don't group or capture. Be aware that, unless the pattern is evaluated in single-quotish context, variable interpolation will take place before the bracketed class is parsed:
$, = "\t| "; $a =~ m'[$,]'; # single-quotish: matches '$' or ',' $a =~ q{[$,]}' # same $a =~ m/[$,]/; # double-quotish: matches "\t", "|", or " "
Characters that may carry a special meaning inside a character class are: "\", "^", "-", "[" and "]", and are discussed below. They can be escaped with a backslash, although this is sometimes not needed, in which case the backslash may be omitted.
The sequence "\b" is special inside a bracketed character class. While outside the character class, "\b" is an assertion indicating a point that does not have either two word characters or two non-word characters on either side, inside a bracketed character class, "\b" matches a backspace character.
The sequences "\a", "\c", "\e", "\f", "\n", "\N{NAME}", "\N{U+hex char}", "\r", "\t", and "\x" are also special and have the same meanings as they do outside a bracketed character class.
Also, a backslash followed by two or three octal digits is considered an octal number.
A "[" is not special inside a character class, unless it's the start of a POSIX character class (see "POSIX Character Classes" below). It normally does not need escaping.
A "]" is normally either the end of a POSIX character class (see "POSIX Character Classes" below), or it signals the end of the bracketed character class. If you want to include a "]" in the set of characters, you must generally escape it.
However, if the "]" is the first (or the second if the first character is a caret) character of a bracketed character class, it does not denote the end of the class (as you cannot have an empty class) and is considered part of the set of characters that can be matched without escaping.
Examples:
"+" =~ /[+?*]/ # Match, "+" in a character class is not special. "\cH" =~ /[\b]/ # Match, \b inside in a character class # is equivalent to a backspace. "]" =~ /[][]/ # Match, as the character class contains # both [ and ]. "[]" =~ /[[]]/ # Match, the pattern contains a character class # containing just [, and the character class is # followed by a ].
Bracketed Character Classes and the "/xx" pattern modifier
Normally SPACE and TAB characters have no special meaning inside a bracketed character class; they are just added to the list of characters matched by the class. But if the "/xx" pattern modifier is in effect, they are generally ignored and can be added to improve readability. They can't be added in the middle of a single construct:
/ [ \x{10 FFFF} ] /xx # WRONG!
The SPACE in the middle of the hex constant is illegal.
To specify a literal SPACE character, you can escape it with a backslash, like:
/[ a e i o u \ ]/xx
This matches the English vowels plus the SPACE character.
For clarity, you should already have been using "\t" to specify a literal tab, and "\t" is unaffected by "/xx".
Character Ranges
It is not uncommon to want to match a range of characters. Luckily, instead of listing all characters in the range, one may use the hyphen ("-"). If inside a bracketed character class you have two characters separated by a hyphen, it's treated as if all characters between the two were in the class. For instance, "[0-9]" matches any ASCII digit, and "[a-m]" matches any lowercase letter from the first half of the ASCII alphabet.
Note that the two characters on either side of the hyphen are not necessarily both letters or both digits. Any character is possible, although not advisable. "['-?]" contains a range of characters, but most people will not know which characters that means. Furthermore, such ranges may lead to portability problems if the code has to run on a platform that uses a different character set, such as EBCDIC.
If a hyphen in a character class cannot syntactically be part of a range, for instance because it is the first or the last character of the character class, or if it immediately follows a range, the hyphen isn't special, and so is considered a character to be matched literally. If you want a hyphen in your set of characters to be matched and its position in the class is such that it could be considered part of a range, you must escape that hyphen with a backslash.
Examples:
[a-z] # Matches a character that is a lower case ASCII letter. [a-fz] # Matches any letter between 'a' and 'f' (inclusive) or # the letter 'z'. [-z] # Matches either a hyphen ('-') or the letter 'z'. [a-f-m] # Matches any letter between 'a' and 'f' (inclusive), the # hyphen ('-'), or the letter 'm'. ['-?] # Matches any of the characters '()*+,-./0123456789:;<=>? # (But not on an EBCDIC platform). [\N{APOSTROPHE}-\N{QUESTION MARK}] # Matches any of the characters '()*+,-./0123456789:;<=>? # even on an EBCDIC platform. [\N{U+27}-\N{U+3F}] # Same. (U+27 is "'", and U+3F is "?")
As the final two examples above show, you can achieve portability to non-ASCII platforms by using the "\N{...}" form for the range endpoints. These indicate that the specified range is to be interpreted using Unicode values, so "[\N{U+27}-\N{U+3F}]" means to match "\N{U+27}", "\N{U+28}", "\N{U+29}", ..., "\N{U+3D}", "\N{U+3E}", and "\N{U+3F}", whatever the native code point versions for those are. These are called "Unicode" ranges. If either end is of the "\N{...}" form, the range is considered Unicode. A "regexp" warning is raised under "use re 'strict'" if the other endpoint is specified non-portably:
[\N{U+00}-\x09] # Warning under re 'strict'; \x09 is non-portable [\N{U+00}-\t] # No warning;
Both of the above match the characters "\N{U+00}" "\N{U+01}", ... "\N{U+08}", "\N{U+09}", but the "\x09" looks like it could be a mistake so the warning is raised (under "re 'strict'") for it.
Perl also guarantees that the ranges "A-Z", "a-z", "0-9", and any subranges of these match what an English-only speaker would expect them to match on any platform. That is, "[A-Z]" matches the 26 ASCII uppercase letters; "[a-z]" matches the 26 lowercase letters; and "[0-9]" matches the 10 digits. Subranges, like "[h-k]", match correspondingly, in this case just the four letters "h", "i", "j", and "k". This is the natural behavior on ASCII platforms where the code points (ordinal values) for "h" through "k" are consecutive integers (0x68 through 0x6B). But special handling to achieve this may be needed on platforms with a non-ASCII native character set. For example, on EBCDIC platforms, the code point for "h" is 0x88, "i" is 0x89, "j" is 0x91, and "k" is 0x92. Perl specially treats "[h-k]" to exclude the seven code points in the gap: 0x8A through 0x90. This special handling is only invoked when the range is a subrange of one of the ASCII uppercase, lowercase, and digit ranges, AND each end of the range is expressed either as a literal, like "A", or as a named character ("\N{...}", including the "\N{U+..." form).
EBCDIC Examples:
[i-j] # Matches either "i" or "j" [i-\N{LATIN SMALL LETTER J}] # Same [i-\N{U+6A}] # Same [\N{U+69}-\N{U+6A}] # Same [\x{89}-\x{91}] # Matches 0x89 ("i"), 0x8A .. 0x90, 0x91 ("j") [i-\x{91}] # Same [\x{89}-j] # Same [i-J] # Matches, 0x89 ("i") .. 0xC1 ("J"); special # handling doesn't apply because range is mixed # case
Negation
It is also possible to instead list the characters you do not want to match. You can do so by using a caret ("^") as the first character in the character class. For instance, "[^a-z]" matches any character that is not a lowercase ASCII letter, which therefore includes more than a million Unicode code points. The class is said to be "negated" or "inverted".
This syntax make the caret a special character inside a bracketed character class, but only if it is the first character of the class. So if you want the caret as one of the characters to match, either escape the caret or else don't list it first.
In inverted bracketed character classes, Perl ignores the Unicode rules that normally say that named sequence, and certain characters should match a sequence of multiple characters use under caseless "/i" matching. Following those rules could lead to highly confusing situations:
"ss" =~ /^[^\xDF]+$/ui; # Matches!
This should match any sequences of characters that aren't "\xDF" nor what "\xDF" matches under "/i". "s" isn't "\xDF", but Unicode says that "ss" is what "\xDF" matches under "/i". So which one "wins"? Do you fail the match because the string has "ss" or accept it because it has an "s" followed by another "s"? Perl has chosen the latter. (See note in "Bracketed Character Classes" above.)
Examples:
"e" =~ /[^aeiou]/ # No match, the 'e' is listed. "x" =~ /[^aeiou]/ # Match, as 'x' isn't a lowercase vowel. "^" =~ /[^^]/ # No match, matches anything that isn't a caret. "^" =~ /[x^]/ # Match, caret is not special here.
Backslash Sequences
You can put any backslash sequence character class (with the exception of "\N" and "\R") inside a bracketed character class, and it will act just as if you had put all characters matched by the backslash sequence inside the character class. For instance, "[a-f\d]" matches any decimal digit, or any of the lowercase letters between 'a' and 'f' inclusive.
"\N" within a bracketed character class must be of the forms "\N{name}" or "\N{U+hex char}", and NOT be the form that matches non-newlines, for the same reason that a dot "." inside a bracketed character class loses its special meaning: it matches nearly anything, which generally isn't what you want to happen.
Examples:
/[\p{Thai}\d]/ # Matches a character that is either a Thai # character, or a digit. /[^\p{Arabic}()]/ # Matches a character that is neither an Arabic # character, nor a parenthesis.
Backslash sequence character classes cannot form one of the endpoints of a range. Thus, you can't say:
/[\p{Thai}-\d]/ # Wrong!
POSIX Character Classes
POSIX character classes have the form "[:class:]", where class is the name, and the "[:" and ":]" delimiters. POSIX character classes only appear inside bracketed character classes, and are a convenient and descriptive way of listing a group of characters.
Be careful about the syntax,
# Correct: $string =~ /[[:alpha:]]/ # Incorrect (will warn): $string =~ /[:alpha:]/
The latter pattern would be a character class consisting of a colon, and the letters "a", "l", "p" and "h".
POSIX character classes can be part of a larger bracketed character class. For example,
[01[:alpha:]%]
is valid and matches '0', '1', any alphabetic character, and the percent sign.
Perl recognizes the following POSIX character classes:
alpha Any alphabetical character (e.g., [A-Za-z]). alnum Any alphanumeric character (e.g., [A-Za-z0-9]). ascii Any character in the ASCII character set. blank A GNU extension, equal to a space or a horizontal tab ("\t"). cntrl Any control character. See Note [2] below. digit Any decimal digit (e.g., [0-9]), equivalent to "\d". graph Any printable character, excluding a space. See Note [3] below. lower Any lowercase character (e.g., [a-z]). print Any printable character, including a space. See Note [4] below. punct Any graphical character excluding "word" characters. Note [5]. space Any whitespace character. "\s" including the vertical tab ("\cK"). upper Any uppercase character (e.g., [A-Z]). word A Perl extension (e.g., [A-Za-z0-9_]), equivalent to "\w". xdigit Any hexadecimal digit (e.g., [0-9a-fA-F]). Note [7].
Like the Unicode properties, most of the POSIX properties match the same regardless of whether case-insensitive ("/i") matching is in effect or not. The two exceptions are "[:upper:]" and "[:lower:]". Under "/i", they each match the union of "[:upper:]" and "[:lower:]".
Most POSIX character classes have two Unicode-style "\p" property counterparts. (They are not official Unicode properties, but Perl extensions derived from official Unicode properties.) The table below shows the relation between POSIX character classes and these counterparts.
One counterpart, in the column labelled "ASCII-range Unicode" in the table, matches only characters in the ASCII character set.
The other counterpart, in the column labelled "Full-range Unicode", matches any appropriate characters in the full Unicode character set. For example, "\p{Alpha}" matches not just the ASCII alphabetic characters, but any character in the entire Unicode character set considered alphabetic. An entry in the column labelled "backslash sequence" is a (short) equivalent.
[[:...:]] ASCII-range Full-range backslash Note Unicode Unicode sequence ----------------------------------------------------- alpha \p{PosixAlpha} \p{XPosixAlpha} alnum \p{PosixAlnum} \p{XPosixAlnum} ascii \p{ASCII} blank \p{PosixBlank} \p{XPosixBlank} \h [1] or \p{HorizSpace} [1] cntrl \p{PosixCntrl} \p{XPosixCntrl} [2] digit \p{PosixDigit} \p{XPosixDigit} \d graph \p{PosixGraph} \p{XPosixGraph} [3] lower \p{PosixLower} \p{XPosixLower} print \p{PosixPrint} \p{XPosixPrint} [4] punct \p{PosixPunct} \p{XPosixPunct} [5] \p{PerlSpace} \p{XPerlSpace} \s [6] space \p{PosixSpace} \p{XPosixSpace} [6] upper \p{PosixUpper} \p{XPosixUpper} word \p{PosixWord} \p{XPosixWord} \w xdigit \p{PosixXDigit} \p{XPosixXDigit} [7]
The similarly named property, "\p{Punct}", matches a somewhat different set in the ASCII range, namely "[-!"#%&'()*,./:;?@[\\\]_{}]". That is, it is missing the nine characters "[$+<=>^`|~]". This is because Unicode splits what POSIX considers to be punctuation into two categories, Punctuation and Symbols.
"\p{XPosixPunct}" and (under Unicode rules) "[[:punct:]]", match what "\p{PosixPunct}" matches in the ASCII range, plus what "\p{Punct}" matches. This is different than strictly matching according to "\p{Punct}". Another way to say it is that if Unicode rules are in effect, "[[:punct:]]" matches all characters that Unicode considers punctuation, plus all ASCII-range characters that Unicode considers symbols.
There are various other synonyms that can be used besides the names listed in the table. For example, "\p{XPosixAlpha}" can be written as "\p{Alpha}". All are listed in "Properties accessible through \p{} and \P{}" in perluniprops.
Both the "\p" counterparts always assume Unicode rules are in effect. On ASCII platforms, this means they assume that the code points from 128 to 255 are Latin-1, and that means that using them under locale rules is unwise unless the locale is guaranteed to be Latin-1 or UTF-8. In contrast, the POSIX character classes are useful under locale rules. They are affected by the actual rules in effect, as follows:
Which rules apply are determined as described in "Which character set modifier is in effect?" in perlre.
Negation of POSIX character classes
A Perl extension to the POSIX character class is the ability to negate it. This is done by prefixing the class name with a caret ("^"). Some examples:
POSIX ASCII-range Full-range backslash Unicode Unicode sequence ----------------------------------------------------- [[:^digit:]] \P{PosixDigit} \P{XPosixDigit} \D [[:^space:]] \P{PosixSpace} \P{XPosixSpace} \P{PerlSpace} \P{XPerlSpace} \S [[:^word:]] \P{PerlWord} \P{XPosixWord} \W
The backslash sequence can mean either ASCII- or Full-range Unicode, depending on various factors as described in "Which character set modifier is in effect?" in perlre.
[= =] and [. .]
Perl recognizes the POSIX character classes "[=class=]" and "[.class.]", but does not (yet?) support them. Any attempt to use either construct raises an exception.
Examples
/[[:digit:]]/ # Matches a character that is a digit. /[01[:lower:]]/ # Matches a character that is either a # lowercase letter, or '0' or '1'. /[[:digit:][:^xdigit:]]/ # Matches a character that can be anything # except the letters 'a' to 'f' and 'A' to # 'F'. This is because the main character # class is composed of two POSIX character # classes that are ORed together, one that # matches any digit, and the other that # matches anything that isn't a hex digit. # The OR adds the digits, leaving only the # letters 'a' to 'f' and 'A' to 'F' excluded.
Extended Bracketed Character Classes
This is a fancy bracketed character class that can be used for more readable and less error-prone classes, and to perform set operations, such as intersection. An example is
/(?[ \p{Thai} & \p{Digit} ])/
This will match all the digit characters that are in the Thai script.
This is an experimental feature available starting in 5.18, and is subject to change as we gain field experience with it. Any attempt to use it will raise a warning, unless disabled via
no warnings "experimental::regex_sets";
Comments on this feature are welcome; send email to<EMAIL_ADDRESS>The rules used by "use re 'strict" apply to this construct.
We can extend the example above:
/(?[ ( \p{Thai} + \p{Lao} ) & \p{Digit} ])/
This matches digits that are in either the Thai or Laotian scripts.
Notice the white space in these examples. This construct always has the "/xx" modifier turned on within it.
The available binary operators are:
& intersection + union | another name for '+', hence means union - subtraction (the result matches the set consisting of those code points matched by the first operand, excluding any that are also matched by the second operand) ^ symmetric difference (the union minus the intersection). This is like an exclusive or, in that the result is the set of code points that are matched by either, but not both, of the operands.
There is one unary operator:
! complement
All the binary operators left associate; "&" is higher precedence than the others, which all have equal precedence. The unary operator right associates, and has highest precedence. Thus this follows the normal Perl precedence rules for logical operators. Use parentheses to override the default precedence and associativity.
The main restriction is that everything is a metacharacter. Thus, you cannot refer to single characters by doing something like this:
/(?[ a + b ])/ # Syntax error!
The easiest way to specify an individual typable character is to enclose it in brackets:
/(?[ [a] + [b] ])/
(This is the same thing as "[ab]".) You could also have said the equivalent:
/(?[[ a b ]])/
(You can, of course, specify single characters by using, "\x{...}", "\N{...}", etc.)
This last example shows the use of this construct to specify an ordinary bracketed character class without additional set operations. Note the white space within it. This is allowed because "/xx" is automatically turned on within this construct.
All the other escapes accepted by normal bracketed character classes are accepted here as well.
Because this construct compiles under "use re 'strict", unrecognized escapes that generate warnings in normal classes are fatal errors here, as well as all other warnings from these class elements, as well as some practices that don't currently warn outside "re 'strict'". For example you cannot say
/(?[ [ \xF ] ])/ # Syntax error!
You have to have two hex digits after a braceless "\x" (use a leading zero to make two). These restrictions are to lower the incidence of typos causing the class to not match what you thought it would.
If a regular bracketed character class contains a "\p{}" or "\P{}" and is matched against a non-Unicode code point, a warning may be raised, as the result is not Unicode-defined. No such warning will come when using this extended form.
The final difference between regular bracketed character classes and these, is that it is not possible to get these to match a multi-character fold. Thus,
/(?[ [\xDF] ])/iu
does not match the string "ss".
You don't have to enclose POSIX class names inside double brackets, hence both of the following work:
/(?[ [:word:] - [:lower:] ])/ /(?[ [[:word:]] - [[:lower:]] ])/
Any contained POSIX character classes, including things like "\w" and "\D" respect the "/a" (and "/aa") modifiers.
Note that "(?[ ])" is a regex-compile-time construct. Any attempt to use something which isn't knowable at the time the containing regular expression is compiled is a fatal error. In practice, this means just three limitations:
Note that skipping white space applies only to the interior of this construct. There must not be any space between any of the characters that form the initial "(?[". Nor may there be space between the closing "])" characters.
Just as in all regular expressions, the pattern can be built up by including variables that are interpolated at regex compilation time. But its best to compile each sub-component.
my $thai_or_lao = qr/(?[ \p{Thai} + \p{Lao} ])/; my $lower = qr/(?[ \p{Lower} + \p{Digit} ])/;
When these are embedded in another pattern, what they match does not change, regardless of parenthesization or what modifiers are in effect in that outer pattern. If you fail to compile the subcomponents, you can get some nasty surprises. For example:
my $thai_or_lao = '\p{Thai} + \p{Lao}'; ... qr/(?[ \p{Digit} & $thai_or_lao ])/;
compiles to
qr/(?[ \p{Digit} & \p{Thai} + \p{Lao} ])/;
But this does not have the effect that someone reading the source code would likely expect, as the intersection applies just to "\p{Thai}", excluding the Laotian. Its best to compile the subcomponents, but you could also parenthesize the component pieces:
my $thai_or_lao = '( \p{Thai} + \p{Lao} )';
But any modifiers will still apply to all the components:
my $lower = '\p{Lower} + \p{Digit}'; qr/(?[ \p{Greek} & $lower ])/i;
matches upper case things. So just, compile the subcomponents, as illustrated above.
Due to the way that Perl parses things, your parentheses and brackets may need to be balanced, even including comments. If you run into any examples, please submit them to <https://github.com/Perl/perl5/issues>, so that we can have a concrete example for this man page.
We may change it so that things that remain legal uses in normal bracketed character classes might become illegal within this experimental construct. One proposal, for example, is to forbid adjacent uses of the same character, as in "(?[ [aa] ])". The motivation for such a change is that this usage is likely a typo, as the second "a" adds nothing.
| 2020-02-11 | perl v5.30.3 |


| Total net profit | -119.3 | Gross profit | 2.42 | Gross loss | -121.72 |
| Profit factor | 0.02 | Expected payoff | -4.11 | ||
| Absolute drawdown | -119.3 | Maximal drawdown (%) | 116.85 (-4769.39%) | ||
| Total trades | 29 | Profit trades (% of total) | 3 (10.34%) | Loss trades (% of total) | 26 (89.66%) |
| Long positions (won %) | 16 (12.5%) | Short positions (won %) | 13 (7.69%) | ||
| Largest | profit trade | 1.9 | loss trade | -10.58 | |
| Average | profit trade | 0.81 | loss trade | -4.68 | |
| Minimum | profit trade | 0.09 | loss trade | -0.31 | |
| Maximum | take profit in pips | 26.8 | stop loss in pips | -37.0 | |
| Average | take profit in pips | 2.9 | stop loss in pips | -21.7 | |
| Minimum | take profit in pips | -7.7 | stop loss in pips | -9.6 | |
| Maximum | Reward-Risk | 2.0 | Duration in minutes | 15770 | |
| Average | Reward-Risk | 0.3 | Duration in minutes | 1486.5 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 0 | |
| Maximum | consecutive wins (profit in money) | 1.0 (0.43) | consecutive losses (loss in money) | 14.0 (-74.33) | |
| Average | consecutive wins | 1.0 | consecutive losses | 4.0 |
| Total net profit | -55.91 | Gross profit | 0.52 | Gross loss | -56.43 |
| Profit factor | 0.01 | Expected payoff | -3.49 | ||
| Absolute drawdown | -55.91 | Maximal drawdown (%) | 51.04 (-1048.05%) | ||
| Total trades | 16 | Profit trades (% of total) | 2 (12.5%) | Loss trades (% of total) | 14 (87.5%) |
| Largest | profit trade | 0.43 | loss trade | -10.58 | |
| Average | profit trade | 0.26 | loss trade | -4.03 | |
| Minimum | profit trade | 0.09 | loss trade | -0.31 | |
| Maximum | take profit in pips | 3.3 | stop loss in pips | -35.4 | |
| Average | take profit in pips | -2.2 | stop loss in pips | -24.1 | |
| Minimum | take profit in pips | -7.7 | stop loss in pips | -9.6 | |
| Maximum | Reward-Risk | 0.2 | Duration in minutes | 8316.0 | |
| Average | Reward-Risk | 0.0 | Duration in minutes | 1459.9 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 22.0 | |
| Maximum | consecutive wins (profit in money) | 1.0 (0.43) | consecutive losses (loss in money) | 7.0 (-23.55) | |
| Average | consecutive wins | 1.0 | consecutive losses | 4.0 |
| Total net profit | -63.39 | Gross profit | 1.9 | Gross loss | -65.29 |
| Profit factor | 0.03 | Expected payoff | -4.88 | ||
| Absolute drawdown | -63.39 | Maximal drawdown (%) | 60.94 (-2487.35%) | ||
| Total trades | 13 | Profit trades (% of total) | 1 (7.69%) | Loss trades (% of total) | 12 (92.31%) |
| Largest | profit trade | 1.9 | loss trade | -9.25 | |
| Average | profit trade | 1.9 | loss trade | -5.44 | |
| Minimum | profit trade | 1.9 | loss trade | -2.45 | |
| Maximum | take profit in pips | 26.8 | stop loss in pips | -37.0 | |
| Average | take profit in pips | 9.2 | stop loss in pips | -18.8 | |
| Minimum | take profit in pips | 3.6 | stop loss in pips | -10.8 | |
| Maximum | Reward-Risk | 2.0 | Duration in minutes | 15770.0 | |
| Average | Reward-Risk | 0.5 | Duration in minutes | 1519.2 | |
| Minimum | Reward-Risk | Duration in minutes | 0.0 | ||
| Maximum | consecutive wins (profit in money) | 1.0 (1.9) | consecutive losses (loss in money) | 8.0 (-46.75) | |
| Average | consecutive wins | 1.0 | consecutive losses | 4.0 |


You’re still broke after “Nothing I Get” hit – Awal launches fresh attack on Fameye
by Nana YawAwal has once again unleashed his venom on Fameye after the latter revealed in an interview that he(Awal) is desperate for fame adding that he has not taken any money from him.
A few days ago, Awal in a self-recorded video revealed that the ‘Nothing I Get’ hitmaker charged him GHC500 to shoot a music video with him but failed to honour his part of the bargain when he got the money.
According to Awal in the video, Fameye verbally attacked him when he was called to come on set to shoot his part pf the video because he is delaying their work.
It seems Awal is still not pleased with Fameye’s response as he has launched a fresh attack on Fameye over their GH500 beef.
According to Awal, Fameye is a greedy artiste who’s still broke despite having a hit song adding that upon all the monies he’s gotten from the shows played, Fameye has not even been able to buy a car and only relies on Uber for commuting around.
See the video below:


{% extends "base.html" %} {% block body %}
In a real environment, you should only deploy your application behind SSL / TLS to avoid having user credentials sent in plain text over the network.
Stormpath user creation is incredibly secure, is not susceptible to any known vulnerabilities (MITM, hashing issues, replay attacks, etc.), and provides you with a number of options to improve security (including built-in email verification, among other things). We will not verify your account by email now, but this can be easily enabled.
Stormpath can also be configured to allow for weaker (or force stronger) passwords, so it can fit into any application workflow.


Top Games
Beat Saber
Beat Saber is a unique VR rhythm game where your goal is to slash the beats (represented by small cubes) as they are coming at you. Every beat indicates which saber you need to...
Vader Immortal
Continue your journey into the heart of Darth Vader's dark fortress in Vader Immortal: A Star Wars VR Series - Episode II.
Read More
Super Hot
No regenerating health bars. No conveniently placed ammo drops. It's just you, outnumbered and outgunned, grabbing the weapons of fallen enemies to shoot, slice, and maneuver through...
Read More
Top Apps
Youtube Vr
Experience your favorite YouTube channels, videos and creators in virtual reality. The YouTube VR app turns every video on the platform into your own virtual reality experience and reimagines YouTube...
Read More
Netflix
Continue your journey into the heart of Darth Vader's dark fortress in Vader Immortal: A Star Wars VR Series - Episode II.
Read More
Virtual Desktop
No regenerating health bars. No conveniently placed ammo drops. It's just you, outnumbered and outgunned, grabbing the weapons of fallen enemies to shoot, slice, and maneuver through...
Read More


Many of the classical object oriented design patterns were conceived
to work around constraints imposed by strictly typed languages without
support for first class functions. In dynamically typed, functional
languages, there are often simpler patterns to achieve the same objectives.
Case Study
Strategy Pattern
“Define a family of algorithms, encapsulate each one, and make
them interchangable. Strategy lets the algorithm vary independently
from clients that use it.” [GoF 315]
Strategy Pattern
Case Study
Approach
Conceptual deep dive
Classical style JavaScript implementation
"Native style" JavaScript implementation
“Favor object composition over class inheritance.”
[GoF 20]
“Program to an interface, not an implementation.
[GoF 18]
Strategy Pattern
Strategy Pattern
Client
// no need to pass strategy into constructor
var fruitList = [new Apple(), new Orange(), new Banana()];
// client can change strategies dynamically
fruitList[0].show = showRollingRight;
fruitList.forEach(function(fruit) {
fruit.show();
});
var orange = new Orange();
// can dynamically change default strategy for entire class
Orange.prototype.show = showSlidingLeft;
orange.show()
// can dynamically use alternate strategy via call/apply
var banana = new Banana();
showRollingRight.apply(banana);
Summary
Primary Differences
point directly to function - no container class or delegation
don't need to instantiate context with strategy
don't need to pass data to strategy algorithm, bind dynamically


Bmod - The Building Modeler
Coders:
Jonathan Falcey
Joseph Lewis
Matthew Rutherford
Notes:
Libraries used in this software are licensed under the Apache, or BSD licenses.


[EDIT]: Faction map has been reset! Hope you all enjoy :D
We'll be resetting the faction map this weekend!
On friday we'll have a massive pvp event!
With the map reset we will also introduce some other changes, we will remove fly from donators, and we will revamp the kits!
-[Co-Owner] Ninjoh
We now got a store on our site! :D Hope you all enjoy, and especially report anything malfunctioning!
-[Co-Owner] Ninjoh
First of all! I'm very happy to announce this new site theme :D! If any bugs or errors are found, please report them to Ninja (me :P)
We have been having some technical issues on the server today though, it'll be closed for the public for a maximum of a couple days :(.
-[Co-Owner] Ninjoh


--- title: Transit Safety author: Gregory Macfarlane date: '2020-06-02' slug: transit-safety categories: [] tags: [] image: caption: '' focal_point: '' ---
I came across this graphic from an APTA Factbook(p. 20) which shows transit with an enormous safety advantage over automobiles. I was curious if I could update the data using information from the Bureau of Transportation Statistics.
knitr::include_graphics("https://i.imgur.com/7txj1aA.png")
First, we want to get passenger miles traveled by different modes. The BTS has this data in an Excel spreadsheet at https://www.bts.gov/content/us-passenger-miles. The data in the spreadsheet is somewhat spotty, and there are plenty of footnotes describing the fact that the sources of the different elements have changed over the years. But let’s go with just data from 2000 onward.
I wanted to read the Excel files directly from the BTS website, but there was just too much cleaning that needed to be done to make them machine-readable in a nice way. You can find the lightly modified spreadsheet I used, including a separate analysis from this one, here
# get Excel file from BTS
passmiles <- read_excel(here("content/post/safety/passmiles.xlsx"),
skip = 1, sheet = "passenger_miles") %>%
filter(!is.na(Mode)) %>%
select(Group, Mode, `2000`:`2018`) %>%
pivot_longer(cols = `2000`:`2018`, names_to = "year", values_to = "passmiles",
names_transform = list(year = as.integer)) %>%
# convert from million miles to miles
mutate( passmiles = passmiles * 1e6 ) %>%
distinct()
The numbers in the data table are given in Millions. To keep our units straight, we are going to use straight miles for now.
ggplot(passmiles, aes(x = year, y = passmiles, label = Mode, color = Mode,
group = str_c(Group, Mode))) +
geom_path() + facet_wrap(~Group, scales = "free_y") +
geom_dl(method = list(dl.trans(x = x + 0.2), "last.points", cex = 0.6)) +
geom_dl(method = list(dl.trans(x = x - 0.2), "first.points", cex = 0.6)) +
scale_x_continuous(limits = c(1995, 2022)) +
scale_color_discrete(guide = FALSE) +
ylab("Passenger Miles") + xlab("Year") +
theme_bw()
The BTS also publishes statistics on fatality broken up by mode at: https://www.bts.gov/content/transportation-fatalities-modea. However, there are a number of potential issues arising from these data. First, transit fatalities are grouped by workers and vehicle occupants, but are not separated by mode. Additionally, there are a number of redundant categories.
fatalities <- read_excel(here("content/post/safety/passmiles.xlsx"),
sheet = "fatalities") %>%
filter(!is.na(Mode)) %>%
select(Group, Mode, `2000`:`2018`) %>%
pivot_longer(cols = `2000`:`2018`, names_to = "year", values_to = "fatalities",
names_transform = list(year = as.integer))
ggplot(fatalities %>% filter(Group %in% c("Air", "Highway", "Rail", "Transit")),
aes(x = year, y = fatalities, label = Mode, color = Mode,
group = str_c(Group, Mode))) +
geom_path() + facet_wrap(~Group, scales = "free_y") +
geom_dl(method = list(dl.trans(x = x + 0.2), "last.points", cex = 0.6)) +
geom_dl(method = list(dl.trans(x = x - 0.2), "first.points", cex = 0.6)) +
scale_x_continuous(limits = c(1995, 2022)) +
scale_color_discrete(guide = FALSE) +
ylab("Fatalities") + xlab("Year") +
theme_bw()
## Warning: Removed 6 row(s) containing missing values (geom_path).
Because the two report tables use different modal definitions, we will consider only group-levels with the following pairs:
miles_summary <- passmiles %>%
# remove bus miles from highway group
filter(!(Group == "Highway" & Mode == "Bus")) %>%
# only keep intercity rail
filter(!(Group == "Rail" %in% c("Light Rail", "Heavy Rail", "Commuter Rail", "All"))) %>%
# remove summary miles from all other groups
filter(!(Group == "Transit" & Mode == "All")) %>%
filter(!(Group == "Highway" & Mode == "All")) %>%
# simplify transit modes into rail and non-rail
mutate(
Mode = case_when(
Group == "Transit" & Mode %in% c("Light Rail", "Heavy Rail", "Commuter Rail") ~ "Rail",
Group == "Transit" ~ "Non-Rail",
Group == "Highway" ~ "All",
Group == "Rail" ~ "All",
Group == "Air" ~ "All",
TRUE ~ Mode
)
) %>%
group_by(Group, Mode, year) %>%
summarise(passmiles = sum(passmiles))
fatalities_summary <- fatalities %>%
mutate(
keep = case_when(
# all air
Group == "Air" & Mode == "All" ~ T,
# all highway but bus
Group == "Highway" & !(Mode %in% c("All", "Bus")) ~ T,
# transit rail and non-rail
Group == "Transit" & Mode %in% c("Non-Rail", "Rail") ~ T,
# passenger rail
Group == "Rail" & Mode == "All" ~ T,
TRUE ~ F
),
Mode = ifelse(Group == "Highway", "All", Mode),
) %>% filter(keep) %>%
group_by(Group, Mode, year) %>%
summarise(fatalities = sum(fatalities))
# remove transit rail fatalities from rail
transit_rail_fatalities <- fatalities_summary %>% filter(Mode == "Rail") %>% pull(fatalities)
fatalities_summary <- fatalities_summary %>%
mutate(
transit_rail_fatalities = transit_rail_fatalities,
fatalities = ifelse(Group == "Rail", fatalities - transit_rail_fatalities, fatalities)
)
Finally, we can join the two datasets together, and compute the fatalities per 100 million miles.
fatal_rate <- left_join(miles_summary, fatalities_summary,
by = c("Group", "Mode", "year")) %>%
mutate(
fatal_rate = fatalities / (passmiles / 1e8) # fatalities per 100 million miles
)
ggplot(fatal_rate, aes(
x = year, y = fatal_rate,
color = str_c(Group, Mode, sep = " "),
label = str_c(Group, Mode, sep = " "),
)) +
geom_path() +
geom_dl(method = list(dl.trans(x = x + 0.2), "last.points", cex = 0.6)) +
geom_dl(method = list(dl.trans(x = x - 0.2), "first.points", cex = 0.6)) +
scale_x_continuous(limits = c(1999, 2019)) +
scale_color_discrete(guide = FALSE) +
ylab("Fatalities per 100 Million Passenger Miles") +
xlab("Year") +
theme_bw()
From my understanding, if a light rail train hits a pedestrian, it counts as a highway fatality and a transit fatality. Given that a large number of the rail fatalities are due to trespassers and at-grade crossings, this may overstate the safety to rail passengers. Also, it double-counts fatalities resulting from a commuter rail train colliding with a private automobile.
My thoughs on the APTA chart:


Welcome
Thank you for stopping by Pat's Salmon Cookies' website. Here at PSC we pride ourselves on creating the most eclectic PNW baked goods for die-hard Cascadians. Why settle for a boring sweet treat when you can flavor it with smoked meat?
Ever since Pat was a child, they admired their grandmother's incredible skill in the kitchen. Grammy Pat would work tirlessly night and day baking sweet confections for friends, family, and community members. Even though every treat was baked with Grammy's love, Pat couldn't ignore the feeling that something was misssing. After almost 30 years of experimentation in the kitchen, Pat has finally discovered the missing ingredient. SMOKED SALMON MEAT!
Now you can safely enjoy the benefit of Pat's decades of trial and error. You really don't want to try past iterations like the gamey squirrel cookies or the chewie salamander cookies, trust us. Salmon is the perfect addition to traditional cookies, delivering a boost of protein, omega-3 fatty acids, and smokey realness. We love these cookies and we're sure you will too!
Locations


AT.ALLOW
Section: Linux Programmer's Manual (5)Updated: Sep 1997
Index Return to Main Contents
NAME
at.allow, at.deny - determine who can submit jobs via at or batchDESCRIPTION
The /etc/at.allow and /etc/at.deny files determine which user can submit commands for later execution via at(1) or batch(1).The format of the files is a list of usernames, one on each line. Whitespace is not permitted.
The superuser may always use at.
If the file /etc/at.allow exists, only usernames mentioned in it are allowed to use at.
If /etc/at.allow does not exist, /etc/at.deny is checked.
SEE ALSO
at(1), atrun(1), cron(8), crontab(1), atd(8).
Index
This document was created by man2html, using the manual pages.
Time: 05:33:59 GMT, December 24, 2015


Brexit party will contest every UK seat if no pact with Tories, says Farage – video
by ReutersNigel Farage has warned Conservatives that if they do not agree to a leave alliance, the Brexit party will ‘make sure every house in the land is informed as to what is in [Johnson’s Brexit] treaty’ and will contest every seat in Britain. His comments came a day after his LBC interview with Donald Trump, in which the US president said Farage and Boris Johnson together would make ‘an unstoppable force’


My name is Sanjog Pokhrel and I'm a Full Stack Web Developer. I currently work at Vantage Health Plan in Monroe, LA as a IT Clinical Web Developer. I'm a hardworking self-driven individual with good communication skill and hands on experience in Application Development. Broadly and deeply knowledgeable in a wide variety of computer languages as well as the principles and techniques of website construction and maintenance.
Responsible for designing, developing, and testing iOS, android, and web app made for Patient/Providers in HealthCare Domain.
Designed, developed, and tested efficient and maintainable software according to the business objectives and needs of the company’s various clients using Java, Angular 4, HTML, CSS, and bootstrap. Involved in developing the applications using Spring Boot for Dependency Injection. Developing the application using Spring MVC Architecture with Hibernate as ORM framework. Used Hibernate Cache for query to improve the application performance.
Provided continued maintenance and development of bug fixes and patch sets for existing web applications and Banner. Diagnosed and troubleshooted UNIX and Windows processing problems and applied solutions to increase company efficiency. Advocated for end-users to perform testing and problem analysis for server, desktop and IT infrastructure work.
Designed, built, tested and deployed a calendar-based display mechanism that utilizes to display independent student, faculty, and administrative schedules. Also, can be viewed based on the student, the faculty, room, class, events, and combination of characteristics. Implemented Material design, and bootstrap to create UI of the program, PHP for the backend and MySQL for database.
View ProjectIndependently built an instant messaging chat server made to communicate locally using Java Multi-Threading program. User can independently communicate with another user without any lag. It can only be used in LAN.
View Project


Select Amount
Order Summary
| Amount | $ {{payment.amount}} |
| Tax | $ {{payment.taxamount}} |
| TOTAL | $ {{payment.totalamount}} |
|---|
Notes
Please note the following:
- If your mesibo services were interrupted due to exceeding credits or free usage limits, it would take a few minutes after the successful payment to restore the service
- You may also pay using wire transfer. Contact us for more details
- Mesibo usage is subject to Terms of Use. By accessing and using Mesibo’s website, software and services, you are agreeing to be bound by Mesibo’s Terms and Conditions of Services and Privacy policy


Before Change
compare = KNeighborsClassifier(n_neighbors=8, algorithm="kd_tree", leaf_size=40, metric="euclidean")
pipe2 = Pipeline([("one_hot_to_categorical", t2), ("KNN", compare)])
train = 2000
X, y = stream.next_instance(train)
pipe.fit(X, y)
After Change
end = timer()
print("Evaluation time: " + str(end-start))
print(str(n_samples) + " samples analyzed.")
print("My performance: " + str(my_corrects/n_samples))
print("Compare performance: " + str(compare_corrects/n_samples))


Zhouxing Liao, Shaffan Mustafa, Madelyn Onweller, Xiaoran Wang Geog 5201 Group Project Instructor: Morteza Karimzadeh
Any adult with a BMI of 30 or higher is considered obese.


— Work experience & Education.
As part of the Digital Lab, and surrounded by other students, I experiment and design for all types of technology, including — VR, AR, Robotics, Mobile — within the fintech industry.
User Research, Experience and Interaction - I prepare and conduct user researches based on different methods (personas, storyboards, user tests, interviews, etc.) analyze the results and design wireframes, prototypes and interactions accordingly.
User Interface - I design user friendly and appealing interfaces based on assumptions, best practices and testing results (if available), always having in mind the target users’ characteristics, needs, cultural background and social environment.
Frontend Design - Sometimes, I also put some CSS3 on it.
**Later edit — The Digital Lab Department became Smart Payments A/S starting with October 2017**
UI/UX & Visual Designer
Nustay A/S
Copenhagen - Denmark
May 2017 - January 2018
User Interface - I designed (from paper sketch to invision prototype) a B2B traveling platform that allows managers to create teams and keep track of each member’s traveling data (bookings, budget, reports, etc.) in a transparent way, with the purpose to cut out time and 3rd parties whenever an employee needs to book a business trip.
Visual Design - - SoMe animated banners, videos, presentation documents, etc.
UI/UX & Visual Designer
Nustay A/S
Copenhagen - Denmark
May 2017 - January 2018
User Interface - I designed (from paper sketch to invision prototype) a B2B traveling platform that allows managers to create teams and keep track of each member’s traveling data (bookings, budget, reports, etc.) in a transparent way, with the purpose to cut out time and 3rd parties whenever an employee needs to book a business trip.
Visual Design - - SoMe animated banners, videos, presentation documents, etc.
UI/UX & Visual Designer
Nustay A/S
Copenhagen - Denmark
May 2017 - January 2018
User Interface - I designed (from paper sketch to invision prototype) a B2B traveling platform that allows managers to create teams and keep track of each member’s traveling data (bookings, budget, reports, etc.) in a transparent way, with the purpose to cut out time and 3rd parties whenever an employee needs to book a business trip.
Visual Design - - SoMe animated banners, videos, presentation documents, etc.
AP Multimedia Design
and Communication
KEA - Københavns Erhvervsakademi
Copenhagen - Denmark
January 2017 - January 2019
User Interface - I designed (from paper sketch to invision prototype) a B2B traveling platform that allows managers to create teams and keep track of each member’s traveling data (bookings, budget, reports, etc.) in a transparent way, with the purpose to cut out time and 3rd parties whenever an employee needs to book a business trip.
Visual Design - - SoMe animated banners, videos, presentation documents, etc.


We're sorry but vue-material-kickstart doesn't work properly without JavaScript enabled. Please enable it to continue.


STORE
CyberPunk
Another action
Something else here
ABOUT
Action
Another action
Something else here
COMMUNITY
Action
Another action
Something else here
SUPPORT
Action
Another action
Something else here
SIGN IN
Action
Another action
Something else here
0
Tonight We Riot
€18.99
Add to cart
Tonight We Riot
€18.99
Add to cart
Tonight We Riot
€18.99
Add to cart
Tonight We Riot
€18.99
Add to cart
Tonight We Riot
€18.99
Add to cart
WARTILE
€5
WARTILE
€5
WARTILE
€5
WARTILE
€5