CSS by Aric
Fred
3 Links to references and at least 8 other CSS commands on this page
http://ww.w3schools.com/cssref
Regular paragraph
This is a paragraph with class="ex". This text is blue.
You should try:
background-image for a textarea
border-color, border-style, width for a div
list-style-image for
or
lists
z-index for overlapping images


Ripvanwinkle wrote:Terra was sold then hacked then hacked...then i email ej when i got him back finally and changed everything told ej he kept getting hacked so only Paypal receits from my paypal would get sw changed it took like 2 months to do
Users browsing this forum: No registered users and 1 guest


| Up | TOC | Index | |||||
| << 7 Included Tools | < 8.30 Prime Numbers | Up: 8 API Reference | 8.32 Hashing Algorithms > | 9 Release Notes >> |
8.31 Flags
8.31.1 Routines
<IP_ADDRESS> which_bit
include std/flags.e namespace flags public function which_bit(object theValue)
tests if the supplied value has only a single bit on in its representation.
Parameters:
- theValue : an object to test.
Returns:
An integer, either 0 if it contains multiple bits, zero bits or is an invalid value, otherwise the bit number set. The right-most bit is position 1 and the leftmost bit is position 32.
Example 1:
? which_bit(2) --> 2 ? which_bit(0) --> 0 ? which_bit(3) --> 0 ? which_bit(4) --> 3 ? which_bit(17) --> 0 ? which_bit(1.7) --> 0 ? which_bit(-2) --> 0 ? which_bit("one") --> 0 ? which_bit(0x80000000) --> 32
<IP_ADDRESS> flags_to_string
include std/flags.e namespace flags public function flags_to_string(object flag_bits, sequence flag_names, integer expand_flags = 0)
returns a list of strings that represent the human-readable identities of the supplied flag or flags.
Parameters:
- flag_bits : Either a single 32-bit set of flags (a flag value), or a list of such flag values. The function returns the names for these flag values.
- flag_names : A sequence of two-element sub-sequences. Each sub-sequence is contains {FlagValue, FlagName}, where FlagName is a string and FlagValue is the set of bits that set the flag on.
- expand_flags: An integer. 0 (the default) means that the flag values in flag_bits are not broken down to their single-bit values. For example: #0c returns the name of #0c and not the names for #08 and #04. When expand_flags is non-zero then each bit in the flag_bits parameter is scanned for a matching name.
Returns:
A sequence. This contains the name or names for each supplied flag value or values.
Comments:
- The number of strings in the returned value depends on expand_flags is non-zero and whether flags_bits is an atom or sequence.
- When flag_bits is an atom, you get returned a sequence of strings, one for each matching name (according to expand_flags option).
- When flag_bits is a sequence, it is assumed to represent a list of atomic flags. That is, {#1, #4} is a set of two flags for which you want their names. In this case, you get returned a sequence that contains one sequence for each element in flag_bits, which in turn contain the matching name or names.
- When a flag's name can not be found in flag_names, this function returns the name of "?".
Example 1:
include std/console.e sequence s s = { {#00000000, "WS_OVERLAPPED"}, {#80000000, "WS_POPUP"}, {#40000000, "WS_CHILD"}, {#20000000, "WS_MINIMIZE"}, {#10000000, "WS_VISIBLE"}, {#08000000, "WS_DISABLED"}, {#44000000, "WS_CLIPPINGCHILD"}, {#04000000, "WS_CLIPSIBLINGS"}, {#02000000, "WS_CLIPCHILDREN"}, {#01000000, "WS_MAXIMIZE"}, {#00C00000, "WS_CAPTION"}, {#00800000, "WS_BORDER"}, {#00400000, "WS_DLGFRAME"}, {#00100000, "WS_HSCROLL"}, {#00200000, "WS_VSCROLL"}, {#00080000, "WS_SYSMENU"}, {#00040000, "WS_THICKFRAME"}, {#00020000, "WS_MINIMIZEBOX"}, {#00010000, "WS_MAXIMIZEBOX"}, {#00300000, "WS_SCROLLBARS"}, {#00CF0000, "WS_OVERLAPPEDWINDOW"}, $ } display( flags_to_string( {#0C20000,2,9,0}, s,1)) --> { --> "WS_BORDER", --> "WS_DLGFRAME", --> "WS_MINIMIZEBOX" --> }, --> { --> "?" --> }, --> { --> "?" --> }, --> { --> "WS_OVERLAPPED" --> } --> } display( flags_to_string( #80000000, s)) --> { --> "WS_POPUP" --> } display( flags_to_string( #00C00000, s)) --> { --> "WS_CAPTION" --> } display( flags_to_string( #44000000, s)) --> { --> "WS_CLIPPINGCHILD" --> } display( flags_to_string( #44000000, s, 1)) --> { --> "WS_CHILD", --> "WS_CLIPSIBLINGS" --> } display( flags_to_string( #00000000, s)) --> { --> "WS_OVERLAPPED" --> } display( flags_to_string( #00CF0000, s)) --> { --> "WS_OVERLAPPEDWINDOW" --> } display( flags_to_string( #00CF0000, s, 1)) --> { --> "WS_BORDER", --> "WS_DLGFRAME", --> "WS_SYSMENU", --> "WS_THICKFRAME", --> "WS_MINIMIZEBOX", --> "WS_MAXIMIZEBOX" --> }


{% blocktrans %}If you send this announcement via email, you will be about to send an email to {{ students }} students.{% endblocktrans %}
{% blocktrans with max_mass_emails_month=course.max_mass_emails_month %}This course can send {{ remain_send_emails }} (of {{ max_mass_emails_month }}) announcements via email this month still.{% endblocktrans %}
{% else %}
{% trans "I'm sorry!" %}
{% blocktrans with max_mass_emails_month=course.max_mass_emails_month %}This course has exceeded the maximum of emails that it can send this month: {{ max_mass_emails_month }}. You have not the option to send this announcement via email {% endblocktrans %}


For the past several years, reader Mike Jennings has spent his time very usefully compiling a reliable list of the works of Dobson. Once a year, at around this time, he updates the list to include those pamphlets to which reference has been made in these pages during the previous twelvemonth. And bang on time, here he is with an additional eight titles. Each has appended to it one of those damnably clever Blötzmann numbers. Please note that, unless otherwise stated, these titles are out of print.
You can find links to earlier lists here.
161. Are There Any Moles In Outer Space? No, There Are Not!
162. On Not Toppling Into Any Of The Many Canals Of Amsterdam
163. How I Hid Under A Table During A Thunderstorm And Ruined My Trousers By Kneeling In A Puddle Of Unaerated Potato Juice, And What This Tells Us About The Human Spirit In Extremis
164. Several Observations On Kathy Kirby, Composed In A Cipher So Baffling That Centuries May Pass Before Anybody Will Be Able To Wring Any Sense From It
165. A Tally Of All The Breakfasts I Have Tucked Into Over The Past Sixteen Years
166. Stringing A Few Words Together To No Apparent Purpose
167. The Blue September Of Conference Pears
168. What I Have To Say, In Toto, About Sops And Fillips


The Emotiv^®^ EPOC+
Although easily modifiable, the MusEEG package is designed to work with the Emotiv^®^ EPOC+. The EPOC+ is an affordable commercial-grade EEG headset that records 14 EEG channels and samples at a rate of 256Hz with 14-bit resolution, with a least significant bit value of approximately 0.51 $\mu$V. The EPOC+ headset proves to be an economically feasible alternative to a medical-grade headset as various studies confirm its viability for noncritical applications.
Data Acquisition
To maximize classification accuracy, the MusEEG package is designed with a train-it-yourself structure, meaning that the end-user will have to train their own ANN model to work with their preferred set of facial or body expressions. Because of the train-it-yourself nature of the package, data was recorded for a single subject only. Six facial expressions were recorded using the Emotiv^®^ PRO application. 80 samples were recorded of the following facial expressions:
-
smile
-
raise eyebrows
-
look left
-
look right
-
neutral
-
scrunch
To expedite recording times, the MusEEG package was designed to allow the user to record all samples of a single facial expression to a single .csv file. The MusEEG package then aids the user through curating and cutting the samples into individual chunks for feature extraction and classification.
During the curation process, the samples were examined for any discontinuities in contact quality, noise, and other artifacts. Samples that appeared to be corrupted with electrode contact discontinuities were discarded, while samples that were clean were stored in the project’s saved chunks directory. From each sample, two different sample chunks were created: a bigChunk (1250ms, 320 samples) for facial expression recognition, and a smallChunk (250ms, 64 samples) for facial expression/no facial expression classification. Examples of a bigChunk and smallChunk can be observed in (Figures 3.2 and 3.3), respectively.
Feature Extraction
Facial Expression Feature Extraction
A feature extraction method similar to the one in [@14] was used. A 4-level wavelet decomposition using Daubechies order-2 (db2) mother wavelet is performed on all 14 channels of the chunk of EEG data.
One advantage of wavelet analysis over other time-frequency distribution methods (e.g. STFT) is that wavelet analysis varies the time-frequency aspect ratio, producing good frequency localization at low frequencies (long time windows) and good time localization at high frequencies (short time windows). This results in a segmentation of the time-frequency plane that will reveal transient features of the signal, which are typically not obvious during Fourier analysis [@14].
Following the wavelet decomposition, the first four statistical moments (mean, variance, skewness, kurtosis) are calculated for each wavelet vector. Since four moments are calculated for each of the 5 wavelet decomposition vectors per EEG channel, a total of 14 x 4 x 5 (280) features are calculated. The data is then normalized using sklearn’s MinMaxScaler. These features are used as an input for the classification models.
Band Power Feature Extraction
The MusEEG system is capable of sending continuous theta (4 - 8 Hz), alpha (8 - 12 Hz), beta (12 - 30 Hz), and gamma (30 - 60 Hz) band power information at a rate of 2Hz.
Before the average band power is calculated, the power spectral density of all of the 14-channel data is calculated using Welch’s periodogram, with a window duration of 0.5s. Once the power spectral density is calculated, the average band power over a certain range of frequencies is found by integrating the power spectral density over the frequency ranges.
Classification
A three-layer Artificial Neural Network (ANN) architecture was used for the classification of the EEG signals. Two models were created: a small model designed to analyze 64-sample chunks and determine whether the chunk contains a facial expression or not (smallBrain), and a large model designed to analyze 320-sample chunks to determine what facial expression is present in the chunk (bigBrain).
The smallBrain model is meant to perform a quick classification of whether a facial expression is present in a 64-sample chunk. The smallBrain model was designed with the intent of having an always-on processor for real-time implementation. By analyzing a chunk with a duration of 250ms, the smallBrain model returns a result fairly quickly, allowing for continuous real-time classification with little latency.
The smallBrain model consists of a three-layer ANN with L1 regularization methods and a sparse categorical cross entropy loss function. During testing, the model exhibited 98.75% accuracy. Its test confusion matrix can be observed in (Figure 3.7) .
The bigBrain model consists of a three-layer ANN with L1_L2 regularization methods and a sparse categorical cross entropy loss function. During testing, the model exhibited 87.04% accuracy. Its test confusion matrix can be observed in (Figure 3.9).


CREATE EXTERNAL SCHEMA
Creates a new external schema in the current database. The owner of this schema is the issuer of the CREATE EXTERNAL SCHEMA command. To transfer ownership of an external schema, use ALTER SCHEMA to change the owner. Use the GRANT command to grant access to the schema to other users or groups.
You can't use the GRANT or REVOKE commands for permissions on an external table. Instead, grant or revoke the permissions on the external schema.
An Amazon Redshift external schema references a database in an external Data Catalog in AWS Glue or in Amazon Athena or a database in an Apache Hive metastore, such as Amazon EMR.
Note
If you currently have Redshift Spectrum external tables in the Athena data catalog, you can migrate your Athena data catalog to an AWS Glue Data Catalog. To use the AWS Glue Data Catalog with Redshift Spectrum, you might need to change your IAM policies. For more information, see Upgrading to the AWS Glue Data Catalog in the Athena User Guide.
All external tables must be created in an external schema. You can't create local tables in external schemas. For more information, see CREATE EXTERNAL TABLE.
External schemas do not support search paths.
To view details for external schemas, query the SVV_EXTERNAL_SCHEMAS system view.
Syntax
CREATE EXTERNAL SCHEMA [IF NOT EXISTS] schema_name FROM { [ DATA CATALOG ] | HIVE METASTORE } DATABASE 'database_name' [ REGION 'aws-region' ] [ URI 'hive_metastore_uri' [ PORT port_number ] ] IAM_ROLE 'iam-role-arn-string' ] [ CATALOG_ROLE 'catalog-role-arn-string' ] [ CREATE EXTERNAL DATABASE IF NOT EXISTS ]
Parameters
- IF NOT EXISTS
-
A clause that indicates that if the specified schema already exists, the command should make no changes and return a message that the schema exists, rather than terminating with an error. This clause is useful when scripting, so the script doesn’t fail if CREATE EXTERNAL SCHEMA tries to create a schema that already exists.
- schema_name
-
The name of the new external schema. For more information about valid names, see Names and Identifiers.
- FROM [ DATA CATALOG ] | HIVE METASTORE
-
A keyword that indicates where the external database is located.
DATA CATALOG indicates that the external database is defined in the Athena data catalog or the AWS Glue Data Catalog.
If the external database is defined in an external Data Catalog in a different AWS Region, the REGION parameter is required. DATA CATALOG is the default.
HIVE METASTORE indicates that the external database is defined in a Hive metastore. If HIVE METASTORE, is specified, URI is required.
- REGION 'aws-region'
-
If the external database is defined in an Athena data catalog or or the AWS Glue Data Catalog, the AWS Region in which the database is located. This parameter is required if the database is defined in an external Data Catalog.
- URI 'hive_metastore_uri' [ PORT port_number ]
-
If the database is in a Hive metastore, specify the URI and optionally the port number for the metastore. The default port number is 9083.
- IAM_ROLE 'iam-role-arn-string'
-
The Amazon Resource Name (ARN) for an IAM role that your cluster uses for authentication and authorization. As a minimum, the IAM role must have permission to perform a LIST operation on the Amazon S3 bucket to be accessed and a GET operation on the Amazon S3 objects the bucket contains. If the external database is defined in an Amazon Athena data catalog or the AWS Glue Data Catalog, the IAM role must have permission to access Athena unless CATALOG_ROLE is specified. For more information, see IAM Policies for Amazon Redshift Spectrum. The following shows the syntax for the IAM_ROLE parameter string for a single ARN.
IAM_ROLE 'arn:aws:iam::
<aws-account-id>
:role/<role-name>
'You can chain roles so that your cluster can assume another IAM role, possibly belonging to another account. You can chain up to 10 roles. For more information, see Chaining IAM Roles in Amazon Redshift Spectrum.
Note
The list of chained roles must not include spaces.
The following shows the syntax for chaining three roles.
IAM_ROLE 'arn:aws:iam::
<aws-account-id>
:role/<role-1-name>
,arn:aws:iam::<aws-account-id>
:role/<role-2-name>
,arn:aws:iam::<aws-account-id>
:role/<role-3-name>
' - CATALOG_ROLE 'catalog-role-arn-string'
-
The Amazon Resource Name (ARN) for an IAM role that your cluster uses for authentication and authorization for the data catalog. If CATALOG_ROLE isn't specified, Amazon Redshift uses the specified IAM_ROLE. The catalog role must have permission to access the Data Catalog in AWS Glue or Athena. For more information, see IAM Policies for Amazon Redshift Spectrum. The following shows the syntax for the CATALOG_ROLE parameter string for a single ARN.
CATALOG_ROLE 'arn:aws:iam::
<aws-account-id>
:role/<catalog-role>
'You can chain roles so that your cluster can assume another IAM role, possibly belonging to another account. You can chain up to 10 roles. For more information, see Chaining IAM Roles in Amazon Redshift Spectrum.
Note
The list of chained roles must not include spaces.
The following shows the syntax for chaining three roles.
CATALOG_ROLE 'arn:aws:iam::
<aws-account-id>
:role/<catalog-role-1-name>
,arn:aws:iam::<aws-account-id>
:role/<catalog-role-2-name>
,arn:aws:iam::<aws-account-id>
:role/<catalog-role-3-name>
' - CREATE EXTERNAL DATABASE IF NOT EXISTS
-
A clause that creates an external database with the name specified by the DATABASE argument, if the specified external database doesn't exist. If the specified external database exists, the command makes no changes. In this case, the command returns a message that the external database exists, rather than terminating with an error.
Note
CREATE EXTERNAL DATABASE IF NOT EXISTS can't be used with HIVE METASTORE.
Usage Notes
For limits when using the Athena data catalog, see Athena Limits in the AWS General Reference.
For limits when using the AWS Glue Data Catalog, see AWS Glue Limits in the AWS General Reference.
These limits don’t apply to a Hive metastore.
Examples
The following example creates an external schema using a database in an Athena data
catalog named sampledb
in the US West (Oregon) Region.
create external schema spectrum_schema from data catalog database 'sampledb' region 'us-west-2' iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
The following example creates an external schema and creates a new external database
named spectrum_db
.
create external schema spectrum_schema from data catalog database 'spectrum_db' iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole' create external database if not exists;
The following example creates an external schema using a Hive metastore database
named hive_db
.
create external schema hive_schema from hive metastore database 'hive_db' uri '<IP_ADDRESS>' port 99 iam_role 'arn:aws:iam::123456789012:role/MySpectrumRole';
The following example chains roles to use the role myS3Role
for
accessing Amazon S3 and uses myAthenaRole
for data catalog access. For more
information, see Chaining IAM Roles in Amazon Redshift Spectrum.
create external schema spectrum_schema from data catalog database 'spectrum_db' iam_role 'arn:aws:iam::123456789012:role/myRedshiftRole,arn:aws:iam::123456789012:role/myS3Role' catalog_role 'arn:aws:iam::123456789012:role/myAthenaRole' create external database if not exists;


Start testing now with your browser's console
Quick Start Developing Compositactic Applications Testing Compositactic Applications
Open your browser's console window and enter the Command Request below.
execute(url)
is a JS function defined in this test page that gets the specified URL and prints the results to
web browser console. The Compositactic LogOn
Command obtains a Session Token used for subsequent commands.
Commands are case-insensitive
execute('LogOn?username=yourUserName&password=yourPassword')
LogOn
returns a response with a Session Token upon successful log on:
{ "sessionToken": "yourSessionTokenHere", "isAuthenticationSuccessful": true, "errorMessage": "", "userName": "yourUserName" }
Incorrectly specified LogOn
Commands, such as this example:
execute('LogOn?username=yourUserName&')
...will return the following response:
{
"success": false,
"errors": [
"MissingParameter: password"
],
"returnValue": null,
"returnValueContentType": null,
"returnValueContentEncoding": null,
"id": 0
}
Use the Session Token returned from the LogOn command to form a Command Request for Commands and Properties on
This example gets the top-level CompositeRoot:
execute('yourSessionTokenHere')
Command Request responses return an array of response objects with the following format. Command Requests containing a single command,
such as those specified in the URL/query-string, return a single response object with an id
of 1. Command Requests
containing multiple Commands have a unique user-assigned integer identifier for each Command:
[ { "success": true, "errors": null, "returnValue": { ... }, "returnValueContentType": null, "returnValueContentEncoding": null, "id": 1 } ]
success
- false
if an unhandled exception occured during Command Request execution, otherwise true
errors
- when an unhandled exception occurs, errors
contains an array of error message strings, otherwise null
returnValue
- the value returned from the Command or Property referenced by the Command Request, or null
returnValueContentType
- for Commands returning a binary (byte[]) value, the MIME content type of the binary valuereturnValueContentEncoding
- the value of the HTTP Content-Encoding header for the returnValue
id
- the user-assigned integer unique identifier specifed to the Command, if multiple Commands are specified in the Command RequestCompositactic accepts Command Requests via HTTP GET or POST automatically, with precedence given to POST requests.
Compositactic also accepts Command Requests in multipart/form-data
format. (multiple file uploads). These
types of Command Requests are only supported with Command Requests containing a single Command.
Compositactic may accept Command Requests containing multiple Commands. Specify multiple Commands using a request to the CompositeRoot:
yourSessionTokenHere
...using a HTTP POST request with the body in the following JSON format. Each CommandPath executes in the order specified:
[ { "CommandPath": "...", "Id": 1 }, { "CommandPath": "...", "Id": 2 }, { "CommandPath": "...", "Id": 3 } ]
CommandPath
- absolute path (from CompositeRoot) to the Command or PropertyId
- a unique integer identifying the Command
A CommandPath may contain a Placeholder which references the return value of a previously executed Command or Property in the Command Request.
CommandPath Placeholders are enclosed in braces { ... }
. The braces contain the Id
of a previously executed Command or Property,
followed by a slash /
, and a Command Path relative to the value returned from the Command specified by the Id
[ { "CommandPath": "MyComposite/SomeOtherComposite", "Id": 1 }, { "CommandPath": "AnotherProperty?{1/SomeOtherPropertyOnSomeOtherComposite}", "Id": 2 }, { "CommandPath": "DoSomething?someParameter={1/SomeOtherPropertyOnSomeOtherComposite}", "Id": 3 } ]
Command Methods are executed by referencing the method name and specifying the parameters in the query string:
yourSessionTokenHere/YourMethod?param1=val1¶m2=val2
Properties values are retrieved by specifying a Command Path to the Property as follows:
yourSessionTokenHere/YourProperty
Properties containing a setter can have their value set as follows:
Set the Property named YourProperty
to the string "myvalue":
yourSessionTokenHere/YourProperty?myvalue
Set the nullable Property named YourProperty
to null:
yourSessionTokenHere/YourProperty?
Set the string
Property named YourProperty
to an empty string:
yourSessionTokenHere/YourProperty?%00
Composites may contain dictionaries containing other Composites. Composites contained in a Composite Dictionary can be accessed by the Composite's Key or its zero-based index.
Get the Composite at index 3:
yourSessionTokenHere/YourContainer/YourDictionary/3
Get the Composite with Key "Composite1":
yourSessionTokenHere/YourContainer/YourDictionary/[Composite1]
/?
appended to a Command Request returns information about the Properties and Commands available on the Composite referenced by the Command Path
execute('yourSessionTokenHere/?')
Help returns information about the available Properties and Commands on the specified Composite. In the Blog example, the Command Request:
yourSessionTokenHere/AllCashiers/?
...returns the available Properties and Commands on the Shop Composite's AllRegisters Property:
[ { "success": true, "errors": null, "returnValue": { "properties": [ { "helpText": null, "propertyEnumValues": null, "propertyName": "Registers", "propertyType": "CT.ReadOnlyCompositeDictionary<System.Int64, CT.Test.Presentation.Shops.Registers.RegisterComposite>", "isReadOnly": true }, { "helpText": "The path to the Composite relative to the CompositeRoot", "propertyEnumValues": null, "propertyName": "Path", "propertyType": "System.String", "isReadOnly": true } ], "commands": [ { "helpText": "Loads Cashier, Register, and Product data for the Shop", "commandName": "CreateNewRegister", "parameters": [], "returnType": "CT.Test.Presentation.Shops.Registers.RegisterComposite", "returnTypeHelp": "Returns 1 on success" }, { "helpText": null, "commandName": "ReloadRegisters", "parameters": [], "returnType": "System.Void", "returnTypeHelp": null } ] }, "returnValueContentType": null, "returnValueContentEncoding": null, "id": 1 } ]
properties
- array of available Composite PropertieshelpText
- description of the PropertypropertyEnumValues
- if Property is a enum
, array of valid valuespropertyName
- name of the PropertypropertyType
- data type of the PropertyisReadOnly
- true
if Property is read-onlycommands
- array of available Composite CommandshelpText
- description of the PropertycommandName
- name of the Commandparameters
- array of required Command parametersparameterName
- helpText
- parameterType
- parameterEnumValues
- Compositactic servers can push data to web applications when Composites are added/removed from Composite Dictionaries, when Property values are changed, and when any other user-defined event occurs. Compositactic uses the W3C Server-sent events standard as the protocol for sending events.
getEvents(url)
is a JS function defined in this test page that sets up an EventSource
object that receives
Composite Events.
function getEvents(eventUrl) { var eventSource = new EventSource(eventUrl); eventSource.onmessage = function (e) { console.log('Event received: ' + e.data); } return true; }
getEvents(url)
is invoked once on the Composite Root:
getEvents('yourSessionTokenHere/event')
getEvents(url)
echos the received event data contained in e.data
to the web browser console:
{"Path":"/Name","EventType":"Change","Data":"testvalue"}
Path
- the Command Path relative to the Composite Root
Data
- the scalar value or JSON object associated with the event.
EventType
contains one of the following:
Listening
- Event stream has openedAdd
- New Composite has been added to the Composite Dictionary referenced in Path
Remove
- Composite has been removed from the Composite Dictionary referenced in Path
Change
- Composite Property referenced by Path
has changed to the value in Data
Rename
- Composite Key referenced by the Composite in Path
has changedLogOff
- Session is expiringCustom
- User-defined event occuredCompositactic serves files from a public and a private directory. The public directory for is accessible from:
The private directory requires a Session Token, and is accessable from:
yourSessionTokenHere/~/
Compositactic (abbreviated "CT") is a .NET Core package for building view-independent applications/services using Composites.
The name "Compositactic" comes from two words - Composite and Tactical.
CT consists of the .NET Core CT Package for creating applications based on Composites, and development tactics for creating optimally maintainable applications of any size.
The philosophy of CT states that complex software systems are best understood and realized as a layered part-whole hierarchy. The "parts" of a CT solution correspond to user-identifiable items-of-interest within the solution design scope. Each of those "parts" relates to a containing (or parent) part, and this parent part manages the immediate child parts.
Example: A customer order contains many line items, along with an invoice.
The bold items identifies the aforementioned "parts"; items-of-interest that our CT solution wishes to create, track, and/or process. CT refers to these "parts" as Composites. The hierarchy of these Composites form a tree structure, with a special Composite at the root of the Composite tree, called the Composite Root. Users access the Composite tree starting from the Composite Root. Each Composite contains a reference to its parent Composite.
The hierarchies can be of any depth and size. The developer/architect designing the CT solution chooses the scope of the hierarchy, which can represent entire applications or even whole business domains.
Composites are represented by .NET classes.
CT solutions typically contain four layers and each layer is confined to its own .NET class library assembly. CT layers are an implementation of the Model-View-Presenter pattern or as it is often referred to, the Model-View-ViewModel pattern.
CT contains an example called "Shop" - a simplified implementation of each of the CT layers, contained in four class class library projects. The Shop example will be referenced in this documentation, and CT also uses the Shop example for its unit tests.
To help highlight the Composite hierarchical structure of the CT Solution, project code files are organized into nested folders that mirror the Composite's actual parent-child relationships. The Model, Presentation, and Presentation Services layers' projects should use this same project folder structure.
The Shop example implements a retail outlet. In our simplified data model, a Shop consists of Products for sale, several Register terminals, and Cashiers. A Register can record a Sale during a designated Period. The Sale contains LineItem(s).
The Shop Model layer establishes this project folder structure, following the data model described above:
Shops/ folder |__ Cashiers/ folder | |__ PersonnelInfos/ folder | |__ PersonnelInfo.cs Composite Model class | |__ Cashier.cs Composite Model class | |__ Authority.cs Supporting file for Cashiers |__ Products/ folder | |__ Product.cs Composite Model class | |__ ProductUnit.cs Supporting file for Products |__ Registers/ folder | |__ Periods/ folder | |__ Sales/ folder | |__ LineItems/ folder | |__ LineItem.cs Composite Model class | |__ Sale.cs Composite Model class | |__ Period.cs Composite Model class | |__ Register.cs Composite Model class |__ Shop.cs Composite Model class
The CT Model layer is the data model of the CT solution. The classes represent the lowest-level state of the "parts" in the CT solution. CT Model layer classes follow these design criteria:


About Wellness
About Wellness Ohio
Welcome to About Wellness Ohio Register - Personal Information
First Name:
Middle Initial:
Last Name:
Street Address:
Apt/Suite/Unit:
City:
State:
Ohio
Texas
California
Zip Code:
Phone Number:
Email:
Best Contact:
Phone
Email
Home
Next
For security reasons, at any time you return to the Home Menu your account will be logged out of this tablet.


|
SoundFontInfoLib
2.21.6
Library for parsing and rendering SF2 files
|
Generator state values for a rendering voice. More...
#include <State.hpp>
Public Types | |
| enum | LoopingMode { none = 0 , continuously = 1 , duringKeyPress = 3 } |
| These are values for the sampleModes (#54) generator. More... | |
| using | Amount = Entity::Generator::Amount |
| using | Index = Entity::Generator::Index |
| using | Definition = Entity::Generator::Definition |
Public Member Functions | |
| State (double sampleRate, const MIDI::Channel &channel, int key, int velocity) | |
| Mock constructor – only used in unit tests. More... | |
| State (double sampleRate, const MIDI::Channel &channel, const Setup &setup) | |
| Create new state vector with a given sample rate. More... | |
| void | setValue (Index index, int value) |
| Set a generator value. More... | |
| void | adjustValue (Index index, int value) |
| Set a generator's adjustment value. More... | |
| void | addModulator (const Entity::Modulator::Modulator &modulator) |
| Install a modulator. More... | |
| double | modulated (Index index) const |
| Obtain a generator value after applying any registered modulators to it. More... | |
| int | unmodulated (Index index) const |
| Obtain a generator value without any modulation applied to it. More... | |
| double | pitch () const |
| int | key () const |
| int | velocity () const |
| int | eventKey () const |
| int | eventVelocity () const |
| double | keyedVolumeEnvelopeHold () const |
| double | keyedVolumeEnvelopeDecay () const |
| double | keyedModulatorEnvelopeHold () const |
| double | keyedModulatorEnvelopeDecay () const |
| double | sustainLevelVolumeEnvelope () const |
| double | sustainLevelModulatorEnvelope () const |
| LoopingMode | loopingMode () const |
| const MIDI::Channel & | channel () const |
| double | sampleRate () const |
Generator state values for a rendering voice.
These are the values from generators. There is the initial state which is the default values. Next, there are instrument generators from the zones that match the MIDI key/velocity values of a MIDI event. These can override any default values. Finally, there are the preset generators which refine any values by adding to them. Note that not all generators are available for refining. Those that are return true from Generator::Definition::isAvailableInPreset
.
|
inline |
Mock constructor – only used in unit tests.
| State::State | ( | double | sampleRate, |
| const MIDI::Channel & | channel, | ||
| const Setup & | setup | ||
| ) |
Create new state vector with a given sample rate.
| sampleRate | the sample rate of audio being rendered |
| channel | the MIDI channel that is in control |
| setup | the voice configuration to use |
References SF2::Render::Voice::Setup::apply().
| void State::addModulator | ( | const Entity::Modulator::Modulator & | modulator | ) |
Install a modulator.
| modulator | the modulator to install |
References SF2::Entity::Modulator::Modulator::generatorDestination(), SF2::Entity::Modulator::Modulator::hasGeneratorDestination(), and SF2::Entity::Generator::indexValue().
|
inline |
Set a generator's adjustment value.
Instrument zones set generator values; preset zones set their adjustments. It can be set twice, once by a global preset generator setting, and again by a non-global preset generator setting.
| index | the generator to set |
| value | the value to use |
References SF2::Logger::debug(), SF2::Entity::Generator::Definition::definition(), and SF2::Entity::Generator::Definition::name().
|
inline |
|
inline |
Referenced by key().
|
inline |
Referenced by velocity().
|
inline |
|
inline |
Referenced by SF2::Render::Envelope::Generator::Modulator().
|
inline |
Referenced by SF2::Render::Envelope::Generator::Modulator().
|
inline |
Referenced by SF2::Render::Envelope::Generator::Volume().
|
inline |
Referenced by SF2::Render::Envelope::Generator::Volume().
|
inline |
References unmodulated().
|
inline |
Obtain a generator value after applying any registered modulators to it.
Due to the modulation calculations this returns a floating-point value, but the value has not been converted from/into any particular units and should still reflect the definitions found in the spec.
| index | the index of the generator |
Referenced by SF2::Render::Envelope::Generator::Modulator(), pitch(), SF2::Render::Sample::PitchControl::PitchControl(), SF2::Render::Voice::Voice::render(), and SF2::Render::Envelope::Generator::Volume().
|
inline |
References key(), and modulated().
|
inline |
Referenced by SF2::Render::Envelope::Generator::Modulator(), and SF2::Render::Envelope::Generator::Volume().
|
inline |
Set a generator value.
Instrument zones set generator values; preset zones set their adjustments. It can be set twice, once by a global instrument generator setting, and again by a non-global instrument generator setting.
| index | the generator to set |
| value | the value to use |
References SF2::Logger::debug(), SF2::Entity::Generator::Definition::definition(), and SF2::Entity::Generator::Definition::name().
|
inline |
Referenced by SF2::Render::Envelope::Generator::Modulator().
|
inline |
Referenced by SF2::Render::Envelope::Generator::Volume().
|
inline |
Obtain a generator value without any modulation applied to it.
This is the original result from the zone generator definitions and so it is expressed as an integer. Most of the time, the modulated
method is what is desired in order to account for any MIDI controller values.
| index | the index of the generator |
Referenced by SF2::Render::Sample::Bounds::Bounds(), key(), loopingMode(), and velocity().
|
inline |
References eventVelocity(), and unmodulated().


A Jekyll template for publishing single-page websites and articles that are incredibly readable and fully responsive
Nice, clean, reading!
Good clean read is set up with readability first in mind. Whatever you want to communicate here can be read easily, and without distraction. Of course, it’s fully responsive, which means people can read it naturally on any phone, or tablet. Write it in markdown in index.md
and get a beautifully published piece.
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
“Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
With footnotes too!
Back up your stuff with solid, clean citations. Footnotes can be written in markdown and appear like this.1 Use as many as you like.2
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.

Add this at the bottom, or the top, or between every other paragraph if you’re desprate for social validation.
Just remember to customize the buttons to fit your url in the _includes/sharing.html
file. These buttons are made available and customizable by the good folks at kni-labs. See the documentation at https://github.com/kni-labs/rrssb for more information.
Font awesome is also included
Now you can use all the cool icons you want! Font Awesome is indeed awesome.  No problem, just disable it in the config.yml
file, and it won’t be loaded.
- you can make lists...
- with cool icons like this,
- even ones that move!
If you need them, you can stick any of the 605 icons anywhere, with any size you like. (See documentation)
Add images to make your point
Images play nicely with this template as well. Add diagrams or charts to make your point, and the template will fit them in appropriately.
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
Thanks to Shu Uesengi for inspiring and providing the base for this template with his excellent work, solo.


“Let us start our investigation of finite rank perturbations of self-adjoint operators with the simplest sort of perturbation—a rank one bounded perturbation. Let A be a self-adjoint (perhaps unbounded) operator in the Hilbert space H with domain Dom (A) … To discuss the eigenfunctions we restrict ourselves first to the case where all particles are bosons, respectively, fermions.” — S Albeverio & P Kurasov, Singular Perturbations of Differential Operators


css assignments
this is notes on CSS training assignment.
show image on hover over name
list names. On hover over show image of person.


I am Dorcas Cherono 23 years Old. I came to love Technology at a tender age and was able to take a course in IT back in college. Due to passion, i chose to study in Moringa School to sharpen up my skills and knowledge about creating new ideas in the society. Moringa has thought me a lot of skills including, Teamwork,Leadership and Problem Solving.
My experience in Moringa has been awesome. In the last one month, i have been able to gain lots of skills through research and in class.Some of them include:
Sometimes i get off my computer and get to do what i love when free.This has enabled me to try figure out the activities throughout the day and set my mind free. I usually
Lets have a chat through


--- layout: post title: "@CPSXnews rocks the Children’s Museum - Centre for Planetary Science & Exploration @westernu" date: '2012-01-05T19:54:00.001-05:00' author: Bob Sica tags: - outreach - cpsx modified_time: '2013-08-02T16:33:02.784-04:00' blogger_id: tag:blogger.com,1999:blog-736339229338318027.post-6679119103258045626 blogger_orig_url: http://blog.purplecrowlidar.ca/2012/01/cpsxnews-rocks-childrens-museum-centre.html ---


Based loosely on the dice game described in Eli Goldratt's "The Goal", this simulator compares a "perfect" line (no variation in processes) with the more realistic case of lines with random variation in processes. The simulation runs for 400 time units (ticks) and compares performance of various simulated production lines.
The yellow boxes represent operations, with the count (in blue) being the number of units that were processed in the current tick. The grey box is the raw material ready to be consumed by the first operation. The white boxes represent the number of items available to be processed. Moving of items between operations is assumed to be instantaneous. The actual capacity of an operation to process units may be higher than shown, but is limited by the number of available units.
The cyan boxes (to the right of each line) represent cash, which starts at zero. The amount of cash at the end of the run is therefore the net profit for that time period. Each unit costs $2, incurred when that unit first enters the line. The line also incurrs fixed costs of $3 per tick. Each finished unit earns $4. If the cash (net profit) is below zero at the end of the run, the line can't pay its bills.
- Run the Balanced line
- Run the Capped line


Rotations Example
This example shows how to do the following:
- Use item rotations
- Use custom item meshes
- Use range gradient to color the series
For more basic example about using Qt Data Visualization graphs, see Bars Example.
Running the Example
To run the example from Qt Creator, open the Welcome mode and select the example from Examples. For more information, visit Building and Running an Example.
Using Rotations
In this example we want to orient the arrow items tangentially to the origin. This requires rotating them, which can be achieved by specifying rotation quaternion to each item:
QQuaternion yRotation = QQuaternion::fromAxisAndAngle(0.0f, 1.0f, 0.0f, horizontalAngle * radiansToDegrees); QQuaternion zRotation = QQuaternion::fromAxisAndAngle(0.0f, 0.0f, 1.0f, verticalAngle * radiansToDegrees); QQuaternion totalRotation = yRotation * zRotation; ptrToDataArray->setRotation(totalRotation);
Since the items need to be rotated along two axes, we define two rotation quaternions, one for Y-axis and one for Z-axis, and then multiply these together to get the total rotation, which we set to the data item.
Using Custom Item Meshes
The narrow arrow mesh we use for magnetic field arrow items is not a standard mesh. Instead we supply our own narrowarrow.obj
file which contains the object definition for the mesh in Wavefront
obj format:
m_magneticField->setMesh(QAbstract3DSeries::MeshUserDefined); m_magneticField->setUserDefinedMesh(QStringLiteral(":/mesh/narrowarrow.obj"));
Using Range Gradient
Setting the color style to range gradient in a series means that the item is colored according to its relative Y-value on the visible Y-coordinate range. We want the arrows on the bottom part of the graph to be darker and gradually get lighter higher they are, so we define a range gradient with black color at the position 0.0 and white color at the position 1.0:
QLinearGradient fieldGradient(0, 0, 16, 1024); fieldGradient.setColorAt(0.0, Qt::black); fieldGradient.setColorAt(1.0, Qt::white); m_magneticField->setBaseGradient(fieldGradient); m_magneticField->setColorStyle(Q3DTheme::ColorStyleRangeGradient);
Example Contents
Files:


--- layout: post title: mysql alter ignore table date: 2011-04-14 14:51:36.000000000 +09:30 type: post published: true status: publish categories: - MySQL tags: - mysql - sql - ddl meta: posturl_add_url: 'yes' _edit_last: '1' views: '1199' ---
Mark
IGNORE is a MySQL extension to standard SQL. It controls how ALTER TABLE works if there are duplicates on unique keys in the new table or if warnings occur when strict mode is enabled. If IGNORE is not specified, the copy is aborted and rolled back if duplicate-key errors occur. If IGNORE is specified, only the first row is used of rows with duplicates on a unique key, The other conflicting rows are deleted. Incorrect values are truncated to the closest matching acceptable value.
root@test 01:57:29>alter ignore table tmp_abc add unique key uk_b(b);
Query OK, 5 rows affected (0.65 sec)
Records: 5 Duplicates: 3 Warnings: 0
----BUT---- WHY --
alter ignore table table_bbb add unique key uk_tcm_sellerid(seller_id,service_date);
Error 1062: Duplicate entry '10688998-2011-04-11 00:00:00' for key 'uk_tcm_sellerid'
[2011-04-14 03:00:00] SQL执行失败！
--- which variables?
##########
mysql删除表中重复记录的sql，只能搞个临时表了
create table tmp_xd_del_id as
select id from tt_stats a
WHERE a.id != (SELECT MAX(id)
FROM tt_stats b
WHERE a.seller_id = b.seller_id
AND a.service_date = b.service_date);
delete from tt_stats where id in(select id from tmp_xd_del_id);
-- one sql
delete a from table_name a,
(select *, min(id) as bid
from table_name
group by index_value, member_id
having count(1) > 1) as b
where a.index_value = b.index_value
and a.member_id = b.member_id
and a.id > b.bid;


Felt like I haven't been posting on here enough so Ima do a post
So obviously not much has changed on here, I've just been messing with the code and making it cleaner.
I do have an important question for all of you 5 people who look at this,
What should I base my custom Operating System off of?
I was thinking either XV6 or MINIX, both are very small and easy for me to understand (code wise).
If I choose XV6 it'll be closer to a blank slate, since MINIX is closer to a complete OS.
It might also be fun to take XV6 and MACH and use them together, since I can use XV6 as a "springboard" to developing MACH.
I dunno, just email me whichever one you think is best.
P.S. I'm gonna post anime stuff on my Instagram ack ack ack cuz I think that's what the world needs so here's a freebie


| Document number: | P0905R1 | |
|---|---|---|
| Date: | 2018-03-16 | |
| Project: | Programming Language C++, Library Evolution Working Group and Evolution Working Group | |
| Reply-to: | Tomasz Kamiński <tomaszkam at gmail dot com> | |
| Herb Sutter <hsutter at microsoft.com> | ||
| Richard Smith <richard at metafoo.co.uk> |
This paper proposes to make operator spaceship (<=>
) symmetric,
so that when a <=> b
is well formed then b <=> a
should also be well formed
and have complementary semantics. This is both for usability purposes, and to make it consistent with the handling
of the two-way comparison operators.
Initial revision.
P0515R3: Consistent comparison
proposes that when expression b < a
is encountered, with a
and b
being
potentially of different types, the following functions are matched:
operator<(b, a)
and b.operator<(a)
,operator<=>(b, a) < 0
and b.operator<=>(a) < 0
,0 < operator<=>(a, b)
and 0 < a.operator<=>(b)
.This guarantees that the class author needs to provide only one definition of
operator<=>
for heterogenous types, and overload resolution itself
will try to match it in different configurations to build the desired expression.
Currently, the same mechanism does not work when expression encountered is b <=> a
,
even if a <=> b
would work. This lack of the built-in symmetry for spaceship operator
may lead to surprising behaviour in user code, leading either to compilation errors in seemingly correct programs,
or, more importantly, to incorrect runtime behavior.
The remainder of this section illustrates the problem with examples.
icase_string
classConsider the declaration of the comparisons function
for the icase_string
class, representing an sequence of characters for which case-sensitivity
is ignored (like file paths in certain operating system):
std::weak_ordering operator<=>(icase_string const&, icase_string const&); std::weak_ordering operator<=>(icase_string const&, std::string_view);
With the current specification, above declarations allow two objects:
is
of icase_string
sv
of std::string_view
<
, >
, ...) regardless
of the order of argument. To be specific all of the following expressions are well-formed:
is == sv, is != sv, is < sv, is > sv, is <= sv, is >= sv sv == is, sv != is, sv < is, sv > is, sv <= is, sv >= is
However, in the case of the three-way comparison operator, only the expression with original order of arguments will be accepted. Meaning that only the first of the below expressions is well-formed:
is <=> sv sv <=> is // ill-formed
This design decision was motivated by the fact that operator<=>
is not expected to be
called by the users, as they naturally use the two-way operators and so use <=>
only indirectly.
optional
exampleFor example let us consider the following implementation of the spaceship operator for std::optional
(the following example is based on the code from Barry Rezvin's blog post
Implementing the spaceship operator for optional):
template<typename T, typename U> auto operator<=>(optional<T> const& lhs, optional<U> const& rhs) -> decltype(*lhs <=> *rhs) { if (lhs.has_value() && rhs.has_value()) return *lhs <=> *rhs; else return lhs.has_value() <=> rhs.has_value(); } template<typename T, typename U> auto operator<=>(optional<T> const& lhs, U const& rhs) -> decltype(*lhs <=> rhs) { if (lhs.has_value()) return *lhs <=> rhs; else return strong_ordering::less; }
The above operators are designed to recreate the behaviour of the current optional
comparisons, that allow an object of the
type optional<T>
to be compared with any object of type U
or optional<U>
,
if an object of type T
can be compared with an object of type U
.
In our example, the user should be able to compare any two of the following objects in either order:
icase_string is; std::string_view sv; std::optional<icase_string> ois; std::optional<std::string_view> osv;
The above holds in the case of a symmetric invocation on two optionals, because for each ois @ osv
being:
ois == osv, ois != osv, ois < osv, ois > osv, ois <= osv, ois >= osv
the synthesised candidate (ois <=> osv) @ 0
is well formed, as it requires *ois <=> *osv
(icase_string
and std::string
)
to be well formed. For the reversed order of arguments i.e. osv @ oie
being:
osv == ois, osv != ois, osv < ois, osv > ois, osv <= ois, osv >= ois
the reversed candidate 0 @ (ois <=> osv)
is used for the same reason.
For a symmetric invocation on an optional and an unwrapped object, the only candidate available
(operator<=>(optional<T> const&, U const&)
) always invokes the underlying <=>
with the wrapped object on the left hand side.
Therefore the invocations in forms osi @ sv
(rewritten to (osi <=> sv) @ 0
) and sv @ osi
(rewritten to 0 @ (osi <=> sv)
) i.e:
osi == sv, osi != sv, osi < sv, osi > sv, osi <= sv, osi >= sv sv == osi, sv != osi, sv < osi, sv > osi, sv <= osi, sv >= osi
are well formed, as they lead to *osi <=> sv
(icase_string
and std::string_view
).
In contrast, the invocations in forms osv @ si
and si @ osv
, i.e:
osv == si, osv != si, osv < si, osv > si, osv <= si, osv >= si si == osv, si != osv, si < osv, si > osv, si <= osv, si >= osv
all ill-formed, because they attempt to invoke *osv <=> is
(std::string_view
and icase_string
).
pair
exampleLet us consider the following potential extension in form of the heterogeneous three-way comparison
operator for std::pair
types:
template<typename T1, typename U1, typename T2, typename U2> auto operator<=>(std::pair<T1, U1> const& p1, std::pair<T2, U2> const& p2) -> common_comparison_category_t<decltype(p1.first <=> p2.first), decltype(p1.second <=> p2.second)> { if (auto res = p1.first <=> p2.first; res != 0) return res; return p1.second <=> p2.second; }
The intent of the above operator is to allow pairs containing different types to be compared,
if corresponding elements (first
and second
) can be compared,
providing functionality similar to that already present for the optional
class template.
However, consider the following declarations of pairs:
std::pair<icase_string, std::string_view> p1; std::pair<std::string_view, icase_string> p2;
As the objects of type icase_string
and std::string
can be compared witch each other, we
can expect that, with the above declarations present, the following expressions will be well-formed:
p1 == p2, p1 != p2, p1 < p2, p1 > p2, p1 <= p2, p1 >= p2 p2 == p1, p2 != p1, p2 < p1, p2 > p1, p2 <= p1, p2 >= p1
According to the current rules for operator rewrite none of them is well-formed: the expression in the
form of p1 == p2
may be interpreted either as:
(p1 <=> p2) == 0
0 == (p2 <=> p1)
p1.first <=> p2.first
(icase_string
and std::string_view
)
is well-formed, however the three-way comparison of the second elements p1.second <=> p2.second
(std::string_view
and icase_string
)
is ill-formed (as invocations of spaceship are not symmetric). For the second candidate the p2.first <=> p1.first
(std::string_view
and icase_string
)
is ill-formed again.
In contrast to the optional
example, where adding the reversed declaration of the mixed operator would address the problem:
template<typename T, typename U> auto operator<=>(T const& lhs, optional<U> const& rhs) -> decltype(lhs <=> *rhs)
this is insufficient to fix the heterogeneous pair
comparison. Instead, we would need to edit the original class (icase_string
)
to include a reversed version of the comparison operator:
std::weak_ordering operator<=>(std::string_view, icase_string const&);
compare_3way
In contrast to the previous example, where lack of the symmetry for the invocation of the spaceship operator led to ill-formed code, in this case, the code will compile but produce an incorrect result.
Given the following specification of the compare_3way
function from 8.7.11 Three-way comparison algorithms ([alg.3way]):
Effects: Compares two values and produces a result of the strongest applicable comparison category type:
- (1.1) Returns
a <=> b
if that expression is well-formed.- (1.2) Otherwise, if the expressions
a == b
anda < b
are each well-formed and convertible tobool
, returnsstrong_ordering::equal
whena == b
istrue
, otherwise returnsstrong_ordering::less
whena < b
is true, and otherwise returnsstrong_ordering::greater
.- (1.3) Otherwise, if the expression
a == b
is well-formed and convertible tobool
, returnsstrong_equality::equal
whena == b
istrue
, and otherwise returnsstrong_equality::nonequal
.- (1.4) Otherwise, the function is defined as deleted.
The invocation in form compare_3way(is, sv)
returns an object of type std::weak_ordering
with value equal to is <=> sv
.
However in case of the reversed order of argument compare_3way(sv, is)
, the expression sv <=> is
is ill-formed, so we move
to the second point (1.2). In this case the expressions sv == is
and sv < is
are well-formed, as they are rewritten to 0 == (is <=> sv)
and 0 < (is <=> sv)
respectively. As a result, we return an object of std::strong_ordering
with the value matching the inverted
value of is <=> sv
.
Furthermore, consider the case of objects o1
and o2
of types O1
and O2
, for which the expression o1 <=> o2
will return
std::partial_order::unordered
and the reverse invocation o2 <=> o1
will be ill-formed (only operator<=>(O1, O2)
exists).
The invocation of the function compare_3way(o1, o2)
will return std::partial_order::unordered
, however if the arguments are reversed
compare_3way(o2, o1)
returns strong_ordering::greater
(due to the fallback to point 1.2 described above).
In addition all named comparison algorithms (strong_order
, weak_order
, partial_order
, strong_equal
, weak_equal
)
are prone to the same error caused by the lack of symmetry for three-way operator invocation.
To address these issues, we propose allowing the expression a <=> b
to find candidates with a reversed
order of arguments (operator<=>(b,a)
or b.operator<=>(a)
) in addition to the usual set of functions,
and if that candidate is selected its returned value is inverted.
As a consequence all of the above examples will "just work" without any changes to their code.
To achieve the above goal, we are proposing extending the current
language rules for the comparison operators to cover the three-way
comparison operator.
That means that an expression of the form a @ b
, with @
being a relational operator (==
, !=
, <
, >
,
<=
, >=
) or three-way comparison operator (<=>
), will consider following candidates:
a @ b
(a <=> b) @ 0
0 @ (b <=> a)
@
and <=>
are interpreted according to usual operator lookup rules, i.e. no recursive rewrites are performed.
Furthermore, we propose to keep the current tie-breakers, that in case of equivalent candidates, prefer:
a @ b
over the three-way forms: (a <=> b) @ 0
and 0 @ (a <=> b)
,(a <=> b) @ 0
over synthesised reversed candidate: 0 @ (b <=> a).
<=>
, the (a <=> b) <=> 0
rewrite will never be used,
as in the case when the expression a <=> b
is well-formed, it will be a worse candidate than a <=> b
.
As a consequence the set of candidates for this operator is de-facto reduced to a <=> b
and 0 <=> (b <=> a)
.
To complement the above language change, we need to extend to interface of each comparison category type C
(like std::strong_ordering
)
to include the following functions:
C operator<=>(C, unspecified); //c <=> 0, i.e. identity C operator<=>(unspecified, C); //0 <=> c, i.e. inversion
This will basically complete the set of comparison operators between these categories and the literal 0
,
which currently only include relational operators.
For an object c
of a comparison category type, the expression c <=> 0
is an identity,
that returns the value of c
unchanged, while 0 <=> c
represents an inversion, i.e. returns:
C::less
for c
representing greater-than comparison result (c > 0
),
C::greater
for c
representing lower-than comparison result (c < 0
),
c
(unchanged) in case of the other values.strong_equality
and weak_equality
the inversion is an identity operation,
as these objects cannot represent less-than or greater-than results.
The proposed wording changes refer to N4713 (C++ Working Draft, 2017-11-27).
Change in [over.match.oper] Operators in expressions paragraph 6 as follows:
- The set of candidate functions for overload resolution for some operator
@
is the union of the member candidates, the non-member candidates, and the built-in candidates for that operator@
. If that operator is a relational ([exp.rel])or, equality ([expr.eq]), or three-way comparison ([expr.spaceship]) operator with operands x and y, then for each member, non-member, or built-in candidate for the operator<=>
:where in each case,
- that operator is added to the set of candidate functions for overload resolution if
@
is not<=>
and(x <=> y) @ 0
is well-formed using thatoperator<=>
; and- a synthesized candidate is added to the candidate set where the order of the two parameters is reversed if
0 @ (y <=> x)
is well-formed using thatoperator<=>
;
- if
@
is not<=>
,operator<=>
candidates are not considered for the recursive lookup of operator@
and- synthesized
operator<=>
candidates are not considered for the recursive lookups.
Change in [over.match.oper] Operators in expressions paragraph 8 as follows:
- If an
operator<=>
candidate is selected by overload resolution for an operator@
,but@
is not<=>
,x @ y
is interpreted as0 @ (y <=> x)
if the selected candidate is a synthesized candidate with reversed order of parameters, or(x <=> y) @ 0
otherwiseif@
is not<=>
, using the selectedoperator<=>
candidate.
Add the following declarations at the end of the definition of the class in [cmp.weakeq] Class
weak_equality
section.
friend constexpr weak_equality operator<=>(weak_equality v, unspecified) noexcept; friend constexpr weak_equality operator<=>(unspecified, weak_equality v) noexcept;
Insert the following at the end of [cmp.weakeq] Class weak_equality
section.
constexpr weak_equality operator<=>(weak_equality v, unspecified) noexcept; constexpr weak_equality operator<=>(unspecified, weak_equality v) noexcept;
- Returns:
v
.
Add the following declarations at the end of the definition of the class in [cmp.strongeq] Class
strong_equality
section.
friend constexpr strong_equality operator<=>(strong_equality v, unspecified) noexcept; friend constexpr strong_equality operator<=>(unspecified, strong_equality v) noexcept;
Insert the following at the end of [cmp.strongeq] Class strong_equality
section.
constexpr strong_equality operator<=>(strong_equality v, unspecified) noexcept; constexpr strong_equality operator<=>(unspecified, strong_equality v) noexcept;
- Returns:
v
.
Add the following declarations at the end of the definition of the class in [cmp.partialord] Class
partial_ordering
section.
friend constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept; friend constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
Insert the following at the end of [cmp.partialord] Class partial_ordering
section.
constexpr partial_ordering operator<=>(partial_ordering v, unspecified) noexcept;
- Returns:
v
.constexpr partial_ordering operator<=>(unspecified, partial_ordering v) noexcept;
- Returns:
v < 0 ? partial_ordering::greater : v > 0 ? partial_ordering::less : v
.
Add the following declarations at the end of the definition of the class in [cmp.weakord] Class
weak_ordering
section.
friend constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept; friend constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
Insert the following at the end of [cmp.weakord] Class weak_ordering
section.
constexpr weak_ordering operator<=>(weak_ordering v, unspecified) noexcept;
- Returns:
v
.constexpr weak_ordering operator<=>(unspecified, weak_ordering v) noexcept;
- Returns:
v < 0 ? weak_ordering::greater : v > 0 ? weak_ordering::less : v
.
Add the following declarations at the end of the definition of the class in [cmp.strongord] Class
strong_ordering
section.
friend constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept; friend constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
Insert the following at the end of [cmp.strongord] Class strong_ordering
section.
constexpr strong_ordering operator<=>(strong_ordering v, unspecified) noexcept;
- Returns:
v
.constexpr strong_ordering operator<=>(unspecified, strong_ordering v) noexcept;
- Returns:
v < 0 ? strong_ordering::greater : v > 0 ? strong_ordering::less : v
.
For the purposes of SG10, we recommend increasing the value of the macro attached to consistent comparisons (if any) to match date of acceptance of this proposal.
At the following link, an example implementation of the comparison category types may be found - its goal is to reduce amount of branches:
<=
and >=
for partial_ordering
,
comparison between comparison category and 0
are implemented using single integer
comparison,<=
and >=
for partial_ordering
are implemented
as disjunction of <
and ==
.
operator<=>
are replaced
with operator_cmp
function.
Jens Maurer and Andrzej Krzemieński offered many useful suggestions and corrections to the proposal.


10.1 Keyboard only in V1 / 10.2 Input streams / 10.3 Mouse support / 10.4 Menu support / 10.5 Terminating characters and timed input / 10.6 Single keypresses / 10.7 Reading ZSCII from the keyboard
In Versions 1 and 2, the player's commands can only be drawn from the keyboard.
In Versions 3 and later, the player's keypresses are drawn from the current "input stream". There are two input streams: numbered 0 (the keyboard) and 1 (a file containing commands). Other inputs (mouse clicks or menu selections), if available, are also implemented as keypresses (see below).
The format of a file containing commands must be the same as that written in output stream 4.
The game can change the current input stream itself, using the opcode input_stream. It has no way of finding out which input stream is currently in use. An interpreter is free to change the input stream whenever it likes (e.g. at the player's request) or, indeed, to run the entire game under input stream 1 (for testing purposes).
When input stream 1 is first selected, the interpreter may use any method of choosing a file name for the file of commands. (Good practice is to use the same conventions as when choosing a filename for output to stream 4.)
When the the current stream is stream 1, the interpreter should not hold up long passages of text (by printing "[MORE]" and waiting for a keypress, for instance).
Mouse support is optional but can be provided in Versions 5 and later.
In a game which wishes to use the mouse, bit 5 of 'Flags 2' in the header should be set in the story file. If it wishes to read the mouse position after clicks, it must provide at least the first two words of a header extension table. (Note that Inform 6.12 and later always provide a header extension table at least this large, but Inform 6.11 and earlier never provide an extension table at all.)
If the interpreter cannot offer mouse support, then it should clear bit 5 of 'Flags 2' to signal this to the game.
Whenever a mouse click takes place (and provided the header extension table exists and contains at least 2 words) the interpreter should update the coordinates as follows:
Word 1: x coordinate where click took place Word 2: y coordinate where click took place
The mouse is presumed to have between 0 and 16 buttons. The state of these buttons can be read by the read_mouse opcode in Version 6. Otherwise, mouse clicks are treated as keyboard input codes (see below).
In Version 6, the mouse can either be free or constrained to one of the 8 windows: if so, clicks outside the 'mouse window' must be ignored, and the interpreter is at liberty to confine the mouse's movement to the boundary of its window.
Menu support can optionally be provided in Version 6.
In a game which wishes to use menus, bit 8 of 'Flags 2' in the header should be set in the story file.
If the interpreter cannot offer menu support, then it should clear bit 8 of 'Flags 2' to signal this to the game.
Menus are numbered from 0 upwards. 0, 1 and 2 are reserved for the interpreter to manage (this system has only been implemented on the Macintosh, wherein 0 is the Apple menu, 1 the File menu and 2 the Edit menu). Menus numbered 3 and upwards can be created or removed with the make_menu opcode.
Menu selection is reported to the game as a keypress (see below). Details of what selection has been made are read with read_mouse.
Whole commands are read from the input stream using the read opcode. (Note that this has two different internal names in Inform, sread for Versions 1 to 4 and aread subsequently.)
In Versions 1 to 3, the interpreter must redisplay the status line before it begins accepting input.
Commands are normally terminated by a new-line (a carriage return or a line feed as appropriate for the machine's keyboard or file format).
In Versions 5 and later, the game may provide a "terminating characters table" by giving its byte address in the word at $2e in the header. This table is a zero-terminated list of input character codes which cause aread to finish the command (in addition to new-line). Only function key codes are permitted: these are defined as those between 129 and 154 inclusive, together with 252, 253 and 254. The special value 255 means "any function key code is terminating".
***[1.0] In Versions 4 and later, an interpreter should ideally be able to time input and to call a (game) routine at periodic intervals: see the read opcode. If it is able to do this, it should set bit 7 of 'Flags 1' in the header.
In Versions 4 and later, individual characters can be read from the current input stream, using read_char. Again, the interpreter should ideally be able to time input and to call a (game) routine at periodic intervals. If it is able to do this, it should set bit 7 of 'Flags 1' in the header.
The only characters which can be read from the keyboard are ZSCII characters defined for input (see S 3).
Every ZSCII character defined for input can be returned by read_char.
Only ZSCII characters defined for both input and output can be stored in the text buffer supplied to the read opcode.
The "escape" code is optional: that is, an interpreter need not provide an escape key. (The Inform library clears and quits menus if this code is returned to read_char.)
Menus in 'Beyond Zork' define cursor up and cursor down as terminating characters, and make use of read in the upper window.
Mouse co-ordinates, whether returned by read_mouse or written into the header during input, are always relative to the top of the display at (1,1), regardless of the position of the current mouse window.
read_mouse is realtime. When called it must read the current mouse location, whether or not the mouse is inside the current mouse window. Interpreters are allowed to show positions and button states outside the Z-machine screen if the pointer is outside the interpreter's own user interface (using negative values if needed).
Programs must be prepared to cope with this. For example in a painting program you might want to ignore all buttons down outside the screen. When dragging something you might want to keep trying to follow the pointer, even outside the screen, until the buttons are released.
Interpreters may constrain the pointer to the screen as long as buttons are held down - this might aid dragging operations - although this is not required.
Section 1 / 2 / 3 / 4 / 5 / 6 / 7 / 8 / 9 / 10 / 11 / 12 / 13 / 14 / 15 / 16
Appendix A / B / C / D / E / F


I am experienced in leveraging agile frameworks to provide a robust synopsis for high level overviews. Iterative approaches to corporate strategy foster collaborative thinking to further the overall value proposition.
Revamp the whole system with much more smooth and workable interface.
Building email templates on day to day basis. Collaborate with several high end clients such as Chanel, Dior and Estee Lauder.
Working on e-commerce system is nothing but challenges. I faced several (if not many) of them during the development.
Build hospital management system for Pantai Hospitals across whole country.
GPA: 3.23
GPA: 3.56
Apart from being a web developer, I enjoy most of my time being outdoors. I play football and futsal in my free time. Apart from that, I also enjoy jogging and participate in several events.
When forced indoors, I spend a lot of time playing video games. I also enjoy comedy series to balance my seriousness.


We will have a look at a TestProject
to get an idea of how jenkins can be used to build, sign and deploy iOS projects. The whole process consists of 4 steps. Note that to deploy an app in this manner, an enterprise distribution certificate is required for each app.
This guide is how I have set up my enterprise builds for my apps that use cocoaPods
for dependencies, but most of the same principles apply for any iOS apps.
Because the project uses cocoaPods
, it means we have to build a workspace and have a build scheme set up.
Note: Apple Enterprise licenses can ONLY be used for builds internal to your company. I am not responsible for anything that may happen if you try to distribute apps outside your company using an enterprise license.
This guide may be a bit brief, don’t hesitate to ask me any questions. This is mostly for my own reference.
Step 1 - Poll SCM
- Dev builds poll the SCM looking for changes to the
master
branch at midnight every night. - If no changes have occurred, then the project is not built.
- If modifications have been made, the next step is executed.
Step 2 - Xcode build
Below is a screenshot from jenkins showing the fields used for the xcode plugin.
Clean before build
- we don’t want any cached compiled objects hanging around.Xcode Schema File
-TestProjectDev
- Because of the way we have our project set up, our top level item is a workspace (
TestProject.xcworkspace
), we have to build based on Schemes as Xcode does not support building a target from a workspace. TestProjectDev
specifies the scheme we want to build with.
- Because of the way we have our project set up, our top level item is a workspace (
Configuration
-Release
- We want the release version. There are several subtle differences between
Debug
andRelease
versions. The most notable is thatDebug
builds are usually built for just one architecture, whereRelease
builds are built for all supported architectures, usually with compile time optimisations as well.
- We want the release version. There are several subtle differences between
Workspace File
- This is our top level workspace file (TestProject.xcworkspace
) that we build from. If this option wasn’t specified, by default the xcode build would look for the first*.xcodeproj
file it can find. This would cause our build to fail.Unlock Keychain
- This allows us to unlock the keychain which is required for signing or resigning
.ipa
files. - The location of the keychain is the default OSX location
- This allows us to unlock the keychain which is required for signing or resigning
Step 3 - Resigning
- This step only occurs if previous steps were successful
- This step only occurs if the text
BUILD
is present in the log text (basically every build) - The result of this build will be escalated to the job status. If this step fails and other steps before it were successful, the job will still fail.
Below is the script used for resigning:
#!/bin/sh
PROJECT_BUILDDIR="${WORKSPACE}/build/TestProject/Build/Products/Release-iphoneos"
APPLICATION_NAME="TestProjectDev"
BUILD_HISTORY_DIR="/Users/administrator/Provisioning/builds"
DEVELOPER_NAME="iPhone Distribution: Test Company LTD"
PROVISIONING_PROFILE="/Users/administrator/Provisioning/TestProjectDevDistributionProfile.mobileprovision"
HOST_LOCATION="/Library/WebServer/Documents/apps"
#Sign The .app file and create .ipa file
/usr/bin/xcrun -sdk iphoneos PackageApplication -v "${PROJECT_BUILDDIR}/${APPLICATION_NAME}.app" -o "${BUILD_HISTORY_DIR}/${APPLICATION_NAME}.ipa" --sign ${DEVELOPER_NAME} --embed ${PROVISIONING_PROFILE}
#Get the version from the Info.plist file
APP_PATH="${PROJECT_BUILDDIR}/${APPLICATION_NAME}.app"
VERSION=`defaults read ${APP_PATH}/Info CFBundleShortVersionString`
BUNDLE_ID=`defaults read ${APP_PATH}/Info CFBundleIdentifier`
# Create plist
cat ${HOST_LOCATION}/template.plist | sed -e "s/\${APP_NAME}/$APPLICATION_NAME/" -e "s/\${BUNDLE_ID}/$BUNDLE_ID/" -e "s/\${BUNDLE_VERSION}/$VERSION/" > ${HOST_LOCATION}/${APPLICATION_NAME}.plist
- The first part of this script sets up the locations and script variables
PROJECT_BUILDDIR
- The folder that the built.ipa
file resides from the previous build step.APPLICATION_NAME
- In this case it isTestProjectDev
BUILD_HISTORY_DIR
- The folder that the re-signed app will be output toDEVELOPER_NAME
- Has to match the.mobileprovision
file used for signing.PROVISIONING_PROFILE
- The location of the.mobileprovision
file used for signing. These must be downloaded from the Apple developer website or shown in Finder from the Xcode organizer.HOST_LOCATION
- Where the final signed app will exist
- The next stage of the build process is actually re-signing the app using the Xcode command line tool called
xcrun
. Note that the version in/usr/bin/
is a symlink to the Xcode version that has been selected by thexcodeselect
command line tool. This is important if more than one version of xcode is installed. Each version of Xcode stores command line tools inside the.app
file in applications. - After re-signing, we grab the version, and bundle-id. These are used in the next part
APP_PATH
- The full path including the.app
extension of the re-signed appVERSION
- This is theCFBundleShortVersionString
. This value is set when you change the version in Xcode for each of the build schemes.BUNDLE_ID
- TheCFBundleIdentifier
for the built app. ForTestProject
, this will beau.com.wordpress.danielbeard.TestProject
. These can be set by modifying the build Schemes, but shouldn’t be changed for existing applications. Production has a different bundleId, which is what allows for both the dev and prod versions to exist on a single iPad at the same time.
- We then auto generate the enterprise install PLIST file. This is needed to install apps from a URL location and acts as a “description” of the app that is about to be installed.
- The actual creation of this file is quite simple, we use
cat
to copy thetemplate.plist
file to the new location and then usingsed
we replace theBUNDLE_ID
andBUNDLE_VERSION
values. These values are read from the Apps Info.plist from inside the .app folder.
- The actual creation of this file is quite simple, we use
Below is an example template.plist file
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
<key>items</key>
<array>
<dict>
<key>assets</key>
<array>
<dict>
<key>kind</key>
<string>software-package</string>
<key>url</key>
<string>http://hostlocation/apps/${APP_NAME}.ipa</string>
</dict>
</array>
<key>metadata</key>
<dict>
<key>bundle-identifier</key>
<string>${BUNDLE_ID}</string>
<key>bundle-version</key>
<string>${BUNDLE_VERSION}</string>
<key>kind</key>
<string>software</string>
<key>title</key>
<string>${APP_NAME}</string>
</dict>
</dict>
</array>
</dict>
</plist>
Step 4 - Copying to host location
- This step simple grabs the signed
.ipa
file and puts it in the host location so that the macmini website can serve it over a URL. The host location is/Library/Webserver/Documents/apps
Script looks like this:
#!/bin/sh
APPLICATION_NAME="TestProjectDev.ipa"
BUILD_HISTORY_DIR="/Users/administrator/Provisioning/builds"
HOST_LOCATION="/Library/WebServer/Documents/apps/"
cp "${BUILD_HISTORY_DIR}/${APPLICATION_NAME}" "${HOST_LOCATION}${APPLICATION_NAME}"
And that’s it! The output is a .ipa file and a .plist file. These are both required to install an enterprise app.


Add point to selected series
Add point with delay
Advance selected series
Add point at X position
Remove selected points
Update point (+1)
Update point (-1)
Remove selected series
Set new data to selected series
Set x axis extremes
Add plot band
Remove plot band
Add plot line
Remove plot line
Add
area
,
areaspline
,
bar
,
column
,
stacked column
,
line
,
pie
,
scatter
,
scatter / line
,
spline
.
Get item by id:
axis
,
series
,
point
.
Click anywhere in the plot area to add a point to the first series.


LENT 3 SUNDAY
On this Sunday we celebrate the first scrutiny in preparation for the Baptism of the catechumens who are to be admitted to the Sacraments of Christian Initiation at the Easter Vigil, using the proper prayers and intercessions as given in The Roman Missal.
Entrance Antiphon
My eyes are always on the Lord, for he rescues my feet from the snare. Turn to me and have mercy on me, for I am alone and poor.
Or:
When I prove my holiness among you, I will gather you from all the foreign lands; and I will pour clean water upon you and cleanse you from all your impurities, and I will give you a new spirit, says the Lord.
The Gloria in excelsis (Glory to God in the highest) is not said.
Collect
O God, author of every mercy and of all goodness, who in fasting, prayer and almsgiving have shown us a remedy for sin, look graciously on this confession of our lowliness, that we, who are bowed down by our conscience, may always be lifted up by your mercy. Through our Lord. . .
Theme of the Sunday: If You Knew the Gift of God.
We have all experienced thirst; we all know what happens to our fields when it doesn’t rain. The first reading and the Gospel speak to us of water. In the desert the people of Israel survived because God provided water for them. In the Gospel Jesus speaks of a new water, a new life that he wants to give us. The second reading shows why we should trust and be joyful because no one will be deprived of this water.
FIRST READING Exodus 17:3-7
“Give us water to drink” (Ex 17:2).
A reading from the Book of Exodus
In those days: The people thirsted for water,
and the people murmured against Moses, and said, "Why did you bring us up
out of
The word of the Lord
RESPONSORIAL PSALM
Psalm 95:1-2.6-7abc.7d-9 (R. cf. 7d, 8a)
R. O that today you would listen to his voice! Harden not your hearts.
Come, let us ring out our joy to the LORD; hail
the rock who saves us. Let us come into his presence, giving thanks; let us
hail him with a song of praise.
R.
O that today you would listen to his voice! Harden not your hearts.
 Let us kneel
before the God who made us, for he is our God and we the people who belong to
his pasture, the flock that is led by his hand.
R.
O that today you would listen to his voice! Harden not your hearts.
O that today you would listen to his voice!
'Harden not your hearts as at Meribah, as on that day
at Massah in the desert when your forebears put me to
the test; when they tried me, though they saw my work.'
R.
O that today you would listen to his voice! Harden not your hearts.
SECOND READING Romans 5:1-2.5-8
“God’s love has been poured into our hearts through the Holy Spirit who has been given to us.”
A reading from the Letter of Saint Paul to the Romans
Brethren: Since we are justified by faith, we
have peace with God through our Lord Jesus Christ. Through him we have obtained
access to this grace in which we stand, and we rejoice in our hope of sharing
the glory of God. And hope does not disappoint us, because God's love has been
poured into our hearts through the Holy Spirit which has been given to us.
While we were still weak, at the right time Christ died for the ungodly. Why,
one will hardly die for a righteous man--though perhaps for a good man one will
dare even to die. But God shows his love for us in that while we were yet
sinners Christ died for us.
The word of the Lord
VERSE BEFORE THE GOSPEL John
4:42.15
R. Glory and praise to you, O Christ.
Lord, you are truly the Saviour of the world; give me living water, that I may not
thirst.
R. Glory and praise to you, O Christ.
GOSPEL John 4:5-42
(or Shorter)
“A spring of water welling up to eternal life.”
A reading from the holy Gospel according to John
At that time: Jesus came to a city of
The Gospel of the Lord
A reading from the holy Gospel according to John
At that time: Jesus came to a city of
The Gospel of the Lord
The
Alternatively, the following readings may be used:
Theme of the Sunday: The Purification of the Temple and of Religion.
The gospel recounts the story of the purification of the temple, or rather, the replacement of the old temple with a new one. We are the new temple but, like the old, we also often need purification from all that hinders our offering to God acceptable sacrifices. In the second reading, Paul tells us that we must stop reasoning like the “Jews” and the “Greeks.” The first reading tells us what sacrifices are acceptable to God coupled with an invitation to purify our religion of cults that have nothing to do with love of God or of our neighbours.
FIRST READING Ex 20:1-17
The law is given through Moses.
A reading from the Book of Exodus
In those days: God spoke all these words,
saying, "I am the LORD your God, who brought you out of the
The word of the Lord
Or shorter:
A reading from the Book of Exodus
In those days: God spoke all these words, saying,
"I am the Lord your God, who brought you out of the land of Egypt, out of the house of bondage.
"You shall have no other gods before me.
"You shall not take the name of the Lord your God in vain; for the Lord will not hold him guiltless who takes his name in vain.
"Remember the sabbath day, to keep it holy.
"Honour your father and your mother, that your days may be long in the land which the Lord your God gives you.
"You shall not kill.
"You shall not commit adultery.
"You shall not steal.
"You shall not bear false witness against your neighbour.
"You shall not covet your neighbour’s house; you shall not covet your neighbour’s wife, or his manservant, or his maidservant, or his ox, or his donkey, or anything that is your neighbour’s.
"
The word of the Lord
RESPONSORIAL PSALM
Ps 19:<IP_ADDRESS> (R. cf. John 6:68c)
R. Lord, you have the words of eternal life.
The law of the LORD is perfect; it revives the
soul. The decrees of the LORD are steadfast; they give wisdom to the simple.
R.
Lord, you have the words of eternal life.
The precepts of the LORD are right; they
gladden the heart. The command of the LORD is clear; it gives light to the
eyes.
R.
Lord, you have the words of eternal life.
The fear of the LORD is pure, abiding for ever.
The judgements of the Lord are true; they are, all of them, just.
R.
Lord, you have the words of eternal life.
They are more to be desired than gold, than
quantities of gold. And sweeter are they than honey, than honey flowing from
the comb.
R.
Lord, you have the words of eternal life.
SECOND READING 1 Corinthians 1:22-25
Brethren: Jews demand signs and
Greeks seek wisdom, but we preach Christ crucified, a stumbling block to Jews
and folly to Gentiles, but to those who are called, both Jews and Greeks,
Christ the power of God and the wisdom of God. For the foolishness of God is
wiser than men, and the weakness of God is stronger than men.
VERSE BEFORE THE GOSPEL John 3:16
R. Glory and praise to you, O Christ.

GOSPEL John 2:13-25
“Destroy this temple, and in three days I will raise it up.”
A reading from the holy Gospel according to John
The Passover of the Jews was at
hand, and Jesus went up to
The Gospel of the Lord
The
Alternatively, the following readings may be used:
Theme of the Sunday: Time to Convert.
In Lent, more that at any other time of the year, God invites us to change our ways. In the gospel Jesus shows us that his Father is always calling us. Time is short; we should choose to follow him now. The first reading tells us about Moses who, when God called him, abandoned his own plans and accepted the Lord’s proposal to return to Egypt and liberate his people. The journey to freedom is long and hard. The children of Israel in the desert gave in to many temptations. This happens to us even when we choose to follow the Lord. This is the message of the second reading.
FIRST READING Exodus 3:1-8.13-15
“‘I am’ has sent me to you.”
A reading from the Book of Exodus
In those days: Moses was
keeping the flock of his father-in-law, Jethro, the priest of Midian; and he
led his flock to the west side of the wilderness, and came to Horeb, the
The word of the Lord
RESPONSORIAL PSALM
Psalm 103:1-2.3-4.6-7.8 and 11 (R. 8a)
R. The Lord is compassionate and gracious.
Bless the LORD, O my soul, and all within me,
his holy name. Bless the LORD, O my soul, and never forget all his benefits.
R.
The Lord is compassionate and gracious.
It is the LORD who forgives all your sins, who
heals every one of your ills, who redeems your life from the grave, who crowns
you with mercy and compassion.
R.
The Lord is compassionate and gracious.
The LORD does just deeds, gives full justice to
all who are oppressed. He made known his ways to Moses, and his deeds to the
children of
R.
The Lord is compassionate and gracious.
The LORD is compassionate and gracious, slow to
anger and rich in mercy. For as the heavens are high above the earth, so strong
his mercy for those who fear him.
R.
The Lord is compassionate and gracious.
SECOND READING 1 Corinthians
10:1-6.10-12
“These things that happened to the people with Moses in the desert were written down for our instruction.”
A reading from the first Letter of Saint Paul to the Corinthians
I want you to know, brethren, that our fathers
were all under the cloud, and all passed through the sea, and all were baptized
into Moses in the cloud and in the sea, and all ate the same supernatural food
and all drank the same supernatural drink. For they drank from the supernatural
Rock which followed them, and the Rock was Christ. Nevertheless with most of
them God was not pleased; for they were overthrown in the wilderness. Now these
things are warnings for us, not to desire evil as they did, nor grumble, as
some of them did and were destroyed by the Destroyer. Now these things happened
to them as a warning, but they were written down for our instruction, upon whom
the end of the ages has come. Therefore let any one
who thinks that he stands take heed lest he fall.
The word of the Lord
VERSE BEFORE THE GOSPEL Matthew
4:17
R. Glory and praise to you, O Christ.
Repent, says the Lord, for the
kingdom of heaven is at hand.
R. Glory and praise to you, O Christ.

A reading from the holy Gospel according to Luke
There were some present at that
very time who told Jesus of the Galileans whose blood Pilate had mingled with
their sacrifices. And he answered them, "Do you think that these Galileans
were worse sinners than all the other Galileans, because they suffered thus?  Or those
eighteen upon whom the tower in Siloam fell and killed them, do you think that
they were worse offenders than all the others who dwelt in
The Gospel of the Lord
The Creed is said.
Prayer over the Offerings
Be pleased, O Lord, with these sacrificial offerings, and grant that we who beseech pardon for our own sins, may take care to forgive our neighbour. Through Christ our Lord.
When the Gospel of the Samaritan Woman is not read, Preface I or II of Lent, pp. 619-620 is used.
Preface: The Samaritan Woman.
It is truly right and just, our duty and our salvation, always and everywhere to give you thanks, Lord, holy Father, almighty and eternal God, through Christ our Lord. For when he asked the Samaritan woman for water to drink, he had already created the gift of faith within her and so ardently did he thirst for her faith, that he kindled in her the fire of divine love. And so we, too, give you thanks and with the Angels praise your mighty deeds, as we acclaim: Holy, Holy, Holy. . .
Communion Antiphon
When the Gospel of the Samaritan Woman is read: Jn 4:13-14
For anyone who drinks it, says the Lord, the water I shall give will become in him a spring welling up to eternal life.
When another Gospel is read: Cf. Ps 84:4-5
The sparrow finds a home, and the swallow a nest for her young:
by your altars, O Lord of hosts, my King and my God. Blessed are they who dwell in your house, for ever singing your praise.
Prayer after Communion
As we receive the pledge of things yet hidden in heaven, and are nourished while still on earth with the Bread that comes from on high, we humbly entreat you, O Lord, that what is being brought about in us in mystery may come to true completion. Through Christ our Lord.
Prayer over the People
Direct, O Lord, we pray, the hearts of your faithful, and in your kindness grant your servants this grace: that, abiding in the love of you and their neighbour, they may fulfil the whole of your commands. Through Christ our Lord.


Lombard's dream inches closer as he leads at Sun City
by Lynn Butler - Sport24Sun City - Zander Lombard is on the verge of achieving a goal of many South African pro golfers as he leads the Nedbank Golf Challenge into the final round.
Lombard, who will take three shot lead into the final round, posted even-par 72 to remain at 11-under par following the third round on Saturday.
The 24-year-old is one his way to securing a maiden European Tour title as he leads by one shot from fellow countryman Louis Oosthuizen and Belgian Thomas Detry.
It would be a childhood dream come true for Lombard, if he manages to hold on and win at Sun City.
"It would be a dream come true, it's an absolute South African childhood dream to win the Nedbank Golf Challenge," Lombard told reporters following his round.
"They money and prizes aside it's to really give the fans what we want."
Lombard confessed that it was a rather frustrating round as the South African produced four birdies, three bogeys and a double bogey.
"It's been a frustrating round but there are a lot of positives," he said.
"All in all, I'm still in the lead. I've got to stay positive and really looking forward for tomorrow."
Lombard revealed that he had to stick to his processes in order for him to keep his cool as thousands of fans followed his every move at the Gary Player Country Club.
"I missed one or two fairways and you can't attack a golf course if you're not on the fairways but I stuck to my guns," said Lombard.
"Pins are definitely on the tricker spots and it was tough to get it close and make the putt. You can't force it out here but I stuck to my processes."
Lombard, Oosthuizen and Detry were neck-and-neck and fighting for the top spot on the leaderboard all through the round.
"It was like we were having our own matchplay, no one was really chasing us so it was cool. It was fun, they're two lovely lads," he said.
Leaderboard after Round 3 of the Nedbank Golf Challenge
205 - Zander Lombard 68-65-72
206 - Thomas Detry (BEL) 66-71-69, Louis Oosthuizen 63-72-71
208 - Marcus Kinhult (SWE) 69-69-70, Oliver Wilson (ENG) 69-72-67
210 - Joachim B Hansen (DEN) 69-70-71, Mikko Korhonen (FIN) 70-70-70, Aaron Rai (ENG) 70-69-71, Jason Scrivener (AUS) 69-70-71, Lee Westwood (ENG) 68-73-69, Bernd Wiesberger (AUT) 71-69-70


Tilos is a long, thin island somewhat off the usual tourist route. A very pleasant, yet quiet island, it lies approximately halfway between Kos and Rhodes.
The Port Authority is close by the harbour and are reported to be very courteous. There is also a Harbourmaster.
Livadhia
Livadhia harbour sits in a large bay on the east coast of Tilos. It is a very laid back place, with the occasional ferry.
The harbour is small, with room for about a dozen visiting yachts. The breakwater (mole) provides excellent protection. Mooring is stern or bows-to with lazy lines on the town quay, or to the mole with your own anchor. Ferries and larger yachts tend to use the outside of the mole. Good holding.
There is water and electricity for most berths.
If the harbour is full, it is possible to anchor outside in settled weather. Take care to get the anchor through the weed to ensure it is dug in.
Small yachts may also be able to find a space in the fishing harbour, in the SE corner of the bay. Depths of 2m at the entrance.
Last updated May 2016.


Struct WasmerValue
This object can wrap an int, long, float or double. The Tag property describes the actual payload, and the I32, I64, F32 and F64 fields provide access to the underlying data. Implicit conversion from those data types to WasmerValue exist, and explicit conversions from a WasmerValue to those types exist.
Namespace: WasmerSharp
Assembly: WasmerSharp.dll
Syntax
public struct WasmerValue
Fields
F32
The 32-bit floating point component, when the Tag is Float32
Declaration
public float F32;
Field Value
| Type | Description |
|---|---|
| System.Single | To be added. |
F64
The 64-bit floating point component, when the Tag is Float64
Declaration
public double F64;
Field Value
| Type | Description |
|---|---|
| System.Double | To be added. |
I32
The 32-bit integer component, when the Tag is Int32
Declaration
public int I32;
Field Value
| Type | Description |
|---|---|
| System.Int32 | To be added. |
I64
The 64-bit integer component, when the Tag is Int64
Declaration
public long I64;
Field Value
| Type | Description |
|---|---|
| System.Int64 | To be added. |
Tag
The underlying type for the value stored here.
Declaration
public WasmerSharp.WasmerValueType Tag;
Field Value
| Type | Description |
|---|---|
| WasmerValueType | To be added. |
Methods
Encode()
Returns a boxed object that contains the underlying .NET type (int, long, float, double) based on the Tag for this value.
Declaration
public object Encode ();
Returns
| Type | Description |
|---|---|
| System.Object | The boxed value. |
Operators
op_Explicit(WasmerValue to Double)
Returns the stored value as a double. This will cast if the value is not a native double.
Declaration
public static double op_Explicit (WasmerSharp.WasmerValue val);
Parameters
| Type | Name | Description |
|---|---|---|
| WasmerValue | val | The incoming WasmerValue. |
Returns
| Type | Description |
|---|---|
| System.Double | To be added. |
op_Explicit(WasmerValue to Int32)
Returns the stored value as an int. This will cast if the value is not a native int.
Declaration
public static int op_Explicit (WasmerSharp.WasmerValue val);
Parameters
| Type | Name | Description |
|---|---|---|
| WasmerValue | val | The incoming WasmerValue. |
Returns
| Type | Description |
|---|---|
| System.Int32 | To be added. |
op_Explicit(WasmerValue to Int64)
Returns the stored value as a long. This will cast if the value is not a native long.
Declaration
public static long op_Explicit (WasmerSharp.WasmerValue val);
Parameters
| Type | Name | Description |
|---|---|---|
| WasmerValue | val | The incoming WasmerValue. |
Returns
| Type | Description |
|---|---|
| System.Int64 | To be added. |
op_Explicit(WasmerValue to Single)
Returns the stored value as a float. This will cast if the value is not a native float.
Declaration
public static float op_Explicit (WasmerSharp.WasmerValue val);
Parameters
| Type | Name | Description |
|---|---|---|
| WasmerValue | val | The incoming WasmerValue. |
Returns
| Type | Description |
|---|---|
| System.Single | To be added. |
op_Implicit(Double to WasmerValue)
Creates a WasmerValue from an double
Declaration
public static WasmerSharp.WasmerValue op_Implicit (double val);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Double | val | Double value to wrap |
Returns
| Type | Description |
|---|---|
| WasmerValue | To be added. |
op_Implicit(Int32 to WasmerValue)
Creates a WasmerValue from an integer
Declaration
public static WasmerSharp.WasmerValue op_Implicit (int val);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int32 | val | Integer value to wrap |
Returns
| Type | Description |
|---|---|
| WasmerValue | To be added. |
op_Implicit(Int64 to WasmerValue)
Creates a WasmerValue from an long
Declaration
public static WasmerSharp.WasmerValue op_Implicit (long val);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Int64 | val | Long value to wrap |
Returns
| Type | Description |
|---|---|
| WasmerValue | To be added. |
op_Implicit(Single to WasmerValue)
Creates a WasmerValue from an float
Declaration
public static WasmerSharp.WasmerValue op_Implicit (float val);
Parameters
| Type | Name | Description |
|---|---|---|
| System.Single | val | Float value to wrap |
Returns
| Type | Description |
|---|---|
| WasmerValue | To be added. |