Class AnonCreds
Provides methods for managing anonymous credentials.
Namespace: Hyperledger.Indy.AnonCredsApi
Assembly: Hyperledger.Indy.Sdk.dll
Syntax
public static class AnonCreds : Object
Methods
CreateRevocationStateAsync(BlobStorageReader, String, String, Int64, String)
Create revocation state for credential in the particular time moment.
Declaration
public static Task<string> CreateRevocationStateAsync(BlobStorageReader blobStorageReader, string revRegDef, string revRegDelta, long timestamp, string credRevId)
Parameters
| Type | Name | Description |
|---|---|---|
| BlobStorageReader | blobStorageReader | Configuration of blob storage reader handle that will allow to read revocation tails. |
| String | revRegDef | Revocation registry definition json. |
| String | revRegDelta | Revocation registry definition delta json. |
| Int64 | timestamp | Time represented as a total number of seconds from Unix Epoch. |
| String | credRevId | user credential revocation id in revocation registry. |
Returns
| Type | Description |
|---|---|
| Task<String> | revocation state json: { "rev_reg": <revocation registry>, "witness": <witness>, "timestamp" : integer } . |
IssuerCreateAndStoreCredentialDefAsync(Wallet, String, String, String, String, String)
Creates keys for the given schema and signature type.
Declaration
public static Task<IssuerCreateAndStoreCredentialDefResult> IssuerCreateAndStoreCredentialDefAsync(Wallet wallet, string issuerDid, string schemaJson, string tag, string type, string configJson)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | The wallet into which the claim definition will be stored. |
| String | issuerDid | The DID of the issuer of the claim definition. |
| String | schemaJson | The JSON schema of the claim definition. |
| String | tag | Allows to distinct between credential definitions for the same issuer and schema |
| String | type | The type of signature to use. |
| String | configJson | Whether to request non-revocation claim. |
Returns
| Type | Description |
|---|---|
| Task<IssuerCreateAndStoreCredentialDefResult> | credDefId: identifier of created credential definition credDefJson: public part of created credential definition |
Remarks
This method creates both primary and revocation keys for the given
signature type and schema and stores them in the provided wallet
.
The generated claim definition is returned as a JSON string containing information about the
signature type, schema, the issuer's public key and the unique identifier of the public key
in the wallet.
note
Currently the only signature type that is supported is 'CL'.
IssuerCreateAndStoreRevocRegAsync(Wallet, String, String, String, String, String, BlobStorageWriter)
Create a new revocation registry for the given credential definition as tuple of entities:
- Revocation registry definition that encapsulates credentials definition reference, revocation type specific configuration and secrets used for credentials revocation
- Revocation registry state that stores the information about revoked entities in a non-disclosing way. The state can be represented as ordered list of revocation registry entries were each entry represents the list of revocation or issuance operations.
Revocation registry definition entity contains private and public parts. Private part will be stored in the wallet. Public part will be returned as json intended to be shared with all anoncreds workflow actors usually by publishing REVOC_REG_DEF transaction to Indy distributed ledger.
Revocation registry state is stored on the wallet and also intended to be shared as the ordered list of REVOC_REG_ENTRY transactions. This call initializes the state in the wallet and returns the initial entry.
Some revocation registry types (for example, 'CL_ACCUM') can require generation of binary blob called tails used to hide information about revoked credentials in public revocation registry and intended to be distributed out of leger (REVOC_REG_DEF transaction will still contain uri and hash of tails). This call requires access to pre-configured blob storage writer instance handle that will allow to write generated tails.
Declaration
public static Task<IssuerCreateAndStoreRevocRegResult> IssuerCreateAndStoreRevocRegAsync(Wallet wallet, string issuerDid, string type, string tag, string credDefId, string configJson, BlobStorageWriter tailsWriter)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | wallet handler (created by open_wallet).. |
| String | issuerDid | a DID of the issuer signing transaction to the Ledger. |
| String | type | revocation registry type (optional, default value depends on credential definition type). Supported types are:
|
| String | tag | allows to distinct between revocation registries for the same issuer and credential definition. |
| String | credDefId | id of stored in ledger credential definition. |
| String | configJson | type-specific configuration of revocation registry as json:
|
| BlobStorageWriter | tailsWriter | handle of blob storage to store tails |
Returns
| Type | Description |
|---|---|
| Task<IssuerCreateAndStoreRevocRegResult> | revoc_reg_id: identifier of created revocation registry definition revoc_reg_def_json: public part of revocation registry definition revoc_reg_entry_json: revocation registry entry that defines initial state of revocation registry |
IssuerCreateCredentialAsync(Wallet, String, String, String, String, BlobStorageReader)
Check Cred Request for the given Cred Offer and issue Credential for the given Cred Request.
Cred Request must match Cred Offer. The credential definition and revocation registry definition referenced in Cred Offer and Cred Request must be already created and stored into the wallet.
Information for this credential revocation will be store in the wallet as part of revocation registry under generated cred_revoc_id local for this wallet.
This call returns revoc registry delta as json file intended to be shared as REVOC_REG_ENTRY transaction. Note that it is possible to accumulate deltas to reduce ledger load.
Declaration
public static Task<IssuerCreateCredentialResult> IssuerCreateCredentialAsync(Wallet wallet, string credOfferJson, string credReqJson, string credValuesJson, string revRegId, BlobStorageReader blobStorageReader)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | Wallet. |
| String | credOfferJson | a cred offer created by indy_issuer_create_credential_offer |
| String | credReqJson | a credential request created by indy_prover_create_credential_req. |
| String | credValuesJson | a credential containing attribute values for each of requested attribute names. Example: { "attr1" : {"raw": "value1", "encoded": "value1_as_int" }, "attr2" : {"raw": "value1", "encoded": "value1_as_int" } } |
| String | revRegId | id of revocation registry stored in the wallet. |
| BlobStorageReader | blobStorageReader | configuration of blob storage reader handle that will allow to read revocation tails |
Returns
| Type | Description |
|---|---|
| Task<IssuerCreateCredentialResult> | cred_json: Credential json containing signed credential values { "schema_id": string, "cred_def_id": string, "rev_reg_def_id", Optional<string>, "values": [see cred_values_json above], // Fields below can depend on Cred Def type "signature": [signature], "signature_correctness_proof": [signature_correctness_proof] } cred_revoc_id: local id for revocation info (Can be used for revocation of this cred) revoc_reg_delta_json: Revocation registry delta json with a newly issued credential |
IssuerCreateCredentialOfferAsync(Wallet, String)
Create credential offer that will be used by Prover for credential request creation. Offer includes nonce and key correctness proof for authentication between protocol steps and integrity checking.
Declaration
public static Task<string> IssuerCreateCredentialOfferAsync(Wallet wallet, string credDefId)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | Wallet. |
| String | credDefId | id of credential definition stored in the wallet |
Returns
| Type | Description |
|---|---|
| Task<String> | credential offer json: { "schema_id": string, "cred_def_id": string, // Fields below can depend on Cred Def type "nonce": string, "key_correctness_proof" : [key_correctness_proof] } |
IssuerCreateSchemaAsync(String, String, String, String)
Create credential schema entity that describes credential attributes list and allows credentials interoperability.
Schema is public and intended to be shared with all anoncreds workflow actors usually by publishing SCHEMA transaction to Indy distributed ledger.
It is IMPORTANT for current version POST Schema in Ledger and after that GET it from Ledger with correct seq_no to save compatibility with Ledger. After that can call indy_issuer_create_and_store_credential_def to build corresponding Credential Definition.
Declaration
public static Task<IssuerCreateSchemaResult> IssuerCreateSchemaAsync(string issuerDid, string name, string version, string attrs)
Parameters
| Type | Name | Description |
|---|---|---|
| String | issuerDid | DID of schema issuer |
| String | name | Name of the schema |
| String | version | Version of the schema |
| String | attrs | A list of schema attributes descriptions |
Returns
| Type | Description |
|---|---|
| Task<IssuerCreateSchemaResult> | schemaId: identifier of created schema schemaJson: schema as json |
IssuerMergeRevocationRegistryDeltasAsync(String, String)
Merge two revocation registry deltas (returned by indy_issuer_create_credential or indy_issuer_revoke_credential) to accumulate common delta. Send common delta to ledger to reduce the load.
Declaration
public static Task<string> IssuerMergeRevocationRegistryDeltasAsync(string revRegDelta, string otherRevRegDelta)
Parameters
| Type | Name | Description |
|---|---|---|
| String | revRegDelta | revocation registry delta. |
| String | otherRevRegDelta | revocation registry delta for which PrevAccum value is equal to current accum value of rev_reg_delta_json.. |
Returns
| Type | Description |
|---|---|
| Task<String> | merged_rev_reg_delta: Merged revocation registry delta. |
IssuerRevokeCredentialAsync(Wallet, BlobStorageReader, String, String)
Revoke a credential identified by a cred_revoc_id (returned by indy_issuer_create_credential).
The corresponding credential definition and revocation registry must be already created an stored into the wallet.
This call returns revoc registry delta as json file intended to be shared as REVOC_REG_ENTRY transaction. Note that it is possible to accumulate deltas to reduce ledger load.
Declaration
public static Task<string> IssuerRevokeCredentialAsync(Wallet wallet, BlobStorageReader blobStorageReader, string revRegId, string credRevocId)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | Wallet. |
| BlobStorageReader | blobStorageReader | configuration of blob storage reader handle that will allow to read revocation tails |
| String | revRegId | id of revocation registry stored in wallet |
| String | credRevocId | local id for revocation info. |
Returns
| Type | Description |
|---|---|
| Task<String> | revoc_reg_delta_json: Revocation registry delta json with a revoked credential. |
ProverCreateCredentialReqAsync(Wallet, String, String, String, String)
Creates a credential request for the given credential offer.
The method creates a blinded master secret for a master secret identified by a provided name. The master secret identified by the name must be already stored in the secure wallet (see prover_create_master_secret) The blinded master secret is a part of the credential request.
Declaration
public static Task<ProverCreateCredentialRequestResult> ProverCreateCredentialReqAsync(Wallet wallet, string proverDid, string credOfferJson, string credDefJson, string masterSecretId)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | Wallet. |
| String | proverDid | a DID of the prover. |
| String | credOfferJson | credential offer as a json containing information about the issuer and a credential. |
| String | credDefJson | credential definition json. |
| String | masterSecretId | the id of the master secret stored in the wallet. |
Returns
| Type | Description |
|---|---|
| Task<ProverCreateCredentialRequestResult> | cred_req_json: Credential request json for creation of credential by Issuer { "prover_did" : string, "cred_def_id" : string, // Fields below can depend on Cred Def type "blinded_ms" : [blinded_master_secret], "blinded_ms_correctness_proof" : [blinded_ms_correctness_proof], "nonce": string } cred_req_metadata_json: Credential request metadata json for processing of received form Issuer credential. |
ProverCreateMasterSecretAsync(Wallet, String)
Creates a master secret with the specified name and stores it in the provided wallet.
Declaration
public static Task<string> ProverCreateMasterSecretAsync(Wallet wallet, string masterSecretId)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | The target wallet. |
| String | masterSecretId | The name of the master secret. |
Returns
| Type | Description |
|---|---|
| Task<String> | An asynchronous Task that completes when the operation has completed. |
Remarks
The name of the master secret must be unique within the wallet.
ProverCreateProofAsync(Wallet, String, String, String, String, String, String)
Creates a proof according to the given proof request Either a corresponding credential with optionally revealed attributes or self-attested attribute must be provided for each requested attribute (see indy_prover_get_credentials_for_pool_req). A proof request may request multiple credentials from different schemas and different issuers. All required schemas, public keys and revocation registries must be provided. The proof request also contains nonce. The proof contains either proof or self-attested attribute value for each requested attribute.
Declaration
public static Task<string> ProverCreateProofAsync(Wallet wallet, string proofRequest, string requestedCredentials, string masterSecret, string schemas, string credentialDefs, string revStates)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | Wallet. |
| String | proofRequest | proof_request_json: proof request json { "name": string, "version": string, "nonce": string, "requested_attributes": { // set of requested attributes "(attr_referent)": (attr_info), // see below ..., }, "requested_predicates": { // set of requested predicates "(predicate_referent)": (predicate_info), // see below ..., }, "non_revoked": Optional [non_revoc_interval], // see below, // If specified prover must proof non-revocation // for date in this interval for each attribute // (can be overridden on attribute level) } |
| String | requestedCredentials | requested_credentials_json: either a credential or self-attested attribute for each requested attribute { "self_attested_attributes": { "self_attested_attribute_referent": string }, "requested_attributes": { "requested_attribute_referent_1": {"cred_id": string, "timestamp": Optional number, revealed: bool }}, "requested_attribute_referent_2": {"cred_id": string, "timestamp": Optional number, revealed: bool }} }, "requested_predicates": { "requested_predicates_referent_1": {"cred_id": string, "timestamp": Optional number }}, } }. |
| String | masterSecret | the id of the master secret stored in the wallet |
| String | schemas | schemas_json: all schemas json participating in the proof request { }. |
| String | credentialDefs | credential_defs_json: all credential definitions json participating in the proof request { "cred_def1_id": (credential_def1_json), "cred_def2_id": (credential_def2_json), "cred_def3_id": (credential_def3_json), }. |
| String | revStates | rev_states_json: all revocation states json participating in the proof request { "rev_reg_def1_id": { "timestamp1": (rev_state1), "timestamp2": (rev_state2), }, "rev_reg_def2_id": { "timestamp3": (rev_state3) }, "rev_reg_def3_id": { "timestamp4": (rev_state4) }, }. |
Returns
| Type | Description |
|---|---|
| Task<String> | Proof json For each requested attribute either a proof (with optionally revealed attribute value) or self-attested attribute value is provided. Each proof is associated with a credential and corresponding schema_id, cred_def_id, rev_reg_id and timestamp. There is also aggregated proof part common for all credential proofs. { "requested": { "revealed_attrs": { "requested_attr1_id": {sub_proof_index: number, raw: string, encoded: string}, "requested_attr4_id": {sub_proof_index: number: string, encoded: string}, }, "unrevealed_attrs": { "requested_attr3_id": {sub_proof_index: number} }, "self_attested_attrs": { "requested_attr2_id": self_attested_value, }, "requested_predicates": { "requested_predicate_1_referent": {sub_proof_index: int}, "requested_predicate_2_referent": {sub_proof_index: int}, } } "proof": { "proofs": [ (credential_proof), (credential_proof), (credential_proof) ], "aggregated_proof": (aggregated_proof) } "identifiers": [{schema_id, cred_def_id, Optional rev_reg_id , Optional timestamp}] } |
Remarks
where attr_referent: Proof-request local identifier of requested attribute attr_info: Describes requested attribute { "name": string, // attribute name, (case insensitive and ignore spaces) "restrictions": Optional ['attr_filter'] // see above, // if specified, credential must satisfy to one of the given restriction. "non_revoked": Optional [non_revoc_interval], // see below, // If specified prover must proof non-revocation // for date in this interval this attribute // (overrides proof level interval) } predicate_referent: Proof-request local identifier of requested attribute predicate predicate_info: Describes requested attribute predicate { "name": attribute name, (case insensitive and ignore spaces) "p_type": predicate type (Currently >= only) "p_value": predicate value "restrictions": Optional ['attr_filter'] // see above, // if specified, credential must satisfy to one of the given restriction. "non_revoked": Optional [non_revoc_interval], // see below, // If specified prover must proof non-revocation // for date in this interval this attribute // (overrides proof level interval) } non_revoc_interval: Defines non-revocation interval { "from": Optional int, // timestamp of interval beginning "to": Optional int, // timestamp of interval ending }
ProverGetCredentialsAsync(Wallet, String)
Gets human readable credentials according to the filter. If filter is NULL, then all credentials are returned. Credentials can be filtered by Issuer, credential_def and/or Schema.
Declaration
public static Task<string> ProverGetCredentialsAsync(Wallet wallet, string filterJson)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | Wallet. |
| String | filterJson | filter_json: filter for credentials { "schema_id": string, (Optional) "schema_issuer_did": string, (Optional) "schema_name": string, (Optional) "schema_version": string, (Optional) "issuer_did": string, (Optional) "cred_def_id": string, (Optional) } |
Returns
| Type | Description |
|---|---|
| Task<String> | /// credentials json [{ "referent": string, // cred_id in the wallet "values": [see cred_values_json above], "schema_id": string, "cred_def_id": string, "rev_reg_id": Optional string, "cred_rev_id": Optional string }]. |
ProverGetCredentialsForProofReqAsync(Wallet, String)
Gets human readable credentials matching the given proof request.
Declaration
public static Task<string> ProverGetCredentialsForProofReqAsync(Wallet wallet, string proofRequestJson)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | Wallet. |
| String | proofRequestJson | /// proof_request_json: proof request json { "name": string, "version": string, "nonce": string, "requested_attributes": { // set of requested attributes "[attr_referent]": [attr_info], // see below ..., }, "requested_predicates": { // set of requested predicates "[predicate_referent]": [predicate_info], // see below ..., }, "non_revoked": Optional [non_revoc_interval], // see below, // If specified prover must proof non-revocation // for date in this interval for each attribute // (can be overridden on attribute level) } where attr_referent: Proof-request local identifier of requested attribute attr_info: Describes requested attribute { "name": string, // attribute name, (case insensitive and ignore spaces) "restrictions": Optional ['attr_filter'] // see below, // if specified, credential must satisfy to one of the given restriction. "non_revoked": Optional [non_revoc_interval], // see below, // If specified prover must proof non-revocation // for date in this interval this attribute // (overrides proof level interval) } predicate_referent: Proof-request local identifier of requested attribute predicate predicate_info: Describes requested attribute predicate { "name": attribute name, (case insensitive and ignore spaces) "p_type": predicate type (Currently >= only) "p_value": predicate value "restrictions": Optional ['attr_filter'] // see below, // if specified, credential must satisfy to one of the given restriction. "non_revoked": Optional [non_revoc_interval], // see below, // If specified prover must proof non-revocation // for date in this interval this attribute // (overrides proof level interval) } non_revoc_interval: Defines non-revocation interval { "from": Optional int, // timestamp of interval beginning "to": Optional int, // timestamp of interval ending } filter: see filter_json above |
Returns
| Type | Description |
|---|---|
| Task<String> | credentials_json: json with credentials for the given proof request. { "requested_attrs": { "[attr_referent]": [{ cred_info: (credential_info), interval: Optional(non_revoc_interval) }], ..., }, "requested_predicates": { "requested_predicates": [{ cred_info: (credential_info), timestamp: Optional integer }, { cred_info: (credential_2_info), timestamp: Optional integer }], "requested_predicate_2_referent": [{ cred_info: (credential_2_info), timestamp: Optional integer }] } }, where credential is { "referent": string, "attrs": [{"attr_name" : "attr_raw_value"}], "schema_id": string, "cred_def_id": string, "rev_reg_id": Optional int, "cred_rev_id": Optional int, } |
ProverStoreCredentialAsync(Wallet, String, String, String, String, String, String)
Check credential provided by Issuer for the given credential request, updates the credential by a master secret and stores in a secure wallet.
Declaration
public static Task<string> ProverStoreCredentialAsync(Wallet wallet, string credId, string credReqJson, string credReqMetadataJson, string credJson, string credDefJson, string revRegDefJson)
Parameters
| Type | Name | Description |
|---|---|---|
| Wallet | wallet | Wallet. |
| String | credId | (optional, default is a random one) identifier by which credential will be stored in the wallet |
| String | credReqJson | a credential request created by indy_prover_create_credential_req. |
| String | credReqMetadataJson | a credential request metadata created by indy_prover_create_credential_req |
| String | credJson | credential json received from issuer. |
| String | credDefJson | redential definition json. |
| String | revRegDefJson | revocation registry definition json. |
Returns
| Type | Description |
|---|---|
| Task<String> | out_cred_id: identifier by which credential is stored in the wallet. |
UpdateRevocationStateAsync(BlobStorageReader, String, String, String, Int64, String)
Create new revocation state for a credential based on existed state at the particular time moment (to reduce calculation time).
Declaration
public static Task<string> UpdateRevocationStateAsync(BlobStorageReader blobStorageReader, string revState, string revRegDef, string revRegDelta, long timestamp, string credRevId)
Parameters
| Type | Name | Description |
|---|---|---|
| BlobStorageReader | blobStorageReader | configuration of blob storage reader handle that will allow to read revocation tails. |
| String | revState | revocation registry state json |
| String | revRegDef | revocation registry definition json |
| String | revRegDelta | revocation registry definition delta json. |
| Int64 | timestamp | time represented as a total number of seconds from Unix Epoch. |
| String | credRevId | user credential revocation id in revocation registry. |
Returns
| Type | Description |
|---|---|
| Task<String> | revocation state json: { "rev_reg": <revocation registry>, "witness": <witness>, "timestamp" : integer } . |
VerifierVerifyProofAsync(String, String, String, String, String, String)
Verifies a proof (of multiple credential). All required schemas, public keys and revocation registries must be provided.
Declaration
public static Task<bool> VerifierVerifyProofAsync(string proofRequest, string proof, string schemas, string credentialDefs, string revocRegDefs, string revocRegs)
Parameters
| Type | Name | Description |
|---|---|---|
| String | proofRequest | proof_request_json: proof request json { "name": string, "version": string, "nonce": string, "requested_attributes": { // set of requested attributes "(attr_referent)": (attr_info), // see below ..., }, "requested_predicates": { // set of requested predicates "[predicate_referent]": (predicate_info), // see below ..., }, "non_revoked": Optional [non_revoc_interval], // see below, // If specified prover must proof non-revocation // for date in this interval for each attribute // (can be overridden on attribute level) } |
| String | proof | proof_json: created for request proof json { "requested": { "revealed_attrs": { "requested_attr1_id": {sub_proof_index: number, raw: string, encoded: string}, "requested_attr4_id": {sub_proof_index: number: string, encoded: string}, }, "unrevealed_attrs": { "requested_attr3_id": {sub_proof_index: number} }, "self_attested_attrs": { "requested_attr2_id": self_attested_value, }, "requested_predicates": { "requested_predicate_1_referent": {sub_proof_index: int}, "requested_predicate_2_referent": {sub_proof_index: int}, } } "proof": { "proofs": [ <credential_proof>, <credential_proof>, <credential_proof> ], "aggregated_proof": <aggregated_proof> } "identifiers": [{schema_id, cred_def_id, Optional<rev_reg_id>, Optional timestamp }] }. |
| String | schemas | schemas_json: all schema jsons participating in the proof { <schema1_id>: <schema1_json>, <schema2_id>: <schema2_json>, <schema3_id>: <schema3_json>, }. |
| String | credentialDefs | credential_defs_json: all credential definitions json participating in the proof { "cred_def1_id": <credential_def1_json>, "cred_def2_id": <credential_def2_json>, "cred_def3_id": <credential_def3_json>, } |
| String | revocRegDefs | rev_reg_defs_json: all revocation registry definitions json participating in the proof { "rev_reg_def1_id": <rev_reg_def1_json>, "rev_reg_def2_id": <rev_reg_def2_json>, "rev_reg_def3_id": <rev_reg_def3_json>, }. |
| String | revocRegs | rev_regs_json: all revocation registries json participating in the proof { "rev_reg_def1_id": { "timestamp1": <rev_reg1>, "timestamp2": <rev_reg2>, }, "rev_reg_def2_id": { "timestamp3": <rev_reg3> }, "rev_reg_def3_id": { "timestamp4": <rev_reg4> }, } |
Returns
| Type | Description |
|---|---|
| Task<Boolean> | The verify proof async. |


Retrieves a 'pluscode' by inputting latitude and longitude. Includes additional functions to retrieve neighbouring 'pluscodes'.
| Version: | 0.1.0 |
| Imports: | httr, jsonlite |
| Published: | 2018-11-14 |
| Author: | Michael Doyle |
| Maintainer: | Michael Doyle <michaeledoyle7 at gmail.com> |
| License: | GPL-2 |
| NeedsCompilation: | no |
| CRAN checks: | pluscode results |
| Reference manual: | pluscode.pdf |
| Package source: | pluscode_0.1.0.tar.gz |
| Windows binaries: | r-devel: pluscode_0.1.0.zip, r-release: pluscode_0.1.0.zip, r-oldrel: pluscode_0.1.0.zip |
| OS X binaries: | r-release: pluscode_0.1.0.tgz, r-oldrel: pluscode_0.1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=pluscode to link to this page.


Access the panel and log in with your account. If you don't have an account yet , create one .
AUTHENTIFICATION WITH KEY API


WITNESS LIST Natural Resources Committee March 23, 1999-2:00P SB 296 THIS LIST HAS NO WITNESSES. SB 513 Registering, but not testifying: On: Schlimper, Paul (General Services Commission - Special projects), Austin SB 897 THIS LIST HAS NO WITNESSES. SB 898 THIS LIST HAS NO WITNESSES. SB 991 FOR: Halbert, Wayne (Texas Irrigation Council - Legislative Director), Harlingen ON: Brittin, Carolyn (Texas Water Development Board - Director of Special Projects), Austin Registering, but not testifying: For: Powers, Bill (Texas Farm Bureau - State Legislative Director), Austin On: Neal, Don (TNRCC - Director, Water Quantity Division), Austin SB 1096 FOR: Burr, Thomas (Angelina & Neches River Authority - General Manager), Lufkin Kindle, Glenda (Vice-Chair, Lake Eastex Planning), Frankston Lilly, Susan (City of Nacogdoches - Governmental Relations), Austin Mallory, Tom (Upper Neches River Authority - General Manager), Palestine AGAINST: Carnahan, Karen (Huntsman Corporation - Public Affairs Manager), Port Neches Cooper, Gaylyn (Lower Neches Valley Authority - Secretary & Member of the Board), Beaumont Darling, Robert (Port Arthur Chamber of Commerce), Port Arthur Hebert, A. Tommy (Lower Neches Valley Authority - General Manager), Beaumont McKelvey, Robert (City of Palestine, Mayor), Palestine Monroe, W. Sam (Port Arthur Chamber of Commerce - Chairman), Port Arthur Neild, Patty (LNVA - Vice-President), Beaumont Oxford, Hubert (Lower Neches River Authority - Attorney), Beaumont Snow, Curtis (City of Palestine - City Manager), Palestine Registering, but not testifying: Against: Batty, Barbara (Port Arthur Chamber of Commerce - Political Issues), Port Neches Griffith, Carl (Jefferson County - judge), Beaumont Herrington, Jimmy (PACE 4-243, President), Beaumont Jenkins, David (Texas Rice Producers Legislative Group - member), Stowell Kelly, Mike (Port Arthur Chamber of Commerce - Director/Treasurer), Port Arthur Rutherford, Verna (Port Arthur Chamber - President), Port Arthur On: Jones, Samuel (TNRCC - Manager, District Administration Section), Austin SB 1165 FOR: Douglas, Craig (Daenner & Stuart, LLP/Stratus Properties), Austin Registering, but not testifying: For: Freeman, Ronald (Phoenix Holdings, Inc. - Law offices of Ronald J. Freeman), Austin On: Vogel, Joe (TNRCC - Deputy Director - Compliance & Enforcement), Austin SB 1184 Registering, but not testifying: On: Smith, Kenneth (Railroad Commission of Texas - Adm. Assistant), Austin SB 1297 THIS LIST HAS NO WITNESSES. SB 1476 AGAINST: Darling, Robert (Port Arthur Chamber of Commerce - member), Port Arthur Monroe, W. Sam (Port Arthur Chamber of Commerce - Chairman), Port Arthur Oxford, Hubert (Lower Neches River Authority - Attorney), Beaumont ON: Petersen, Ken (TNRCC - Deputy Director, Office of Water), Austin Registering, but not testifying: Against: Batty, Barbara (Port Arthur Chamber of Commerce - member), Port Neches Kelly, Mike (Port Arthur Chamber of Commerce - Director/ Treasurer), Port Arthur Rutherford, Verna (Port Arthur Chamber of Commerce - President), Port Arthur SCR 17 THIS LIST HAS NO WITNESSES.


[Gecode] Removed old CVS
Denys Duchier
duchier at ps.uni-sb.de
Tue Jul 27 21:15:25 CEST 2004
Guido Tack <tack at ps.uni-sb.de> writes:
> I have now removed the old CVS tree. The log messages still go to the ps.cvs
> news group, I don't know if we should add a gecode.cvs news group or archive
> the messages in any other way.
I am in favor of a gecode.cvs group. The gecode abstract
infrastructure should be factored out separately from the ps lab's
(eventhough it is currently concretely realized and hosted on ps lab
facilities).
Cheers,
--
Dr. Denys Duchier - Équipe Calligramme - LORIA, Nancy, FRANCE
AIM: duchierdenys
More information about the gecode-users
mailing list


PHY321: Classical Mechanics 1
Contents
PHY321: Classical Mechanics 1¶
Homework 5, due Friday February 18
Date: Feb 6, 2022
Practicalities about homeworks and projects¶
You can work in groups (optimal groups are often 2-3 people) or by yourself. If you work as a group you can hand in one answer only if you wish. Remember to write your name(s)!
Homeworks are available ten days before the deadline.
How do I(we) hand in? You can hand in the paper and pencil exercises as a scanned document. For this homework this applies to exercises 1-5. Alternatively, you can hand in everyhting (if you are ok with typing mathematical formulae using say Latex) as a jupyter notebook at D2L. The numerical exercise(s) (exercise 6 here) should always be handed in as a jupyter notebook by the deadline at D2L.
Introduction to homework 5¶
This week’s sets of classical pen and paper and computational exercises are a continuation of the topics from the previous homework set and lectures from the last two weeks. We keep dealing with simple motion problems and conservation laws; energy, momentum and angular momentum. These conservation laws are central in Physics and understanding them properly lays the foundation for understanding and analyzing more complicated physics problems.
The relevant reading background is
chapters 3 and 4 of Taylor (there are many good examples there) and
chapters 10-14 of Malthe-Sørenssen.
For the numerical exercise, see Malthe-Sørenssen section 7.5
In both textbooks there are many nice worked out examples. Malthe-Sørenssen’s text contains also several coding examples you may find useful.
The numerical homework focuses on another motion problem where you can use the code you developed in homework sets 3 and 4, almost entirely. Please take a look at the posted solutions (jupyter-notebook) for homework sets 3 and 4. You need only to change the forces at play. The problem at hand is a classic, the gravitational force acting between the Sun and the Earth. Here you will notice also that the standard Euler-integration algorithm is not the best choice and we will introduce the so-called Euler-Cromer method and the Velocity-Verlet method. These methods will give much more stable numerical results with only few additions to your code.
The code you develop here will also be reused when we analyze energy conservation in homework set 6. And for those of you doing the honors project, it serves as a starting point for the solar system variant.
Exercise 1 (15 pt), Work-energy theorem and conservation laws¶
This exercise was partly discussed during the lectures of the week of February 8-12, see https://mhjensen.github.io/Physics321/doc/pub/week6/html/week6.html.
We will study a classical electron which moves in the \(x\)-direction along a surface. The force from the surface is
The constant \(b\) represents the distance between atoms at the surface of the material, \(F_0\) is a constant and \(x\) is the position of the electron.
1a (2pt) Is this a conservative force? And if so, what does that imply?
1b (4pt) Use the work-energy theorem to find the velocity \(v(x)\).
1c (4pt) With the above expression for the force, find the potential energy.
1d (5pt) Make a plot of the potential energy and discuss the equilibrium points where the force on the electron is zero. Discuss the physical interpretation of stable and unstable equilibrium points. Use energy conservation. Recommended read here is Malthe-Sørenssen chapter 11.3.2.
Exsercise 2 (15pt), Rocket, Momentum and mass¶
Taylor exercise 3.11. This exercise is meant to illustrate momentum conservation or not. This exercise was partly discussed during the lectures, see the notes from the week of February 8-12 on Energy and Momentum etc, see the part on Momentum conservation. Taylor’s chapter 3.2 covers also this example.
Exercise 3 (10pt), More Rockets¶
Taylor exercises 3.13 (5pt) and 3.14 (5pt). This is a continuation of the previous exercise and most of the relevant background material can be found in Taylor chapter 3.2.
Exercise 4 (10pt), Center of mass¶
Taylor exercise 3.20. Here Taylor’s chapter 3.3 can be of use. This relation will turn out to be very useful when we discuss systems of many classical particles.
Exercise 5 (10pt), Warming up for the Earth-Sun system, Scaling the Equations¶
The aim of this exercise (as well as the next) is to study the motion of objects under the influence of the gravitational force. We will limit ourselves to the Earth-Sun system. Here we will scale the equations and sketch our first algorithm for solving the equations, namely using Euler’s method again, as we did in homework sets 3 and 4. This part together with the numerical part forms also the entry point for the solar system honors project. Furthermore, we will reuse parts of these results when analyzing energy conservation in homework 6.
We will limit ourselves (in order to test the algorithm) to a hypothetical solar system with the Earth only orbiting around the sun. The only force in the problem is gravity. Newton’s law of gravitation is given by a force \(F_G\)
where \(M_{\odot}\) is the mass of the Sun and \(M_{\mathrm{Earth}}\) is the mass of the Earth. The gravitational constant is \(G\) and \(r\) is the distance between the Earth and the Sun. The Sun has a mass which is much larger than that of the Earth. We can therefore safely neglect the motion of the Sun in this problem.
We assume that the orbit of the Earth around the Sun is co-planar, and we take this to be the \(xy\)-plane. Using Newton’s second law of motion we get the following equations
and
where \(F_{G,x}\) and \(F_{G,y}\) are the \(x\) and \(y\) components of the gravitational force.
We will use so-called astronomical units when rewriting our equations. Using astronomical units (AU as abbreviation)it means that one astronomical unit of length, known as 1 AU, is the average distance between the Sun and Earth, that is \(1\) AU = \(1.5\times 10^{11}\) m. It can also be convenient to use years instead of seconds since years match better the time evolution of the solar system. The mass of the Sun is \(M_{\mathrm{sun}}=M_{\odot}=2\times 10^{30}\) kg. The mass of Earth is \(M_{\mathrm{Earth}}=6\times 10^{24}\) kg with a distance 1AU.
In setting up the equations we limit ourselves to a co-planar motion and use only the \(x\) and \(y\) coordinates. But you should feel free to extend your equations to three dimensions, it is not very difficult and the data from NASA are all in three dimensions.
NASA has an excellent site at http://ssd.jpl.nasa.gov/horizons.cgi#top. From there you can extract initial conditions in order to start your differential equation solver. At the above website you need to change from OBSERVER to VECTOR and then write in the planet you are interested in. The generated data contain the \(x\), \(y\) and \(z\) values as well as their corresponding velocities. The velocities are in units of AU per day. Alternatively they can be obtained in terms of km and km/s.
For the system below involving only the Earth and the Sun, you could just initialize the position with say \(x=1\) AU and \(y=0\) AU.
We assume that mass units can be obtained by using the fact that Earth’s orbit is almost circular around the Sun.
For circular motion we know that the force must obey the following relation
where \(v\) is the velocity of Earth. The latter equation can be used to show that
5a (5pt) Show how to derive the last equation and use this to scale the differential equations, getting thus rid of the constant \(G\) and the two masses. Split the differential equations for the motion in the \(x\) and \(y\) directions in terms of four coupled differential equations.
5b (5pt) Discretize the above differential equations and set up an algorithm for solving these equations using Euler’s forward algorithm and the so-called velocity Verlet method discussed in the lecture notes. Here you can reuse what you did in homework sets 3 and 4.
Exercise 6 (40pt), Numerical elements, solving exercise 5 numerically¶
This exercise should be handed in as a jupyter-notebook at D2L. Remember to write your name(s).
In homework sets 3 and 4 we:
studied Euler’s Method to find the position and the velocity of a falling object, including air resistance and gravity
and added additional forces to our model and studied a bouncing ball.
This week we will reuse our code from homework 4 (exercises 6) and replace the air resistance and force from the ground with the gravitational force. Then we will study the stability of the system as function of initial conditions and the time step length.
We start by importing some standard packages
%matplotlib inline
# let's start by importing useful packages we are familiar with
import numpy as np
from math import *
import matplotlib.pyplot as plt
%matplotlib inline
6a (30 pt) Write then a program which solves the above differential equations for the Earth-Sun system using Euler’s method and the velocity Verlet method. Find out which initial value for the velocity that gives a circular orbit and test the stability of your algorithm as function of different time steps \(\Delta t\). Make a plot of the results you obtain for the position of the Earth (plot the \(x\) and \(y\) values and/or if you prefer to use three dimensions the \(z\)-value as well) orbiting the Sun. Discuss eventual differences between the Verlet algorithm and the Euler algorithm.
6b (10pt) Consider then a planet which begins at a distance of 1 AU from the sun. Find out by trial and error what the initial velocity must be in order for the planet to escape from the sun. Can you find an exact answer? How does that match your numerical results?
Here we add a code-example which may aid in the above studies using Euler’s forward method.
DeltaT = 0.001
#set up arrays
tfinal = 10 # in years
n = ceil(tfinal/DeltaT)
# set up arrays for time t, velocity v, and position r
t = np.zeros(n)
v = np.zeros((n,2))
r = np.zeros((n,2))
# Initial conditions as compact 2-dimensional arrays
r0 = np.array([1.0,0.0])
v0 = np.array([0.0,2*pi])
r[0] = r0
v[0] = v0
Fourpi2 = 4*pi*pi
# Start integrating using Euler's method
for i in range(n-1):
# Set up the acceleration
# Here you could have defined your own function for this
rabs = sqrt(sum(r[i]*r[i]))
a = -Fourpi2*r[i]/(rabs**3)
# update velocity, time and position using Euler's forward method
v[i+1] = v[i] + DeltaT*a
r[i+1] = r[i] + DeltaT*v[i]
t[i+1] = t[i] + DeltaT
Classical Mechanics Extra Credit Assignment: Scientific Writing and attending Talks¶
The following gives you an opportunity to earn five extra credit points on each of the remaining homeworks and ten extra credit points on the midterms and finals. This assignment also covers an aspect of the scientific process that is not taught in most undergraduate programs: scientific writing. Writing scientific reports is how scientist communicate their results to the rest of the field. Knowing how to assemble a well written scientific report will greatly benefit you in you upper level classes, in graduate school, and in the work place.
The full information on extra credits is found at https://github.com/mhjensen/Physics321/blob/master/doc/Homeworks/ExtraCredits/. There you will also find examples on how to write a scientific article. Below you can also find a description on how to gain extra credits by attending scientific talks.
This assignment allows you to gain extra credit points by practicing your scientific writing. For each of the remaining homeworks you can submit the specified section of a scientific report (written about the numerical aspect of the homework) for five extra credit points on the assignment. For the two midterms and the final, submitting a full scientific report covering the numerical analysis problem will be worth ten extra points. For credit the grader must be able to tell that you put effort into the assignment (i.e. well written, well formatted, etc.). If you are unfamiliar with writing scientific reports, see the information here
The following table explains what aspect of a scientific report is due with which homework. You can submit the assignment in any format you like, in the same document as your homework, or in a different one. Remember to cite any external references you use and include a reference list. There are no length requirements, but make sure what you turn in is complete and through. If you have any questions, please contact Julie Butler at<EMAIL_ADDRESS>| HW/Project | Due Date | Extra Credit Assignment |
|---|---|---|
| HW 3 | 2-8 | Abstract |
| HW 4 | 2-15 | Introduction |
| HW 5 | 2-22 | Methods |
| HW 6 | 3-1 | Results and Discussion |
| **Midterm 1** | **3-12** | *Full Written Report* |
| HW 7 | 3-22 | Abstract |
| HW 8 | 3-29 | Introduction |
| HW 9 | 4-5 | Results and Discussion |
| **Midterm 2 | ** _4-16_ | *Full Written Report* |
| HW 10 | 4-26 | Abstract |
| **Final** | **4-30** | *Full Written Report* |
You can also gain extra credits if you attend scientific talks. This is described here.
Integrating Classwork With Research¶
This opportunity will allow you to earn up to 5 extra credit points on a Homework per week. These points can push you above 100% or help make up for missed exercises. In order to earn all points you must:
Attend an MSU research talk (recommended research oriented Clubs is provided below)
Summarize the talk using at least 150 words
Turn in the summary along with your Homework.
Approved talks: Talks given by researchers through the following clubs:
Research and Idea Sharing Enterprise (RAISE): Meets Wednesday Nights Society for Physics Students (SPS): Meets Monday Nights
Astronomy Club: Meets Monday Nights
Facility For Rare Isotope Beam (FRIB) Seminars: Occur multiple times a week
If you have any questions please consult Jeremy Rebenstock<EMAIL_ADDRESS>All the material on extra credits is at https://github.com/mhjensen/Physics321/blob/master/doc/Homeworks/ExtraCredits/.


In preparation for my current job hunt, I recently revisited a project I worked on last year for inclusion in my portfolio: a Facebook clone called Odinbook that I built with Rails. As I was poking around to make sure that everything was working as it should, I noticed, to my chagrin, that omniauth user authentication through Facebook was not operational. I took a look at my terminal to see what the trouble could be and plucked out the relevant section amongst the gaggle of server logs:
Started GET "/accounts/auth/facebook" for <IP_ADDRESS> at 2019-09-26 13:51:16 -0700
(facebook) Request phase initiated.
Started GET "/accounts/auth/facebook" for <IP_ADDRESS> at 2019-09-26 13:51:16 -0700
(facebook) Request phase initiated.
Started GET "/accounts/auth/facebook/callback?code=AQAkA70qdFAPf-ZfnGx8YsZxyxVuAMf3XbniAcRi-PxoV
LAou9WB8E9vIdBNwvLW6VnglZaaC8e4avqphTqnJqxE_32_5vhB3zdpzSg96pmLxtuLAUgMj8QP2oxMi8VMZBy-bfJcC-HnI
fXok0QHeqZBR5B2MQhe-PCiVEiRPQcfo8CC7V_c0BSpzR2ssEPTGZnYiFbLblacFLKum16PlTuZbGjlsIZozVf2wrXLrQuCK
BxwQXW3hVQCkrhS7Eni9oCju5r1qVjS9DRHjR6SrVCS0nIoeWZtqL4kXDEHXrh9pd9mcgBtEetoJHJWujELtgY-NDyUJ2aAL
0qksEG0lZtEMIpCvIXGLu_ea15fNMjKvg&state=df105568f8d68638f3f6fafcd5cc0bc0a681340d686ae99e" for <IP_ADDRESS> at 2019-09-26 13:51:16 -0700
(facebook) Callback phase initiated.
(facebook) Callback phase initiated.
(facebook) Authentication failure! invalid_credentials: OAuth2::Error, {"message"=>"This authorization code has been used.",
"type"=>"OAuthException", "code"=>100, "fbtrace_id"=>"Ag-7uiDdGQoX6-5NndyIEf0"}:
{"error":{"message":"This authorization code has been used.","type":"OAuthException","code":100,"fbtrace_id":"Ag-7uiDdGQoX6-5NndyIEf0"}}
From the above we can see that the callback phase was being initiated twice in succession, causing the same authorization code to be passed to Facebook twice resulting in the authentication error seen just below the callback initiation entries.
The issue was a bit of a head-scratcher; I had adhered to the omniauth-facebook gem’s documentation, setting up an omniauth.rb initializer in app/config/initializers to apply the omniauth middleware with the following code:
Rails.application.config.middleware.use OmniAuth::Builder do
provider :facebook, ENV['app_ID'], ENV['app_secret']
End
It was a comment on Stack Overflow from a post on a related, but not totally identical problem that clued me into the solution:
-do we need to have the fb config twice 1. devise.rb and 2. omniauth.rb ?
-No, if you are using devise, you only have to set it in devise.rb
Eureka! I am indeed utilizing Devise for authentication in this app, so after reading this small exchange I opened up the app/config/initializers/devise.rb file and sure enough, I had already set the omniauth config there:
config.omniauth :facebook, Figaro.env.app_ID, Figaro.env.app_secret
I commented out the code in my omniauth.rb file and all was once again well; I was able to both create a new account and authenticate an existing account with Facebook and the server log confirmed the story:
Started GET "/accounts/auth/facebook" for <IP_ADDRESS> at 2019-09-26 13:53:18 -0700
(facebook) Request phase initiated.
Started GET "/accounts/auth/facebook" for <IP_ADDRESS> at 2019-09-26 13:53:19 -0700
(facebook) Request phase initiated.
Started GET "/accounts/auth/facebook/callback?code=AQARrTnw2WA-oT9kEqacKF2cw-Sz5BPSib-6DCaUuqORLISWqcysUzHLXCfPhD_yYMfoTJDl--LARJ8tKhUfd0L1_mxKV3wNfSutHtd4EyxvBq9-9OQHChKH595raR-ayX_grIIaeVlSjLir-3O50sFGNrRDNlM2eH5cchBXENzcKGWv2w1SPbQcTiUoZCixKj1e0aERYbBrmrpO5Ud5WV4FNIt0RITydJ_L-NY6uJnzw5Xw8jZGOLcACM05S-XlVXDAITEohzKUiW32kGmw14VNqfaS8y8ugaI5eB-9LBbe9Yzul2hWbmBbj70cuT8HVE7FNLn_RinfpmiVud0RwmWwX5O-Raj9X623WPVLxqEkbA&state=a2e81b04ce02b698429e4bdb6f5b8b01f0e2b09aac8dc048" for <IP_ADDRESS> at 2019-09-26 13:53:19 -0700
(facebook) Callback phase initiated.
Processing by Users::OmniauthCallbacksController#facebook as HTML
Parameters: {"code"=>"AQARrTnw2WA-oT9kEqacKF2cw-Sz5BPSib-6DCaUuqORLISWqcysUzHLXCfPhD_yYMfoTJDl--LARJ8tKhUfd0L1_mxKV3wNfSutHtd4EyxvBq9-9OQHChKH595raR-ayX_grIIaeVlSjLir-3O50sFGNrRDNlM2eH5cchBXENzcKGWv2w1SPbQcTiUoZCixKj1e0aERYbBrmrpO5Ud5WV4FNIt0RITydJ_L-NY6uJnzw5Xw8jZGOLcACM05S-XlVXDAITEohzKUiW32kGmw14VNqfaS8y8ugaI5eB-9LBbe9Yzul2hWbmBbj70cuT8HVE7FNLn_RinfpmiVud0RwmWwX5O-Raj9X623WPVLxqEkbA", "state"=>"a2e81b04ce02b698429e4bdb6f5b8b01f0e2b09aac8dc048"}
Only one callback phase initiation!
So with that issue solved, I turned my attention to the duplicate request phases at the top of the excerpt above. While it didn’t appear to be causing any immediate problems, I was uncomfortable with it in principle and worried that it may eventually lead to a tricky bug down the road. A little google searching lead me to the culprit: turbolinks. I disabled turbolinks for the Oauth link like so:
<%= link_to "Sign in with #{OmniAuth::Utils.camelize(provider)}",
user_facebook_omniauth_authorize_path(resource), data: {turbolinks: false} %>
and the repeat request was eliminated:
Started GET "/accounts/auth/facebook" for <IP_ADDRESS> at 2019-10-02 08:45:25 -0700
(facebook) Request phase initiated.
Started GET "/accounts/auth/facebook/callback?code=AQArPbmhcOlJU9woExRzl4FIoPN1gU2FredV_OyZRuvnAoPZXA5IQkeywGaYQYeLhgzrhwWS1clKMS9HcmWYKoRDPMNqv4rfPC1Vibgsg6Y5cQbTJDd45V1dP5tMppEkeeBq
EFI7PiL-VJmE6dqNNq2EiVaXRIdPxxPRlJkvy01Nf2Wqa9efzmDqhjC-bVfKkEgxF61WiXYA6hd3wbVklsUBj7JSZ
j-mEF0v_IHpAgUE240dqz23r-iciBUmmXxaZi0ofCsbaVMnILGA3Vn8Wxt2IiwyYVxd2zfIF81eBILlJkGxjmoCOX
RaDupHLAe90MGC0SFVuK1mdRVm4XiLhWJeAGoErkj03Z_TppC3xjJaFw&state=ff4143b2b2a5786d0cd9f278bd
34e7835b3af747a274326c" for <IP_ADDRESS> at 2019-10-02 08:45:25 -0700
(facebook) Callback phase initiated.
Processing by Users::OmniauthCallbacksController#facebook as HTML
Parameters: {"code"=>"AQArPbmhcOlJU9woExRzl4FIoPN1gU2FredV_OyZRuvnAoPZXA5IQkeywGaYQYeLhgzrhw
WS1clKMS9HcmWYKoRDPMNqv4rfPC1Vibgsg6Y5cQbTJDd45V1dP5tMppEkeeBqEFI7PiL-VJmE6dqNNq2EiVaXR
IdPxxPRlJkvy01Nf2Wqa9efzmDqhjC-bVfKkEgxF61WiXYA6hd3wbVklsUBj7JSZj-mEF0v_IHpAgUE240dqz23
r-iciBUmmXxaZi0ofCsbaVMnILGA3Vn8Wxt2IiwyYVxd2zfIF81eBILlJkGxjmoCOXRaDupHLAe90MGC0SFVuK1
mdRVm4XiLhWJeAGoErkj03Z_TppC3xjJaFw", "state"=>"ff4143b2b2a5786d0cd9f278bd34e7835b3af747a274326c"}
So TLDR, if you’re using both Devise and Omniauth-facebook (and I’d imagine omniauth gems for authentication through other sites), an omniauth.rb file is not necessary if you configure omniauth in your devise.rb file. Also, in the event of duplicate GET request, it may be resolved by disabling turbolinks.


| Description of Study Design | |||
| Description of Interventions | |||
| Randomized Study? | |||
| Blinding | |||
| Control | |||
| Study Configuration | |||
| Subject Participation Duration | |||
| Primary Endpoint | |||
|
|||
| Other Endpoints | |||
|
|
| Subject Age | ||||||
|
||||||
| Study uses Healthy Subjects? | ||||||
| Subject Gender | ||||||
| Inclusion Criteria | ||||||
|
|
||||||
| Exclusion Criteria | ||||||
|
|
Study Day: 1
DateTimeStudy Day: 1
DateTime: TodayStudy Day: 1
DateTime: TodayStudy day 4
DateTimeStudy day 8
DateTimeStudy day 12
DateTime


Questioner
Signup Form
Your password should be between six and 18 characters long.
Already a member? Login below.
LOGIN


This fancy new website is going show off how fabulous Josh Argle's cats and Mercedes cars are!
The Artist, Joshua Argle, aka Shag, was a prolific producer of contemporary art in the late 1950's to 60's. His images featured many stylised forms including cats, tikis (tribal figures), aeroplanes, scooters, cocktail drinks, lamps and buildings. Each art piece is very reflective of the era and showcased the newer contemporary trends of the time. eg. air travel was something new and opening to the general public .
Josh was born in 1962 in California. He studied Economics and Architecture before finally in Graphic Design. He has exhibited in USA, UK and Japan. His first New York Gallery show was in 2002. In 2009 he opened the SHAG STORE in Palm Springs which sells merchandise based on his work. He lives with his wife and two children in Orange County, California.
I am restoring a Mercedes Benz 170S which was an important car for Mercedes as it was the first car that they were able to bring inot production after the end of World War II. If my daughter had her way she would have me spray paint it pink.
>


I am a Nothern Ontario local, though I was born in Calgary, I was raised in Kenora. I enjoy coding, skiing, and entertaining friends in my spare time. I have built my own PCs and enjoy working on PC hardware, making the PC run faster and perform better. One day I hope to be able to work in the IT/Programing fields doing what I love. Writing code and building PC's.
Let's Look at My Social Media


Input:
Processing code:
Process
Output:
Demo source code:
https://github.com/asvd/jailed/tree/master/demos/web/process/
Scrolling indicator:
https://asvd.github.com/intence/
data processing
The input data is shipped by the application. User-submitted code for processing the data is evaluated in a Plugin created with the
Jailed
library. The code is executed in a sandboxed iframe in order to prevent accessing the main application.


Thu Sep 11, 2003
Yesterday Sulu and I went to Everland, the seventh largest amusement park in the world. Unfortunately for us, yesterday was also the first day of Chuseok, which meant about 12 million Koreans were making the exodus south to their hometowns. In a fantastically unwise move, we took public transit…so, we ended up standing in a crowded bus in a traffic jam for about four hours (it usually takes 40 minutes).  When we all finally tumbled off the bus everyone started stretching and jumping around for joy.
Everland was lots of fun, although at first my body went into involuntary shock from the crazy rides even astronauts would find challenging I’m sure. Anyways, by the end of the night I was quite accustomed to being hurled upside down and spun around at neck-breaking speeds and I wanted to do them all one more time. I guess it’s kind of like Disney land, they had a huge fireworks show and an erupting volcano as a finale. On the ride home I kept falling asleep and having spurts of vivid dreaming, probably in response to a sensory overload.


Contribute¶
Thank you for choosing to contribute to hylia. There are a ton of great open-source projects out there, so we appreciate your interest in contributing to hylia. It is an open-source, machine learning time series library in Python for network operations. Please contact<EMAIL_ADDRESS>if you have any questions. In this documentation, we will cover a couple of ways you can contribute to this project.
Documentation¶
There is always room for improvement in documentation. We welcome all the pull requests to fix typo / improve grammar or semantic structuring of documents. Here are a few documents you can work on:
Official Tutorials: https://github.com/hylia/hylia/tree/master/tutorials
README.md https://github.com/hylia/hylia/blob/master/README.md
Functional Documentation / Docstrings: https://github.com/hylia/hylia/tree/master/hylia
Open Issues¶
If you would like to help in working on open issues. Look out for
following tags: good first issue
help wanted
open for contribution
Medium Writers¶
Coming soon
Major Contribution¶
If you are willing to make a major contribution please contact<EMAIL_ADDRESS>What we currently need help on?¶
Improving unit-test cases and test coverage https://github.com/hylia/hylia/tree/master/hylia/tests


interface Connected
Marker interface for State instances that represent when the wallet is connected.


Kim Kardashian reveals surprising fact about Kylie Jenner selling half of her beauty business
The 22-year-old recently sold 51% of Kylie Cosmetics to Coty Inc.
by Kendra BeckerKim Kardashian has revealed a surprising fact about Kylie Jenner’s decision to sell half of her beauty business.
On Tuesday, the reality star confirmed that she’s sold 51% of her beauty brand, Kylie Cosmetics, to Coty Inc.
Kylie’s older sister Kim has spoken out about the sale for the first time, and admitted Kylie decided to sell her majority share last year.
Speaking to Entertainment Tonight, Kim said: “I’ve known that selling her business was always in the works for her for a long time.”
“A lot of companies were bidding and really wanted to buy her brand, and so selling just about half of it was a decision that she made about a year ago.”
Kim gushed: “I’m so proud of her. To think, in her early twenties, she built a business off of something that she first was insecure about, and finding confidence and tapping into that and figuring out how to make an amazing product and just being true to herself and doing what she loves to do.”
“That’s so inspiring and so amazing and I’m so proud of her.”
After the sale hit headlines earlier this week, Kylie’s momager Kris Jenner said: “We decided to partner with Coty because they share the same vision as we do in building this into a huge thing. We dream big and this is something we’re so excited about.”
“This is her baby and this is her dream, to build this beauty empire and just go into many categories that she hasn’t even scratched the surface.”
“She looks forward to working with Coty to develop more categories and going into other areas of the beauty business,” Kris continued.
“She feels like this is where she belongs. This is where her passion is and she wants to really — wants to use her creative side to develop her brand.  Twenty years from now she sees herself doing this and maybe passing it down to her daughter [Stormi].”


Cash Assistant
Time borders:
Current month
Previous month
Current year
Custom
Down border:
Top border:
Show balance
Incomes:
Category
Sum amount zł
Category1
10
Category2
100
Category3
1000
Expenses:
Category
Sum amount zł
Category1
10
Category2
100
Category3
1000
Incomes:
0
zł
Expenses:
0
zł
Total:
0
zł
Back


{% extends "base.html" %} {% block content %} {% if success %}
Type the url of the input video stream which you want to stream For now it's only support HTTP video source (
Write Content ID manually if you have had stream and you want to restart it. If you doesn't have Content ID just left blank. It will be generated automatically.
Type port on which the program will accept incoming connections.


All standard stream templates are derived from std::basic_ios. In C++, a virtual base class is initialized by its most derived class; that is, our new odatstream class is responsible for initialization of its base std::basic_ios. Now basic_ios has only one public constructor, which takes a pointer to a stream buffer. This is because basic_ios contains a pointer to the stream buffer, which has to be initialized when a basic_ios subobject is constructed. Consequently, we must figure out how to provide a stream buffer to our base class. Let's consider two options:
Derivation from file stream or string stream classes; that is, class
std::{i,o}fstream or class std::{i,o}stringstream, and
Derivation from std::basic_{i,o}stream.
The file and string stream classes contain a stream buffer data member and already monitor the initialization of their virtual base initialization by providing the pointer to their own stream buffer. If we derive from one of these classes, we do not provide another stream buffer pointer because it would be overwritten by the file or string stream's constructor anyway. (Remember that virtual base classes are constructed before non-virtual base classes regardless of where they appear in the hierarchy.) Consider:
template <class charT, class Traits=std::char_traits<charT> > class MyOfstream : public std::basic_ofstream<charT,Traits> { public: MyOfstream(const char* name) : std::basic_ios<charT,Traits>(...streambufptr...), std::basic_ofstream<charT,Traits>(name) {} // ... };
The order of initialization would be:
std::ios_base()
std::basic_ios (std::basic_streambuf*)
std::basic_ostream (const char*)
std::basic_ofstream (const char*)
MyOfstream (const char*)
In other words, the constructor of basic_ofstream overwrites the stream buffer pointer set by the constructor of basic_ios.
To avoid this dilemma, class basic_ios has a protected default constructor in addition to its public constructor. This default constructor, which requires a stream buffer pointer, doesn't do anything. Instead, there is a protected initialization function std::basic_ios<>::init() that can be called by any class derived from std::basic_ios<>. With this function, initialization of the std::basic_ios<> base class is handled by the stream class that actually provides the stream buffer -- in our example, std::basic_ofstream<>. It calls the protected init() function:
template <class charT, class Traits=std::char_traits<charT> > class MyOfstream : public std::basic_ofstream<charT,Traits> { public: MyOfstream(const char* name) : std::basic_ofstream<charT,Traits>(name) {} // ... };
The order of initialization is:
std::ios_base()
std::basic_ios()
std::basic_ostream (const char*)
calls std::basic_ios::init(basic_streambuf*)
std::basic_ofstream (const char*)
MyOfstream (const char*)
The scheme for deriving from the stream classes is slightly different in that you must always provide a pointer to a stream buffer. This is because the stream classes do not contain a stream buffer, as the file or string stream classes do. For example, a class derived from an output stream could look like this:
template <class charT, class Traits = std::char_traits<charT> > class MyOstream : public std::basic_ostream<charT,Traits> { public: MyOstream(std::basic_streambuf<charT,Traits>* sb) : std::basic_ostream<charT,Traits>(sb) {} // ... };
There are several ways to provide the stream buffer required for constructing such a stream:
Create the stream buffer independently, before the stream is created. Here is a simple example in which a file buffer is created as a separate object and used by the derived stream:
std::filebuf strbuf; strbuf.open("/tmp/xxx"); MyOstream<char> mostr(&strbuf); mostr << "Hello world\n";
Take the stream buffer from another stream. In the example below, the stream buffer is "borrowed" from the standard error stream std::cerr:
MyOstream<char,std::char_traits<char> > mostr(std::cerr.rdbuf()); mostr << "Hello world\n";
Remember that the stream buffer is now shared between mostr and cerr (see Section 34.3 for details).
Contain the stream buffer in the derived stream, either as a data member or inherited. It is typically preferred when a new stream buffer type is used along with the new stream type.


[]. virus [], infection treatment viral host Ebola drug biothreat bacterial human combination therapy efficacy survival protein development disease resistance Chemother agents animal fever Burkholderia antibodies identify compounds screening Agents Infect cell inhibitors intracellular used antibody pathogens target screen using identified model pathogen tularensis clinical entry immune lethal pseudomallei studies therapeutic therapeutics assay factors polymerase viruses Dis RNA monoclonal protection study {border-style anthrax drugs novel therapies use antibiotic efflux mice patients pestis px;} replication vitro #ffffff;} Lassa Med Res approved bacteria hemorrhagic infected mg/kg, Brucella antiviral burnetii cells dose effective mg/kg potential required small targeting EBOV Francisella anthracis approach countermeasures days genome high mAbs Combination Onee Phase Table Viral Yersinia antibiotics challenge data factor infectious molecule new plasma proteins Bacillus Microbiol TLR agent case complex highly levels mallei mechanisms number protective respiratory targets Drug Junin assays available encephalitis equine inhibition pathway treat virulence virus; FDA-approved Virol and/or diseases exposure fusion humans inhibit inhibitor life response vaccine (Fig. Animal Coxiella FDA activity antimicrobial bacterium caused developed high-throughput increased mechanism protect pump research resistant severe spp. vivo (e.g., DNA Immun antivirals biofilm cause cellular countermeasure different following include kinase mouse neutralizing nonhuman prevent prior recombinant role starting systems Human Immunol Marburg Nipah Rev Rule active appropriate autophagy challenges collab: compared concentration high-content identifies including infection, infection. limited medical models pathways post px; receptor require shown type unique {font-family AVI- BID Figure References Screening action administration animals assay, botulinum causing ceftazidime chronic cocktail control convalescent current discovery evaluated font-size genes growth improve innate mammalian membrane multiple possible postexposure potent product reduced related release resulting results select testing time treated vaccines (NCT) Antibiotics Antimicrob Cat Food HDT LPS NHP: Pathoge Quinolones RNAi VEEV ability acute agents. approaches approval bacteria, biocontainment broad-spectrum cases causative cells, characterization chemical critical cycle double; doxycycline escape example, generated hits host-directed known leads loss minigenome molecules murine overcome pathogens, pathogens. patient performed production protease pulmonary replication. reported review rhesus secretion serum showed signaling significantly single specific specifically stages susceptibility threat toxin traditional trial trials virus-like viruses, (T-) Administered Administration Alternatively, Chem Elsevier HCI HOPS HTS LVS N/A NHP National United Using West administered antibacterial associated border-color border-width candidates cell-based cells. ciprofloxacin concentrations demonstrated designed detect disease, dosed dye effectiveness emerging entry, favipiravir features gene genome-wide imaging improved infections, infections. inhalational involved laboratory large level low methods mice, modulation outbreak pharmacokinetic present prevention producing provide pseudomalleiAntimicrob quantitate rapid replicate reporter safety siRNA solid; species spread strains strategy targeted tissue trafficking transmitted transporter types vaccination vacuole {font-style {font-weight μM, > (Table AMPK Acad AcrAB-TolC BCX COVID- Centers Clostridium Dise Disease Efficacy III Infectious Institute Intracellular LF, Lactams MAb NHP, NHPs NPC, Negl PA, RND-type Sci Similarly, TKM- TSS Targeting Terminated Ther Tier Toll-like Trop Vaccinia Valley Vero ZMapp addition advanced alternative analysis antibodies, anticoagulant antigen areas based binding biological biorelease bold calcium centre chapter cholesterol clear cleavage concern containing controlled courier; course daily described determine develop directly dissemination distinct doses early easily edema effect effective, em; endosomes experimental experiments expression factor; filovirus fluorescence fluorescent followed form gain general generally giant glanders globulin government hit host–pathogen humans, humans. i.p. identifying important infect infections inflammatory information inhibitory interaction isolates key laboratories levofloxacin library likely lysosomal lysosome mAb macrophages major making method modulate molecular monitoring mortality multinucleated natural nematode network nonmotile outbreaks p.o. passive pathways. phagosome phase phenotypic plague pneumonic potentially poxvirus preclinical presence primate primates process produced progress properties prophylactic prophylaxis provides pt;} pumps rapidly recent regulation replication, reports: requirement requires resource responses reveals ribavirin rifampin risk safe significant similar smallpox stage subsequent successfully syndrome synergistic synthetic therapeutics. tissues toxin, toxins treatments understanding useful utilization versus virion virus, vivo—NHP: weaponized


Designer Program How To's
The following are various tips and tricks that don't warrant
a topic on their own.
How to display a different board bitmap at each board viewing scale.
Use the Tools/Set Scale Visibility
feature to do this. The procedure in more detail:
- Create the full scale map and use the CyberBoard palette to create a
compatible image. Paste this into the playing board.
- Open the Set Scale Visibility dialog and clear all scale
check marks except full-scale. You will now only see this bitmap
when the board is viewed at full-scale.
- Open the board properties dialog and make note of the pixel dimensions
of the half and small scale boards. These are the target sizes you should
use when creating your reduced scale maps.
- Set the board scale to half-scale and paste the half-scale bitmap into the
playing board. Note: it will initially seem too small.
- Open the Set Scale Visibility dialog and check the
"Above scale is natural scale" and "Half Scale" check boxes.
- Set the board scale to small-scale and paste the small-scale bitmap into the
playing board. Note: it will initially seem too small.
- Open the Set Scale Visibility dialog and check the
"Above scale is natural scale" and "Small Scale" check boxes.


DocOnce text looks like ordinary text (much like Markdown ), but there are some almost invisible text constructions that allow you to control the formating. Here are some examples.
*
,
or o
if the list is to be enumerated.*
. Words in boldface
are surrounded by underscores.verbatim (in a monospace font)
.=
before and after the heading, e.g.,
===== Here is a subsection heading =====
.!bc
(begin code) and !ec
(end code) tags on separate lines.
Blocks of computer code can also be imported from source files.!bt
(begin TeX) and !et
(end TeX) tags on separate lines.
Inline mathematics is surrounded by dollar signs: $a=b$
.#
and are not visible in the output document.

(name 1: comment...)

and made visible or invisible as desired.TITLE:
, AUTHOR:
, DATE:
, FIGURE:
,
and MOVIE:
.1: In fact, DocOnce allows basic GitHub-extended Markdown syntax as input. This is attractive for newcomers from Markdown or writers who also write Markdown documents (or uses Markdown frequently at GitHub).
LaTeX is ideal for articles, thesis, and books, but the PDF files does not look fresh and modern on tablets and phones or big computer screens. For the latter type of media you need HTML-based documents with strong support for nice layouts. Tools like Sphinx, Markdown, or plain HTML with Bootstrap are then more appropriate than LaTeX, but involves a very different syntax. DocOnce lets you write one text in one place and then generate the most appropriate language for the media you want to target. DocOnce also has many extra features for supporting large documents with much code and mathematics, not found in any of other publishing tool.
LaTeX writers often have their own writing habits with use of their own favorite LaTeX packages. DocOnce is a much simpler format and corresponds to writing in quite plain LaTeX and making the ascii text look nice (be careful with the use of white space!). This means that although DocOnce has borrowed a lot from LaTeX, there are a few points LaTeX writers should pay attention to. Experience shows that these points are so important that we list them before we list typical DocOnce syntax!
Any LaTeX syntax in mathematical formulas is accepted when DocOnce
translates the text to LaTeX, but if output in the sphinx
, pandoc
,
mwiki
, html
, or ipynb
formats is also important, one should
follow the rules below.
html
, sphinx
,
and ipynb
formats.latex
, html
, sphinx
,
markdown
, and ipynb
, it is recommended to use only
the following equation environments: \[ ... \]
,
equation*
, equation
, align*
, align
. alignat*
, alignat
.
Other environments, such as split
, multiline
, gather
are
supported in modern MathJax in HTML and Sphinx, but may face
rendering problems (to a larger extent than equation
and align
).
DocOnce performs extensions to sphinx
, ipynb
,
and other formats such that
labels in align
and alignat
environments work well.
If you face problems with fancy LaTeX equation environments in
web formats, try rewriting with plain align
, nonumber
, etc.newcommands*.tex
. Use \newcommands
and not \def
.
Each newcommand must be defined on a single line.
Use Mako functions if you need macros in the running text.mwiki
) does not support references to equations.ref
command (no \eqref
for equations) and references to
equations must use parentheses. Never use the tilde
(non-breaking
space) character before references to figures, sections, etc., but
tilde is allowed for references to equations.\pageref
as pages are not a concept in web documents
(there is only a ref
command in DocOnce and it refers to labels).subfigure
to combine several image files in one
figure, but you can combine the files to one file using
the doconce combine_images
tool. Refer to individual image files
in the caption or text by (e.g.) "left" and "right", or
"upper left", "lower right", etc.cite
for references (e.g., \citeauthor
has no counterpart
in DocOnce). The bibliography must be prepared in the Publish format,
but import from (clean) BibTeX is possible.idx
for index entries, but put the definitions between paragraphs,
not inside them (required by Sphinx).\bm
command (from the bm
package, always included by DocOnce)
for boldface in mathematics.\begin{}
and \end{}
directives should start
in column 1.2: There is an exception: by using user-defined environments
within !bu-name
and !eu-name
directives, it is possible to
label any type of text and refer to it. For example, one can have
environments for examples, tables, code snippets, theorems, lemmas, etc.
One can also use Mako functions to implement enviroments.
#if FORMAT in ("latex", "pdflatex")
) to
include such special LaTeX code. With an else clause you can easily
create corresponding constructions for other formats. This way
of using Preprocess or Mako
allows advanced LaTeX features, or HTML features for the HTML formats,
and thereby fine tuning of the resulting
document. More tuning can be done by automatic editing of the
output file (e.g., .tex
or .html
) produced by DocOnce using
your own scripts or the doconce replace
and doconce subst
commands.
doconce latex2doconce
may help you translating LaTeX files
to DocOnce syntax. However, if you use computer code in floating
list environments, special packages for typesetting algorithms,
example environments, subfigure
in figures,
or a lot of newcommands in the running text, there will be need for
a lot of manual edits and adjustments.
For examples, figure environments can be translated by the program
doconce latex2doconce
only if the label is inside the caption and
the figure is typeset like
\begin{figure}
\centering
\includegraphics[width=0.55\linewidth]{figs/myfig.pdf}
\caption{This is a figure. \labe{myfig}}
\end{figure}
If the LaTeX is consistent with respect to placement of the label, a
simple script can autoedit the label inside the caption, but many
LaTeX writers put the label at different places in different figures,
and then it becomes more difficult to autoedit figures and translate
them to the DocOnce FIGURE:
syntax.
Tables are hard to interpret and translate, because the headings and caption can be typeset in many different ways. The type of table that is recognized looks like
\begin{table}
\caption{Here goes the caption.}
\begin{tabular}{lr}
\hline
\multicolumn{1}{c}{$v_0$} & \multicolumn{1}{c}{$f_R(v_0)$}\\
\hline
1.2 & 4.2\\
1.1 & 4.0\\
0.9 & 3.7
\hline
\end{tabular}
\end{table}
Recall that table captions do not make sense in DocOnce since tables must be inlined and explained in the surrounding text.
Footnotes are also problematic for doconce latex2doconce
since DocOnce
footnotes must have the explanation outside the paragraph where the
footnote is used. This calls for manual work. The translator from
LaTeX to DocOnce will insert _PROBLEM_
and mark footnotes. One
solution is to avoid footnotes in the LaTeX document if fully automatic
translation is desired.
Here is an example of some simple text written in the DocOnce format:
======= First a Section Heading =======
===== Then a Subsection Heading =====
=== Finally a Subsubection Heading ===
You can also have paragraphs with a paragraph heading surrounded
by double underscores are the beginning of a line.
__This is a paragraph heading.__
And here comes the text.
===== A Subsection with Sample Text =====
label{my:first:sec}
Ordinary text looks like ordinary text, but must always start at the
beginning of lines. Tags used for _boldface_ words, *emphasized*
words, and `computer` words look natural in plain text. Quotations
appear inside double backticks and double single quotes, as in ``this
example''.
Below the section title we have a *label*, which can be used to
refer to Section ref{my:first:sec}.
References to equations, such as (ref{myeq1}), work in the same
LaTeX-inspired way.
Lists are typeset as you would do in email,
* item 1
* item 2,
perhaps with a 2nd line
* item 3
Note the consistent use of indentation (as in Python programming!).
Lists can also have automatically numbered items instead of bullets,
o item 1
o item 2
o item 3,
but be careful with the indentation of the next lines!
__Hyperlinks.__
URLs with a link word are possible, as in "hpl": "http://folk.uio.no/hpl".
If the word is just URL, the URL itself becomes the link name,
as in URL: "tutorial.do.txt". DocOnce distinguishes between paper
and screen output. In traditional paper output, in PDF generated from LaTeX
generated from DocOnce, the URLs of links appear as footnotes.
With screen output, all links are clickable hyperlinks, except in
the plain text format which does not support hyperlinks.
__Inline comments.__
DocOnce also allows inline comments of the form [name: comment] (with
a space after `name:`), e.g., such as [hpl: here I will make some
remarks to the text]. Inline comments can be removed from the output
by a command-line argument (see Section ref{doconce2formats} for an
example). Inline comments can also be used for detailed editing of
text, much like track changes in word, to illustrate how a text
is revised. (However, for seeing how others have revised the text, I
strongly recommend using Git for version control and running `git diff`
on the appropriate versions, or you can click on differences at
GitHub if the files are hosted there.)
__Footnotes.__ Adding a footnote[^footnote] is also possible.
[^footnote]: The syntax for footnotes is borrowed from Extended Markdown.
__Tables.__
Tables are also written in the plain text way, e.g.,
|--c--------c-----------c--------|
|time | velocity | acceleration |
|---r-------r-----------r--------|
| 0.0 | 1.4186 | -5.01 |
| 2.0 | 1.376512 | 11.919 |
| 4.0 | 1.1E+1 | 14.717624 |
|--------------------------------|
The characters `c`, `r`, and `l` can be inserted, as illustrated above,
for aligning the headings and the columns (center, right, left).
One can also use `X` for potentially very long text in a column (will be
left-adjusted).
# Lines beginning with # are comment lines.
The DocOnce text above results in the following little document:
You can also have paragraphs with a paragraph heading surrounded by double underscores are the beginning of a line.
This is a paragraph heading. And here comes the text.
Ordinary text looks like ordinary text, but must always start at the
beginning of lines. Tags used for boldface words, emphasized
words, and computer
words look natural in plain text. Quotations
appear inside double backticks and double single quotes, as in "this
example".
Below the section title we have a label, which can be used to refer to the section A Subsection with Sample Text. References to equations, such as '\eqref{myeq1}', work in the same LaTeX-inspired way.
Lists are typeset as you would do in email,
Inline comments.
DocOnce also allows inline comments of the form
(name 2: comment)
(with
a space after name:
), e.g., such as
(hpl 3: here I will make some remarks to the text)
. Inline comments can be removed from the output
by a command-line argument (see the section From DocOnce to Other Formats for an
example). Inline comments can also be used for detailed editing of
text, much like track changes in word, to illustrate how a text
is revised. (However, for seeing how others have revised the text, I
strongly recommend using Git for version control and running git diff
on the appropriate versions, or you can click on differences at
GitHub if the files are hosted there.)
Footnotes. Adding a footnote is also possible.
3: The syntax for footnotes is borrowed from Extended Markdown.
Tables. Tables are also written in the plain text way, e.g.,
| time | velocity | acceleration |
| 0.0 | 1.4186 | -5.01 |
| 2.0 | 1.376512 | 11.919 |
| 4.0 | 1.1E+1 | 14.717624 |
The characters c
, r
, and l
can be inserted, as illustrated above,
for aligning the headings and the columns (center, right, left).
Inline mathematics, such as \( \nu = \sin(x) \) is written exactly as in LaTeX:
$\nu = \sin(x)$
Blocks of mathematics are typeset with raw LaTeX, inside
!bt
and !et
(begin TeX, end TeX) directives:
!bt
\begin{align}
{\partial u\over\partial t} &= \nabla^2 u + f,
label{myeq1}\\
{\partial v\over\partial t} &= \nabla\cdot(q(u)\nabla v) + g
\end{align}
!et
The result looks like this:
$$
\begin{align}
{\partial u\over\partial t} &= \nabla^2 u + f, \label{myeq1}\\
{\partial v\over\partial t} &= \nabla\cdot(q(u)\nabla v) + g
\label{_auto1}
\end{align}
$$
Of course, such blocks only looks nice in formats with support
for LaTeX mathematics
(this includes latex
, pdflatex
, html
, sphinx
, ipynb
, pandoc
,
and mwiki
). Simpler
formats have to just list the raw
LaTeX syntax.
subfigure
(combine image files to one file instead, via doconce combine_images
).
You can have blocks of computer code, starting and ending with
!bc
and !ec
instructions, respectively.
!bc pycod
from math import sin, pi
def myfunc(x):
return sin(pi*x)
import integrate
I = integrate.trapezoidal(myfunc, 0, pi, 100)
!ec
Such blocks are formatted as
from math import sin, pi
def myfunc(x):
return sin(pi*x)
import integrate
I = integrate.trapezoidal(myfunc, 0, pi, 100)
A code block must come after some plain sentence (at least for successful
output to sphinx
, rst
, and formats close to plain text),
not directly after a section/paragraph heading or a table.
Blocks of computer code has named environments, such as pycod. The py stands for Python and cod indicates a code snippet that cannot be run without more code. Another example is fpro, f for Fortran and pro for a complete program that will run as it stands. There is support for code in C, C++, Fortran, Java, Python, Perl, Ruby, JavaScript, HTML, and LaTeX,
One can also copy computer code directly from files, either the complete file or specified parts, e.g,
@@@CODE src/myprog.py fromto: def regression\(@import mymod
The copying is based on regular expressions and not on line numbers, which
makes the specifications much more robust during software and document
developing. With the @@@CODE
command,
computer code is never
duplicated in the documentation (important for the principle of
avoiding copying information!) and once the software is updated, the
next compilation of the document is up-to-date.
Inclusion of files.
Another DocOnce document or any file can be
included by writing # #include "mynote.do.txt"
at the beginning of a
line. DocOnce documents have extension do.txt
. The do
part stands
for doconce
, while the trailing .txt
denotes a text document so
that editors gives you plain text editing capabilities.
DocOnce supports a type of macros via a LaTeX-style newcommand
construction. The newcommands are defined in files with names
newcommands*.tex
, using standard LaTeX syntax. Only newcommands
for use inside LaTeX math environments are supported. (But you can
define any type of macros through Mako functions!)
Labels, corss-references, citations, and support of an index and bibliography are much inspired by LaTeX syntax, but DocOnce features no backslashes. Use labels for sections and equations only, and preceed the reference by "Section" or "Chapter", or in case of an equation, surround the reference by parenthesis.
Here is an example:
===== My Section =====
label{sec:mysec}
idx{key equation} idx{$\u$ conservation}
We refer to Section ref{sec:yoursec} for background material on
the *key equation*. Here we focus on the extension
# \Ddt, \u and \mycommand are defined in newcommands_keep.tex
!bt
\begin{equation}
\Ddt{\u} = \mycommand{v},
label{mysec:eq:Dudt}
\end{equation}
!et
where $\Ddt{\u}$ is the material derivative of $\u$.
Equation \eqref{mysec:eq:Dudt} is important in a number
of contexts, see cite{Larsen_et_al_2002,Johnson_Friedman_2010a}.
Also, cite{Miller_2000} supports such a view.
As see in Figure ref{mysec:fig:myfig}, the key equation
features large, smooth regions *and* abrupt changes.
FIGURE: [fig/myfile, width=600 frac=0.9] My figure. label{mysec:fig:myfig}
===== References =====
BIBFILE: papers.pub
DocOnce applies Publish for specifying bibliographies because this tool has more functionality than BibTeX, but any BibTeX database can be automatically converted to the simple Publish format.
For further details on functionality and syntax we refer to the DocOnce manual.
We refer to the manual for detailed information on how to compile a DocOnce document to various formats. Here we just give a glimpse of the possibilities.
Suppose you have some DocOnce text in mydoc.do.txt
. Here is how you
compile that document to an HTML file mydoc.html
, which can be viewed
in a web browser:
Terminal> doconce format html mydoc --html_style=bootswatch_journal
There are lots of styles for HTML files, and bootswatch_journal
is
a fancy one. There are also lots of other command-line options for
tailoring the compilation. Run doconce format --help
to see a list
of all options. Those that start with --html_
are specific for the
HTML output format.
A DocOnce compilation has three stages:
mydoc.do.txt
, resulting in tmp_preprocess__mydoc.do.txt
.tmp_preprocess__mydoc.do.txt
, resulting in tmp_mako__mydoc.do.txt
.tmp_mako__mydoc.do.txt
is translated to the chosen output format.DocOnce can be translated to many formats. For documents with much mathematics and/or computer code the following formats are suitable:
latex
, pdflatex
html
sphinx
ipynb
(IPython/Jupyter notebooks)matlabnb
(Matlab notebooks)gwiki
(Googlecode), cwiki
(Creole), mwiki
(MediaWiki)plain
(pure ascii)pandoc
(various Markdown formats)
DocOnce has strong support for writing slides, see the
slides demo
for examples. Each slide starts with
a subsection heading (5 =
), preceded by !split
to indicate a
new slide. Section headings are used to mark parts of the presentation.
The slides are compiled as any other DocOnce file, but there is usually
a second step where the text is modified to become a proper slide text
in the chosen output format. We refer to the manual for details
and the DocOnce slide demo.
Several popular slide formats are supported:
Our short scientific report is a good starting point for seeing how DocOnce documents are written and get a demonstration of the vast choice of output formats and settings that are available.
There is also a demo of different slide formats.
DocOnce has support for responsive HTML documents with design and functionality based on Bootstrap styles. A Bootstrap demo illustrates the many possibilities for colors and layouts.
DocOnce also has support for exercises in quiz format. Pure quiz files can be automatically uploaded to Kahoot! online quiz games operated through smart phones (with the aid of quiztools for DocOnce to Kahoot! translation).
The current text is generated from a DocOnce format stored in the file
doc/tutorial/tutorial.do.txt
The file make.sh
in the tutorial
directory of the
DocOnce source code contains a demo of how to produce a variety of
formats.


Last update - 7/3/2013 4:30:44 PM
The conf.json file holds all the information to display your web application.
Be very careful when making edits as the file must contain valid json syntax JSON Lint is a good resource for checking JSON validity. Also don't forget that javascript and JSON (JavaScript Object Notation) are case sensitive so section/object/type names listed below must be used exactly as shown.
mapConfig {Object}
the container for all of the configuration all of the following sections are contained within this object.
{
"mapConfig":{
}
}
Page {Object}
"Page": {
"style": "steal-gray",
"title": "Some Name",
"links": [{
"label": "Google",
"url": "http://www.google.com/"
}, {
"label": "Yahoo",
"url": "http://www.yahoo.com/"
}],
"helpTab": "help.html",
"scalebar": true,
"scaleview": true
}
links - {Array} list of links displayed at top right of the page
url - url of link
[
{
"label": "Google",
"url": "http://www.google.com/"
},
{
"label": "Plats",
"url": "http://www.mysite.com/plats/"
}
]
Extent {Object}
"Extent": {
"xmin":<PHONE_NUMBER>2705395,
"ymin":<PHONE_NUMBER>1863936,
"xmax":<PHONE_NUMBER>280566,
"ymax":<PHONE_NUMBER>86436,
"spatialReference": {
"wkid": 26985
}
}
spatialReference - {Object} the spatial reference system used
epsg - epsg coordianate system id
"spatialReference":{
"wkid": 26985
}
or
"spatialReference":{
"epsg": 2264
}
Layers {Array}
"layers" : [
]
Layer Object
bingKey - {String} only used with Bing layer type is the bing api key received from microsoft.
{
"name": "Layer1",
"type": "ArcGISDynamicMapServiceLayer",
"url": "http://myserver.com/arcgis/rest/services/map1/MapServer",
"toggle": false,
"transbtn": false,
"visible":true
}
Tools {Array}
Optional tool Objects
Identify
task - {Array}
Identify Task Object
templates - {Object} for each layer id in layerIds you must have a template, it can be empty but it must exist in the templates array. You may use html markup in the template as well as the ${PROPERTY_NAME} syntax to use attribute values.
{
"21":"<b>${PID}</b>,
"65":"<h1>${NAME}-${AGE}<h1>"
}
printDefs - {Object} an object with properties of layerIds that hold an array of attribute values to put on the printed map.
"printDefs": {
"28": [
"PPIN",
"TaxParcel.Parcel_Number",
"Appraised_AC",
"NAME",
"ADDRESS1",
"ADDRESS2",
"CITY",
"STATE",
"ZIPCODE",
"RANGE",
"TR_SECTION",
"TAX_DIST",
"SUBDIV_CODE",
"PROP_ADD_NUM",
"PROP_STREET",
"LEGAL_DESC",
"TOTAL_ASSESED_VAL"
],
"31": [
"NAME",
"AGE",
"SIZE"
]
}
Hyperlink
task - {Object}
template - {String} the url template to use to retrieve data.
Use {PROPERTY_NAME} syntax to get a value from an attribute and #functionName# syntax to use a user defined function to format data. The user defined function must be added into the agd.Utils.userFunctions object via the addUserFunction method this can be added into the html template for the page. The example below creates a user defined function of MyFormater (#MyFormater#) and the propertyValue variable will be whatever follows the #MyFormater# tag in the template, for example http://norealurl.com/getStuff/#MyFormater#{ACCOUNTID}
If {ACCOUNTID} was billbagens the formatted url would be
http://norealurl.com/getStuff/bobbagens
.
agd.Utils.addUserFunction(
"MyFormater",
function(propertyValue){
return propertyValue.replace("bill","bob");
});
Measure
Queries {Array}
"Queries" : [
]
QueryTask
symbol - {String} name of a symbol from the Symbols section of the configuration
{
"label": "Search by Owner",
"type": "QueryTask",
"url": "http://noname.org/arcgis/rest/services/map1/MapServer/22",
"operator": "LIKE",
"isNumber": false,
"searchBoxLable": "Owner Name",
"searchFields": ["OWNNAME1", "OWNNAME2"],
"outFields": ["OWNNAME1", "OWNADD1", "OWNCITY", "OWNSTATE", "ACCTID"],
"symbol": "DefaultPolygonSymbol"
}
GeocodeTask
url - {String} url of the ArcGIS geocode service
{
"label": "Find Address",
"type": "GeocodeTask",
"searchBoxLable": "Address",
"url": "http://noname.org/arcgis/rest/services/AddressLocator/GeocodeServer",
"layerIds": [],
"searchFields": []
}
FindTask
Symbols {Array}
"Symbols": [
]
style - {Object} Symbol Object (see esri symbol json representation)
"name": "DefaultLineSymbol",
"style": {
"type": "esriSFS",
"style": "esriSFSSolid",
"color": [115, 76, 0, 255],
"outline": {
"type": "esriSLS",
"style": "esriSLSSolid",
"color": [110, 110, 110, 255],
"width": 1
}
}


| Home | Trees | Indices | Help |
|
|---|
|
|
Created on March 22, 2011
Author: Tucker Balch
Contact<EMAIL_ADDRESS>This script generates a list of days on which we expect the NYSE to be open. Information is drawn from two websites:
http://www.timeanddate.com/holidays/ http://www.nyse.com/about/newsevents/1176373643795.html
Version: $Revision: 295 $
|
|||
rootday = datetime.datetime(2011, 1, 3, 0, 0)
|
|||
endday = datetime.datetime(2021, 1, 1, 0, 0)
|
|||
weekdays =
|
|||
oneday = datetime.timedelta(1)
|
|||
curr = 3654
|
|||
candidateday = datetime.datetime(2021, 1, 4, 0, 0)
|
|||
NYSEholidays =
|
|||
setweekdays =
|
|||
setNYSEholidays =
|
|||
newdays =
|
|||
MAXYEAR = 9999
|
|||
MINYEAR = 1
|
|||
__package__ =
|
|||
datetime_CAPI = <capsule object "datetime.datetime_CAPI" at 0x
|
|||
i = datetime.datetime(2021, 1, 1, 0, 0)
|
|||
j = 4
|
|
weekdays
|
NYSEholidays
|
setweekdays
|
setNYSEholidays
|
newdays
|
datetime_CAPI
|
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Mon Mar 5 00:49:15 2012 | http://epydoc.sourceforge.net |


Pattern matching is new in C#7 / Visual Studio 2017. Remember C#7 isn't the same a .Net version upgrade - you can use these language features in projects targeting .net Core, .net 4.6, 4.5, 4.0 and even 3.5.
Pattern matching is essentially a better syntax to test types.
"is" better
This is the existing (C# 1-6) "is" syntax.
{
var person = (Person) o;
UpdatePerson(person);
}
You can make a slightly more efficient version with "as"
if (person != null)
{
UpdatePerson(person);
}
In C#7 the "is" syntax can have a variable name afterwards - so it's a test and assignment in one syntax.
{
UpdatePerson(person);
}
One complication is that the variable "person" has method scope. If you re-use "person" below the closing "if" braces, you'll get the "Use of unassigned local variable" compilation error.
"case" better
More useful is the updated "switch" statement. Previously the "case" tests had to be constants. Now they can be types with assignment.
{
case Person person:
UpdatePerson(person);
break;
case Cat cat:
UpdateCat(cat);
break;
}
Unlike old-style switches, order is important! (Except the "default" case, which is always last, even if you write it first...)
The case test can be extended with a "when" (not "where" like in linq). Now you can do ranges in switch statements.
{
case 1:
Console.WriteLine("One");
break;
case int j when j > 1:
Console.WriteLine("More than one");
break;
}
Note that variable scope is now within the "case" block (unlike "if").
{
case Person person when person.Name != null:
UpdateUnknownPerson(person);
break;
case Person person:
UpdatePerson(person);
break;
}


This timer demonstrates drift. The clock is supposed to fire every 1000 milliseconds and it is started when the page loads, so any fraction of second represents clock drift. Notice how it steadily increases... Elapsed seconds:
Time of day:


About
About this software
-
Software Home
Documentation
Support Forums
Feedback
Admin Navigation
Dashboard
Themes
Customize
Widgets
Menus
Background
Header
0 new comments
New
Post
Media
Page
User
Edit Page
A CMS style admin bar.


{{extend 'zlayout.html'}}
{{=XML(T('Forums have been re-sorted'))}}
{{pass}} {{if view_info['errors']:}}{{=XML(T('There were some errors while processing your request, please correct the following'))}}:
{{=XML(T('No categories have been created. You must have at least one category to allow forum management'))}}.
{{pass}}


Home
(current)
About
Services
Projects
Contact
This is a test
Also this
This is a test
Also this
This is a test
Also this
Previous
Next


A Warm Welcome To
Akadimia
Sign Up and Start Learning
First Name
Last Name
Phone Number
Email Address
Password
Confirm Password
Choose your timezone
Select timezone
Select Image
Select The second Image
Submit
Already have an account?
Sign In Now
Copyright © 2020 AuburnForest