AlastriaCredentialRegistry
AlastriaCredentialRegistry: object
IssuerCredentialRevoked
IssuerCredentialRevoked: object
anonymous
anonymous: boolean = false
inputs
inputs: object[] = [{"indexed":false,"name":"issuerCredentialHash","type":"bytes32"},{"indexed":false,"name":"status","type":"uint8"}]
name
name: string = "IssuerCredentialRevoked"
type
type: string = "event"
SubjectCredentialDeleted
SubjectCredentialDeleted: object
anonymous
anonymous: boolean = false
inputs
inputs: object[] = [{"indexed":false,"name":"subjectCredentialHash","type":"bytes32"}]
name
name: string = "SubjectCredentialDeleted"
type
type: string = "event"
addIssuerCredential
addIssuerCredential: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"issuerCredentialHash","type":"bytes32"}]
name
name: string = "addIssuerCredential"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
addSubjectCredential
addSubjectCredential: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"subjectCredentialHash","type":"bytes32"},{"name":"URI","type":"string"}]
name
name: string = "addSubjectCredential"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
constructor
constructor: object
inputs
inputs: object[] = [{"name":"_previousPublishedVersion","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "constructor"
deleteSubjectCredential
deleteSubjectCredential: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"subjectCredentialHash","type":"bytes32"}]
name
name: string = "deleteSubjectCredential"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
getCredentialStatus
getCredentialStatus: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"subjectStatus","type":"uint8"},{"name":"issuerStatus","type":"uint8"}]
name
name: string = "getCredentialStatus"
outputs
outputs: object[] = [{"name":"","type":"uint8"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "pure"
type
type: string = "function"
getIssuerCredentialStatus
getIssuerCredentialStatus: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"issuer","type":"address"},{"name":"issuerCredentialHash","type":"bytes32"}]
name
name: string = "getIssuerCredentialStatus"
outputs
outputs: object[] = [{"name":"exists","type":"bool"},{"name":"status","type":"uint8"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
getSubjectCredentialList
getSubjectCredentialList: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"subject","type":"address"}]
name
name: string = "getSubjectCredentialList"
outputs
outputs: object[] = [{"name":"","type":"uint256"},{"name":"","type":"bytes32[]"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
getSubjectCredentialStatus
getSubjectCredentialStatus: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"subject","type":"address"},{"name":"subjectCredentialHash","type":"bytes32"}]
name
name: string = "getSubjectCredentialStatus"
outputs
outputs: object[] = [{"name":"exists","type":"bool"},{"name":"status","type":"uint8"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
issuerCredentialList
issuerCredentialList: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"","type":"address"},{"name":"","type":"uint256"}]
name
name: string = "issuerCredentialList"
outputs
outputs: object[] = [{"name":"","type":"bytes32"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
previousPublishedVersion
previousPublishedVersion: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "previousPublishedVersion"
outputs
outputs: object[] = [{"name":"","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
subjectCredentialList
subjectCredentialList: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"","type":"address"},{"name":"","type":"uint256"}]
name
name: string = "subjectCredentialList"
outputs
outputs: object[] = [{"name":"","type":"bytes32"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
subjectCredentialRegistry
subjectCredentialRegistry: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"","type":"address"},{"name":"","type":"bytes32"}]
name
name: string = "subjectCredentialRegistry"
outputs
outputs: object[] = [{"name":"exists","type":"bool"},{"name":"status","type":"uint8"},{"name":"URI","type":"string"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
updateCredentialStatus
updateCredentialStatus: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"issuerCredentialHash","type":"bytes32"},{"name":"status","type":"uint8"}]
name
name: string = "updateCredentialStatus"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
version
version: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "version"
outputs
outputs: object[] = [{"name":"","type":"int256"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
AlastriaIdentityManager
AlastriaIdentityManager: object
IdentityCreated
IdentityCreated: object
anonymous
anonymous: boolean = false
inputs
inputs: object[] = [{"indexed":true,"name":"identity","type":"address"},{"indexed":true,"name":"creator","type":"address"},{"indexed":false,"name":"owner","type":"address"}]
name
name: string = "IdentityCreated"
type
type: string = "event"
IdentityRecovered
IdentityRecovered: object
anonymous
anonymous: boolean = false
inputs
inputs: object[] = [{"indexed":true,"name":"oldAccount","type":"address"},{"indexed":false,"name":"newAccount","type":"address"},{"indexed":true,"name":"serviceProvider","type":"address"}]
name
name: string = "IdentityRecovered"
type
type: string = "event"
OperationWasNotSupported
OperationWasNotSupported: object
anonymous
anonymous: boolean = false
inputs
inputs: object[] = [{"indexed":true,"name":"method","type":"string"}]
name
name: string = "OperationWasNotSupported"
type
type: string = "event"
PreparedAlastriaID
PreparedAlastriaID: object
anonymous
anonymous: boolean = false
inputs
inputs: object[] = [{"indexed":true,"name":"signAddress","type":"address"}]
name
name: string = "PreparedAlastriaID"
type
type: string = "event"
addIdentityIssuer
addIdentityIssuer: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"_identityIssuer","type":"address"},{"name":"_level","type":"uint8"}]
name
name: string = "addIdentityIssuer"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
addIdentityServiceProvider
addIdentityServiceProvider: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"_identityServiceProvider","type":"address"}]
name
name: string = "addIdentityServiceProvider"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
alastriaCredentialRegistry
alastriaCredentialRegistry: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "alastriaCredentialRegistry"
outputs
outputs: object[] = [{"name":"","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
alastriaPresentationRegistry
alastriaPresentationRegistry: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "alastriaPresentationRegistry"
outputs
outputs: object[] = [{"name":"","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
alastriaPublicKeyRegistry
alastriaPublicKeyRegistry: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "alastriaPublicKeyRegistry"
outputs
outputs: object[] = [{"name":"","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
constructor
constructor: object
inputs
inputs: object[] = [{"name":"_version","type":"uint256"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "constructor"
createAlastriaIdentity
createAlastriaIdentity: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"addPublicKeyCallData","type":"bytes"}]
name
name: string = "createAlastriaIdentity"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
delegateCall
delegateCall: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"_destination","type":"address"},{"name":"_value","type":"uint256"},{"name":"_data","type":"bytes"}]
name
name: string = "delegateCall"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
deleteIdentityIssuer
deleteIdentityIssuer: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"_identityIssuer","type":"address"}]
name
name: string = "deleteIdentityIssuer"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
deleteIdentityServiceProvider
deleteIdentityServiceProvider: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"_identityServiceProvider","type":"address"}]
name
name: string = "deleteIdentityServiceProvider"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
getEidasLevel
getEidasLevel: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"_identityIssuer","type":"address"}]
name
name: string = "getEidasLevel"
outputs
outputs: object[] = [{"name":"","type":"uint8"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
identityKeys
identityKeys: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"","type":"address"}]
name
name: string = "identityKeys"
outputs
outputs: object[] = [{"name":"","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
isIdentityServiceProvider
isIdentityServiceProvider: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"_identityServiceProvider","type":"address"}]
name
name: string = "isIdentityServiceProvider"
outputs
outputs: object[] = [{"name":"","type":"bool"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
isOwner
isOwner: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"addr","type":"address"}]
name
name: string = "isOwner"
outputs
outputs: object[] = [{"name":"","type":"bool"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
owner
owner: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "owner"
outputs
outputs: object[] = [{"name":"","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
pendingIDs
pendingIDs: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"","type":"address"}]
name
name: string = "pendingIDs"
outputs
outputs: object[] = [{"name":"","type":"uint256"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
prepareAlastriaID
prepareAlastriaID: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"_signAddress","type":"address"}]
name
name: string = "prepareAlastriaID"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
recoverAccount
recoverAccount: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"accountLost","type":"address"},{"name":"newAccount","type":"address"}]
name
name: string = "recoverAccount"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
transfer
transfer: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"newOwner","type":"address"}]
name
name: string = "transfer"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
updateIdentityIssuerEidasLevel
updateIdentityIssuerEidasLevel: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"_identityIssuer","type":"address"},{"name":"_level","type":"uint8"}]
name
name: string = "updateIdentityIssuerEidasLevel"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
version
version: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "version"
outputs
outputs: object[] = [{"name":"","type":"uint256"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
AlastriaPresentationRegistry
AlastriaPresentationRegistry: object
PresentationUpdated
PresentationUpdated: object
anonymous
anonymous: boolean = false
inputs
inputs: object[] = [{"indexed":false,"name":"hash","type":"bytes32"},{"indexed":false,"name":"status","type":"uint8"}]
name
name: string = "PresentationUpdated"
type
type: string = "event"
addSubjectPresentation
addSubjectPresentation: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"subjectPresentationHash","type":"bytes32"},{"name":"URI","type":"string"}]
name
name: string = "addSubjectPresentation"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
constructor
constructor: object
inputs
inputs: object[] = [{"name":"_previousPublishedVersion","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "constructor"
getPresentationStatus
getPresentationStatus: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"subjectStatus","type":"uint8"},{"name":"receiverStatus","type":"uint8"}]
name
name: string = "getPresentationStatus"
outputs
outputs: object[] = [{"name":"","type":"uint8"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "pure"
type
type: string = "function"
getReceiverPresentationStatus
getReceiverPresentationStatus: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"receiver","type":"address"},{"name":"receiverPresentationHash","type":"bytes32"}]
name
name: string = "getReceiverPresentationStatus"
outputs
outputs: object[] = [{"name":"exists","type":"bool"},{"name":"status","type":"uint8"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
getSubjectPresentationList
getSubjectPresentationList: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"subject","type":"address"}]
name
name: string = "getSubjectPresentationList"
outputs
outputs: object[] = [{"name":"","type":"uint256"},{"name":"","type":"bytes32[]"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
getSubjectPresentationStatus
getSubjectPresentationStatus: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"subject","type":"address"},{"name":"subjectPresentationHash","type":"bytes32"}]
name
name: string = "getSubjectPresentationStatus"
outputs
outputs: object[] = [{"name":"exists","type":"bool"},{"name":"status","type":"uint8"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
previousPublishedVersion
previousPublishedVersion: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "previousPublishedVersion"
outputs
outputs: object[] = [{"name":"","type":"address"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
subjectPresentationListRegistry
subjectPresentationListRegistry: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"","type":"address"},{"name":"","type":"uint256"}]
name
name: string = "subjectPresentationListRegistry"
outputs
outputs: object[] = [{"name":"","type":"bytes32"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
subjectPresentationRegistry
subjectPresentationRegistry: object
constant
constant: boolean = true
inputs
inputs: object[] = [{"name":"","type":"address"},{"name":"","type":"bytes32"}]
name
name: string = "subjectPresentationRegistry"
outputs
outputs: object[] = [{"name":"exists","type":"bool"},{"name":"status","type":"uint8"},{"name":"URI","type":"string"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"
updateReceiverPresentation
updateReceiverPresentation: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"receiverPresentationHash","type":"bytes32"},{"name":"status","type":"uint8"}]
name
name: string = "updateReceiverPresentation"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
updateSubjectPresentation
updateSubjectPresentation: object
constant
constant: boolean = false
inputs
inputs: object[] = [{"name":"subjectPresentationHash","type":"bytes32"},{"name":"status","type":"uint8"}]
name
name: string = "updateSubjectPresentation"
outputs
outputs: undefined[] = []
payable
payable: boolean = false
stateMutability
stateMutability: string = "nonpayable"
type
type: string = "function"
version
version: object
constant
constant: boolean = true
inputs
inputs: undefined[] = []
name
name: string = "version"
outputs
outputs: object[] = [{"name":"","type":"int256"}]
payable
payable: boolean = false
stateMutability
stateMutability: string = "view"
type
type: string = "function"


{{trOfferHost.offer.maxGuests, plural, offset:1 =0 {No guests.} =1 {At most one guest.} other {At most {{ trOfferHost.offer.maxGuests }} guests.} }}
Offering hospitality and welcoming “strangers” to our homes strengthens our faith in each other.


二黄的三亩一分地
About
Contact
Jun 20, 2021
Welcome To Jekyll
May 20, 2021
Welcome To Jekyll
May 20, 2020
Some articles are just so long they deserve a really long title to see if things will break well
May 20, 2019
This post demonstrates post content styles
May 20, 2019
Some articles are just so long they deserve a really long title to see if things will break well
程序员一枚，偶尔写点东西


---
layout: portal
category: reject
tags: reject
id: 155
imgurl: https://lh4.ggpht.com/obJpEUp-U4AsIR-jOYejXWA1dflDJ295u7O3Ggyltmvxc0wQTORF75kFZ9BG2etyJVR05iparb1zL9Y9afF-
portalname: 流木のベンチ
sentdate: Wed May 06 06:48:05 JST 2015
title: 155 - 流木のベンチ
---
From: Ingress Operations<EMAIL_ADDRESS>Date: 2015年5月5日(火) 午後5:32
Subject: Ingress Portal Rejected: 流木のベンチ
To: **
Thank you for your Portal submission. However, this Portal candidate does not meet the criteria required for approval.
Please refer to New Portal Submission criteria at our Help Center for further information.


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| async-fragment-to-await-transformer.js | 100% | 23/23 | 90% | 9/10 | 100% | 1/1 | 100% | 23/23 | |
| await-nested-tag-transformer.js | 86.67% | 13/15 | 75% | 6/8 | 100% | 1/1 | 86.67% | 13/15 | |
| await-reorderer-tag.js | 91.89% | 34/37 | 75% | 12/16 | 100% | 5/5 | 91.89% | 34/37 | |
| await-tag-transformer.js | 88.24% | 45/51 | 87.5% | 21/24 | 100% | 1/1 | 88.24% | 45/51 | |
| await-tag.js | 93.22% | 110/118 | 83.95% | 68/81 | 83.33% | 10/12 | 93.16% | 109/117 | |
| client-reorder-browser.js | 0% | 0/1 | 100% | 0/0 | 100% | 0/0 | 0% | 0/1 | |
| client-reorder-runtime.js | 0% | 0/21 | 0% | 0/8 | 0% | 0/1 | 0% | 0/21 | |
| client-reorder-runtime.min.js | 0% | 0/17 | 0% | 0/8 | 0% | 0/1 | 0% | 0/1 | |
| client-reorder.js | 100% | 8/8 | 100% | 2/2 | 100% | 1/1 | 100% | 8/8 |


As I begin the uphill trek to firmly understand The Math of Machine Learning, the first stop on my ascension is The Gradient. In cliche fashion, not only does The Gradient help to descend the treacherous curve of an Objective Function, it has also forced me (as the learner) to tumble to the mountain’s base, and learn a few fundamentals. Recommended pre-requisites:
This series is written as I, the learner, writer and Software Engineer, complete a series of online Math classes to understand Machine Learning. Each post will start explaining why the chosen concept is significant in the ML space.
The Gradient is significant primarily due to its use in Gradient Descent algorithms - the most popular flavor being Stochastic (fancy word for random) Gradient Descent (SGD). SGD is used in a wide gamut of models, including Logistic Regression and Neural Networks. When iterating to find ideal weights for a model, The Gradient is a vector that points in the direction of greatest slope in n-dimensional space. In other words, for a given model, it helps the model converge (quickly) on a local minimum.


CartConvert -- convert geodetic coordinates to geocentric or local cartesian
CartConvert [ -r ] [ -l lat0 lon0 h0 ] [ -e a f ] [ -w ] [ -p prec ] [ --comment-delimiter commentdelim ] [ --version | -h | --help ] [ --input-file infile | --input-string instring ] [ --line-separator linesep ] [ --output-file outfile ]
Convert geodetic coordinates to either geocentric or local cartesian coordinates. Geocentric coordinates have the origin at the center of the earth, with the z axis going thru the north pole, and the x axis thru latitude = 0, longitude = 0. By default, the conversion is to geocentric coordinates. Specifying -l lat0 lon0 h0 causes a local coordinate system to be used with the origin at latitude = lat0, longitude = lon0, height = h0, z normal to the ellipsoid and y due north.
Geodetic coordinates are provided on standard input as a set of lines containing (blank separated) latitude, longitude (decimal degrees or degrees, minutes and seconds), and height above the ellipsoid (meters); for details on the allowed formats for latitude and longitude, see the GEOGRAPHIC COORDINATES
section of GeoConvert(1). For each set of geodetic coordinates, the corresponding cartesian coordinates x, y, z (meters) are printed on standard output.
perform the reverse projection. x, y, z are given on standard input and each line of standard output gives latitude, longitude, height.
specifies conversions to and from a local cartesion coordinate systems with origin lat0 lon0 h0, instead of a geocentric coordinate system. The -w flag can be used to swap the default order of the 2 geographic coordinates, provided that it appears before -l.
specify the ellipsoid via the equatorial radius, a and the flattening, f. Setting f = 0 results in a sphere. Specify f < 0 for a prolate ellipsoid. A simple fraction, e.g., 1/297, is allowed for f. By default, the WGS84 ellipsoid is used, a = 6378137 m, f = 1/298.257223563.
toggle the longitude first flag (it starts off); if the flag is on, then on input and output, longitude precedes latitude (except that, on input, this can be overridden by a hemisphere designator, N, S, E, W).
set the output precision to prec (default 6). prec is the number of digits after the decimal point for geocentric and local cartesion coordinates and for the height (in meters). For latitudes and longitudes (in degrees), the number of digits after the decimal point is prec + 5.
set the comment delimiter to commentdelim (e.g., "#" or "//"). If set, the input lines will be scanned for this delimiter and, if found, the delimiter and the rest of the line will be removed prior to processing and subsequently appended to the output line (separated by a space).
print version and exit.
print usage and exit.
print full documentation and exit.
read input from the file infile instead of from standard input; a file name of "-" stands for standard input.
read input from the string instring instead of from standard input. All occurrences of the line separator character (default is a semicolon) in instring are converted to newlines before the reading begins.
set the line separator character to linesep. By default this is a semicolon.
write output to the file outfile instead of to standard output; a file name of "-" stands for standard output.
echo 33.3 44.4 6000 | CartConvert
=> 3816209.60 3737108.55 3485109.57
echo 33.3 44.4 6000 | CartConvert -l 33 44 20
=> 37288.97 33374.29 5783.64
echo 30000 30000 0 | CartConvert -r
=> 6.483 45 -6335709.73
An illegal line of input will print an error message to standard output beginning with ERROR:
and causes CartConvert to return an exit code of 1. However, an error does not cause CartConvert to terminate; following lines will be converted.
The algorithm for converting geocentric to geodetic coordinates is given in Appendix B of C. F. F. Karney, Geodesics on an ellipsoid of revolution, Feb. 2011; preprint http://arxiv.org/abs/1102.1215.
CartConvert was written by Charles Karney.
CartConvert was added to GeographicLib, http://geographiclib.sourceforge.net, in 2009-02. Prior to 2009-03 it was called ECEFConvert.


I felt a sudden urge to write a chat application during Scala Days. Writing the server side code in Scala was fun and only took like 30 minutes. The JavaScript part was not nearly as gratifying. Changing the client to AngularJS over the last couple of days allowed me to reclaim client side development joy.
UPDATE 06/27/2013: Here is how it looks like. Deploy it yourself if you want full chat functionality.
There should be actors randomly reciting Romeo and Juliet in Room 1 above if everything is working, but that’s not our problem right now. Last month I was writing about Server Sent Events vs. WebSockets and decided to go with SSE for my BirdWatch application. In that application information only flows from server to the client though so I wanted a proof of concept that REST style calls are an appropiate way to communicate back with the server.
I challenged myself to write a chat server for this purpose, with 10 lines of code on the server side (or less). I knew this would be possible thanks to the awesome Play Iteratee library:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
|
What happens here is fairly straightforward once we look at the drawing:
The Concurrent object is the central information hub which provides us with a channel to push JSON into. The messages from all clients are pushed into the chatChannel Broadcaster. The individual streaming connections then attach an Iteratee to the provided chatOut Enumerator, with Enumeratees in between.
What is an Iteratee? An Iteratee is a function that represents a single step of an ongoing computation. Any state it might have is immutable; supplying input results in a new function / a new Iteratee. This ongoing computation is driven by an Enumerator which keeps track of the latest step. The Enumerator calls the associated Iteratee function with new input when available and then stores that resulting Iteratee (and so on). The way state is handled is somewhat comparable to a fold function that holds intermediate state in an accumulator using an immutable data structure, with the difference here being that the computation can run over an infinite stream.
Enumeratees are adapters between Enumerators and Iteratees. They allow for example type transformation or filtering. The filter Enumeratee makes sure input is only used when the input matches the criteria, which here is the message being for the correct chat room for a particular stream / client connection. EventSource provides a transforming Enumeratee for wrapping chunks as Server Sent Events.
In the chatFeed function we have a chain of Enumerator and two Enumeratees: chatOut &> filter(room) &> EventSource() which results in a composed Enumerator. We pass this composed Enumerator into Ok.stream, which internally connects the Enumerator with a simple Iteratee. This simple Iteratee does not hold intermediate state, it only does something for each input item: deliver it as a chunk of bytes to the client over the open HTTP connection.
Let’s visualize this:
A message is pushed into the chatChannel and distributed to all attached Iteratees (wrapped by the filter Enumeratee and the EventSource). The message is then sent to the client as a Server Sent Event, but only if the filter predicate evaluates to true.
AngularJS Client
I wrote an initial version using jQuery to manipulate the DOM. It worked fine, just getting there wasn’t really much fun at all. I would have liked the expressive greatness of templates in Play, but without having to reload the page every time the model changes.
Last week I started learning AngularJS, so I thought I’d give it a try. The resulting code is not only more than 30% smaller, it also also is a real pleasure to work with. Dynamic views are written in an extended HTML vocabulary which attaches elements on the page to the $scope, which can be seen as the ViewModel of the application. The views are then automatically updated when the associated data changes.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
|
The latest 10 items within $scope.msgs are rendered into the “chat” div above. The color of each div is also defined in the view by testing if the current user is the sender of the message and adding css class ‘others’ if not. No more direct DOM manipulation. Very nice.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
|
The $scope is managed by AngularJS and we declare its properties inside the controller, for example $scope.msgs as an empty array. Whenever new messages come in, they are appended to the array, automagically updating the view. Note that manipulations to the data structure that are not triggered by AngularJS itself must be wrapped in an apply() call in order to update the UI. That was one of the valuable lessons I learned.
I have to say I am really impressed by AngularJS, it is a great addition to my toolbox. I now feel that client side development will be as much fun as server side development already is with Play Framework. I will probably use this newly gained knowledge in the next version of the BirdWatch application.
If you enjoyed this post, then make sure you subscribe to my Newsletter.
There is a follow-up article with the lessons learned, please check it out if you are interested in the server side problems I encountered while running the demo application.
-Matthias


February, 3rd, 2017
Hotel ibis Brussels Centre St Catherine
rue Joseph Plateau N°2
1000 Brussels - Belgium
Meet the 100% open source software development analytics platform used by several open source projects, communitites, engineering teams to track and analyze their development activities, communities health, diversity, etc.
This conference will show GrimoireLab updates, use cases and practical workshop/s for developers, community managers, project managers, etc.
The workshop/s will cover the basic training for using open source Grimoire toolkit for tracking Open Source and Inner Source software development processes to manage them through metrics and KPIs.
Community managers, software development managers, developers and generally anyone involved in Open Source and Inner Source software development will learn through real examples how to set up and use Grimoire for their specific needs.
13:30 - 14:00 Registration
14:00 - 15:00 Keynote: past, present and future of Grimoire Lab
15:00 - 15:30 Break & networking
15:30 - 16:20 Grimoire Lab tutorial: architecture, deployment, dashboards, etc.
16:30 - 17:30 Grimoire Lab tutorial: development, third parties integration, etc.
17:30 - ... Up to you
Hotel ibis Brussels Centre St Catherine
rue Joseph Plateau N°2
1000 Brussels - Belgium
We have some free tickets for teachers, students and researchers. Feel free to contact us asking for them before they are over


Welcome to Real Time Image Interpolation App
Developed By
Shreyam
Using The Paper
RIFE - Real Time Video Interpolation
Now wait for some time (maybe more than 3 mins)
First Frame:
Last Frame:
use Following Sample
Images(click here)
for Trial Run
Here's an Example:First Frame, Last Frame and the output respectively
Rules:
1.Use Actual Frames from a video (Not The sceenshot/screensnip ,due to change in aspect ratio between Frames.
2. It is a Computationally heavy Process, It will take considerable amount of time.
3. Use small resolution image for faster Output.
Developed By
Shreyam
Using The Paper
RIFE - Real Time Video Interpolation


Toggle navigation
Project name
Home
About
Contact
Dropdown
Action
Another action
Something else here
Nav header
Separated link
One more separated link
Profile


Empyreal
-
Utilities
-
Content
-
Components
-
Forms
A modern, blazing fast, responsive front-end framework to make powerful human interfaces.
Version 0.0.1
Beautiful UI in just a few lines and functional javascript, that is also blazing fast. All the hard work done for you and handed to you on a silver platter. What more could you ask from a framework.
Learn MoreLorem ipsum dolor sit amet consectetur adipisicing elit. Perferendis, aliquam quia. Praesentium eaque repellendus odio! Sunt vitae ratione alias assumenda? Ea similique magni deserunt quia.
Learn MoreDetailed documentation, easy syntax as well as good examples to help you get started in no time. We are also always open to feedback and can answer any questions a user may have about Betterial.
Learn MoreMIT
License
That's right, all Empyreal frameworks will always be open source.
Even More Free!


Current Money is Escrow Account
Rs {{current_escrow}}
Ongoing Events
Total Amount
Amount transferred
Fullfillment Stage
Payment ID
{{amount}}
{{transfer}} RS
One
Two
Three
qwerty123


WITNESS LIST Criminal Justice Committee August 17, 2000-1:00P HEARING ON PARDONS & PAROLES On: Andrus, Tom (TDCJ Parole Officer), Dallas Carter, Oweida (Self), Dallas Clements, Richard (TX State Employees Union), Pasadena DeVercelly, Ora (TDCJ Parole Officer), Farmers Branch Garrett, Gerald (TX Board of Pardons & Parole), Austin Gross, Michael (TX State Employees Union), Austin Holton, Ladd (Restorative Justice Ministries Network of TX), Ft. Worth Livingston, Brad (TX Department of Criminal Justice - Financial Services), Austin Maston, Veronique (TDCJ Parole Officer), Dallas McElyea, Edward (TDCJ Internal Affairs Division), Huntsville McMillian, Gary (TDCJ Parole Officer), Dallas McNutt, David (TX Department of Criminal Justice - Financial Services), Huntsville Mora, David (TDCJ Parole Officer), Dallas Parker, Patrick (TDCJ Parole Officer), Dallas Pickard, Denise (TDCJ Parole Officer), Mesquite Reeves, Linda (Inmate Families Organization), Manchaca Robison, David (TDCJ Parole Officer), Dallas Rodriguez, Victor (TX Department of Criminal Justice -Parole Division), Huntsville Ross, Derrick (TX State Employees Union), Dallas Scott, Wayne (TX Department of Criminal Justice), Huntsville Shepperd, Val (Legislative Budget Board), Austin Wash, Bill (Highpoint Church), Arlington West, Kevin (TX State Employees Union), Pasadena Yates, Johnnie (TX State Employees Union), Dallas Registering, but not testifying: On: Fabelo, Dr. Tony (TX Criminal Justice Policy Council), Austin Knowles, Bob (Dallas Sheriff's Department), Dallas Leveling, Capt. Gregory (Denton Co. Sheriff's Office), Denton Lewis, Bill (MADD), Keller Pavlock, Janet (TDCJ Parole Officer), Huffman Powell, Capt. Bob (Denton Co. Sheriff's Office), Denton Rayzer, Oliver (Dallas Area Northstar Authority), Dallas Rogers, William (Denton County Sheriff's Office), Denton Ryan, Phil (Sheriff's Departments), Decatur Simmons, Kenneth (TDCJ Parole Officer), Ft. Worth


I rarely put anything in my coffee, but I'll make an exception for my sister-in-law's homemade Irish cream. ☕💥
1/4/2014, 10:14:00 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
I rarely put anything in my coffee, but I'll make an exception for my sister-in-law's homemade Irish cream. ☕💥
1/4/2014, 10:14:00 AM
Favs: 0
Retweets: 0
link


Home
Locations and Scheduling
Contact Us
Locations and Scheduling
Information
1.
Where do you live?
Choose Your Community:
The Slate...Fridays
The Grove...Saturdays
The Domain...Sundays
Obnoxious Arms...whenever they feel
2.
Choose Your Package
Which Package Would You Like?
Knock the Dust off: $20
Make it Shiny: $28
Flossmode: $35
3.
Enter Your Name and Mobile Number
Place Order


API Documentation¶
Power Curve¶
-
class
sourcecodes.example_module.
ExampleModule
(**kwargs)[source]¶ Some documentation about the class.
It’ll get rendered in the auto generated docs. If Kanye could see this he’d rap about how great it is.
-
example_method
(example_arg, example_kwarg=None)[source]¶ A public method to show parameter stuff in docstrings
- Parameters
example_arg – Document the function parameter
example_kwarg – Document the function parameter
- Returns
None
-
example_of_how_to_refer_to_a_file_in_the_package
()[source]¶ Method showing how to reference files within the package
You need to refer to the file in the package bundle, because you don’t know where the module will be called from… this gets you the right path always, relative to sourcecodes
Don’t forget to include non-python files in the MANIFEST.in too!
-
More Example¶
-
sourcecodes.
example_module


Hey, nice to meet you. My name is Andrey, and I'm one of the creators of the Seamless Cloud.
 We created it to help you automate your routine tasks with ease and spend more time living and doing what you love.
Since we are in beta right now, there are some limitations:
If you have any feedback about the product or a question, please just reply to this email.


Implementation of a generic iterator for dense vectors and matrices.The DenseIterator represents a generic random-access iterator that can be used for dense vectors and specific rows/columns of dense matrices.
More...
#include <DenseIterator.h>
template<typename Type, bool AF>
class blaze::DenseIterator< Type, AF >
Implementation of a generic iterator for dense vectors and matrices.
The DenseIterator represents a generic random-access iterator that can be used for dense vectors and specific rows/columns of dense matrices.
◆ DenseIterator() [1/2]
template<typename Type , bool AF>
Constructor for the DenseIterator class.
- Parameters
-
| ptr | Pointer to the initial element. |
◆ DenseIterator() [2/2]
template<typename Type , bool AF>
template<typename Other , bool AF2>
Conversion constructor from different DenseIterator instances.
- Parameters
-
◆ base()
template<typename Type , bool AF>
Low-level access to the underlying member of the iterator.
- Returns
- Pointer to the current memory location.
◆ load()
template<typename Type , bool AF>
Load of the SIMD element at the current iterator position.
- Returns
- The loaded SIMD element.
This function performs a load of the SIMD element of the current element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
◆ loada()
template<typename Type , bool AF>
Aligned load of the SIMD element at the current iterator position.
- Returns
- The loaded SIMD element.
This function performs an aligned load of the SIMD element of the current element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
◆ loadu()
template<typename Type , bool AF>
Unaligned load of the SIMD element at the current iterator position.
- Returns
- The loaded SIMD element.
This function performs an unaligned load of the SIMD element of the current element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
◆ operator*()
template<typename Type , bool AF>
Direct access to the element at the current iterator position.
- Returns
- Reference to the current element.
◆ operator++() [1/2]
template<typename Type , bool AF>
Pre-increment operator.
- Returns
- Reference to the incremented iterator.
◆ operator++() [2/2]
template<typename Type , bool AF>
Post-increment operator.
- Returns
- The previous position of the iterator.
◆ operator+=()
template<typename Type , bool AF>
Addition assignment operator.
- Parameters
-
| inc | The increment of the iterator. |
- Returns
- Reference to the incremented iterator.
◆ operator--() [1/2]
template<typename Type , bool AF>
Pre-decrement operator.
- Returns
- Reference to the decremented iterator.
◆ operator--() [2/2]
template<typename Type , bool AF>
Post-decrement operator.
- Returns
- The previous position of the iterator.
◆ operator-=()
template<typename Type , bool AF>
Subtraction assignment operator.
- Parameters
-
| dec | The decrement of the iterator. |
- Returns
- Reference to the decremented iterator.
◆ operator->()
template<typename Type , bool AF>
Direct access to the element at the current iterator position.
- Returns
- Pointer to the element at the current iterator position.
◆ operator[]()
template<typename Type , bool AF>
Direct access to the underlying elements.
- Parameters
-
- Returns
- Reference to the accessed value.
◆ store()
template<typename Type , bool AF>
Store of the SIMD element at the current iterator position.
- Parameters
-
| value | The SIMD element to be stored. |
- Returns
- void
This function performs a store of the SIMD element of the current element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
◆ storea()
template<typename Type , bool AF>
Aligned store of the SIMD element at the current iterator position.
- Parameters
-
| value | The SIMD element to be stored. |
- Returns
- void
This function performs an aligned store of the SIMD element of the current element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
◆ storeu()
template<typename Type , bool AF>
Unaligned store of the SIMD element at the current iterator position.
- Parameters
-
| value | The SIMD element to be stored. |
- Returns
- void
This function performs an unaligned store of the SIMD element of the current element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
◆ stream()
template<typename Type , bool AF>
Aligned, non-temporal store of the SIMD element at the current iterator position.
- Parameters
-
| value | The SIMD element to be stored. |
- Returns
- void
This function performs an aligned, non-temporal store of the SIMD element of the current element. This function must NOT be called explicitly! It is used internally for the performance optimized evaluation of expression templates. Calling this function explicitly might result in erroneous results and/or in compilation errors.
The documentation for this class was generated from the following file:


It is often useful for an application to be able to write out data in an orderly manner to be read by another program or sent to a device such as a printer or modem. GEOS provides a mechanism called a stream to allow an orderly flow of data between two programs, between two threads of a multi-threaded program, or between a program and a device such as a serial or parallel port. The stream interface includes various ways to notify a program that bytes are available to read, or that there is room to write additional data.
The GEOS parallel and serial port drivers use the stream mechanism, so programs that will use these ports must do so via this mechanism; however, libraries exist to handle some of the more common uses for port communications. Programs do not need to access the serial or parallel ports in order to print because the spooler does it for them. For more information about the spooler and printing, see .
This chapter may be read with only a general understanding of GEOS and Object Assembly. Messaging is used heavily in informing the application using a stream of the stream's status, so a good understanding of object-oriented programming will be helpful. You should also be familiar with the GEOS memory manager. The chapter is divided into three main sections:
1 Using Streams: The Basics
1.1 Initializing a Stream
1.2 Blocking on Read or Write
1.3 Writing Data to a Stream
1.4 Reading Data from a Stream
1.5 Shutting Down a Stream
1.6 Miscellaneous Functions
2 Using the Serial Ports
2.1 Initializing a Serial Port
2.2 Communicating
2.3 Closing a Serial Port
3 Using the Parallel Ports
3.1 Initializing a Parallel Port
3.2 Communicating
3.3 Closing a Parallel Port
A stream is a path along which information flows in one direction. At one end of the stream is a writer , who puts data into the stream. At the opposite end of the stream is a reader , who receives data from the stream. The writer and reader can be GEOS programs or device drivers. Data flow in both directions can be achieved by using two streams, one in each direction; this is how the serial port driver is implemented.
Even though the stream driver is loaded automatically when a stream is created, you will need to initialize, configure, and destroy any streams you use. The specific steps involved in this process are
GeodeUseDriver()
.Streams are created and managed by the Stream Driver . Programs written in Object-Assembly can call the driver directly. Goc programs cannot do this; instead, they make calls to the Stream Library , which in turn calls the Stream Driver, and passes back any return values.
A stream is essentially a first-in-first-out data buffer, in which the writer is different from the reader. When the writer writes data to the stream, the kernel stores it in the buffer; when the reader requests information from the stream, the kernel retrieves the oldest data not yet read. The data is stored in a memory block; this block may be either fixed or movable. If it is movable, both the reader and the writer must lock the block before calling any stream routines.
Note that the kernel does not enforce who is the reader or writer to a stream. Any geode may call the appropriate stream library routine, passing in the token for a stream, and read or write data. However, in practice, only those threads with a legitimate interest in a stream will know the stream's token.
The serial and parallel drivers are built on top of the stream driver. There are separate routines to access the serial and parallel ports; these routines are discussed in Using the Serial Ports for the serial driver and Using the Parallel Ports for the parallel driver.
StreamOpen()
To create and initialize a new stream, call the routine
StreamOpen()
. This routine takes five arguments:
GeodeHandle
of the geode that will own this stream. When this geode exits, the stream will be freed; however, you should call
StreamClose()
before this happens.
HeapFlags
. The routine will have to allocate a block to hold the stream. The
HeapFlags
specify whether that block will be fixed or movable. If it is fixed, this argument should contain the flag HF_FIXED; otherwise it should be blank.
StreamToken
variable.
StreamOpen()
will create the stream and write its token to this variable. You will need this token whenever you access the stream, for reading or writing.
If the creation is successful,
StreamOpen()
will return zero and store the stream's token in the
StreamToken
variable. You must see to it that both the reader and the writer have this token. If the stream cannot be created, the strategy routine will set an error flag and return either STREAM_CANNOT_ALLOC (if the memory for the stream's buffer cannot be allocated) or STREAM_BUFFER_TOO_LARGE (if the requested stream size was greater than 32767).
Once a stream is created, you must make sure that both ends will be managed--a stream that has only a writer or only a reader is not a useful stream.
When communicating with a device such as a serial or parallel port, the port is considered to be the entity on the other end. However, if two threads are communicating via a stream, you must make sure the other thread can gain access to the stream. The best way to do this is to set up a message that will be sent by the creator to the other geode. This message should contain as an argument the token of the stream and probably the direction of the stream (whether the creator will be reading or writing).
Once both geodes have the stream's token, each can access the stream normally. The next several sections explain how to access a stream for writing and reading.
StreamBlocker, StreamError, StreamGetError(), StreamSetError()
A stream is a data buffer of limited size. When a thread writes to the stream, there is a chance it could run out of space. Similarly, when a thread reads from the stream, there is a possibility that it will try to read more data than is available; for example, it might try to read 500 bytes, when only 250 bytes of data are sitting in the stream.
There are two ways you can deal with these situations. One way is, you can instruct the thread to block. For example, if you try to write 500 bytes to a stream and there is only 200 bytes of space available, the driver will write the first 200 bytes to that space, then have the writing thread block until more space is available (i.e. until the reading thread has read some data). The writing thread will not resume execution until all the data has been written. Similarly, a reading thread could block until the stream provided all the data it requested.
The other approach is to have the stream driver write or read all it can, then return an appropriate error code. This requires a little more work by the calling thread, as it cannot assume that all the data is always read or written; however, it avoids the risk of deadlock.
All read and write routines are passed a member of the
StreamBlocker
enumerated type. This type has two members: STREAM_BLOCK, indicating that the calling thread should block in the situations described above; and STREAM_NO_BLOCK, indicating that the routine should immediately return with an error if enough space is not available. A single thread may, if it wishes, pass STREAM_BLOCK sometimes and STREAM_NO_BLOCK sometimes.
If a stream routine returns an error, the error will be a member of the
StreamError
enumerated type. The possible error values are described in the section for each routine.
Sometimes the device or application at the other end of the stream will need to return a special error value. For example, it may have its own error enumerated type, and may wish to signal an error to the application on the other end of the stream. It can do this by calling
StreamSetError()
. This routine is passed four arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.
StreamRoles
enumerated type. The only appropriate values here are STREAM_ROLES_WRITER or STREAM_ROLES_READER.
If the routine is succesful, it returns zero. Otherwise, it returns a member of the
StreamError
enumerated type.
To read a an error value set by the other side of a stream, call
StreamGetError()
. This routine is passed four arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.
StreamRoles
enumerated type. The only appropriate values here are STREAM_ROLES_WRITER or STREAM_ROLES_READER.
If successful, the routine returns zero, and writes the other side's error value to the passed word-sized argument. If it is unsuccessful, the routine returns a
StreamError
value.
StreamWrite(), StreamWriteByte()
To write data into a stream, call the routine
StreamWrite()
. This routine takes six arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.
StreamBlocker
enumerated type, as described in Blocking on Read or Write
.
StreamWrite()
will write the number of bytes actually copied to that integer.
If all the data was written successfully,
StreamWrite()
will return zero and write the number of bytes written (i.e. the size of the data buffer passed) to the integer pointed to by the sixth argument. If it could not successfully write all the data, it will return one of the following
StreamError
values:
You may often want to write a single byte to the stream. There is a special routine to do this,
StreamWriteByte()
. This routine takes four arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.
StreamBlocker
enumerated type, as described in Blocking on Read or Write
.
If the byte is written successfully,
StreamWriteByte()
will return zero. Otherwise, it will return one of the following error values:
StreamRead(), StreamReadByte()
To read data in a stream, call the routine
StreamRead()
. This routine takes six arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.
StreamBlocker
enumerated type, as described in Blocking on Read or Write
.
StreamRead()
will write the number of bytes actually read to that integer.
If the requested amount of data was read successfully,
StreamRead()
will return zero and write the number of bytes read (i.e. the size of the data buffer passed) to the integer pointed to by the sixth argument. If it could not successfully read the requested amount of data, it will return one of the following
StreamError
values:
You may often want to read a single byte from the stream. There is a special routine to do this,
StreamReadByte()
. This routine takes four arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.
StreamBlocker
enumerated type, as described in Blocking on Read or Write
.
If the byte is written successfully,
StreamReadByte()
will return zero. Otherwise, it will return one of the following error values:
StreamClose()
Either the writer or the reader can instigate stream shutdown by calling
StreamClose()
. When one of the two calls this routine, the shut-down process is started; it will not be completed until the other calls the routine.
If the writer calls
StreamClose()
, it may specify that the data already in the buffer be
flushed
(immediately cleared), or that it
linger
. If you specify that the data should linger, the data will be preserved as long as the reader has the stream open. The reader can continue to read data normally until it runs out of data. The last read-operation will most likely return STREAM_SHORT_READ_WRITE; after that, all attempts to read data will generate the error STREAM_CLOSING. At that point, the reader should call
StreamClose()
. (If the data was flushed by the writer, the next read attempt will return STREAM_CLOSING.)
To shut down the stream, call the routine
StreamClose()
. This routine is passed the following arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.If you are using the Serial or Parallel drivers (described later in this chapter), you do not have to coordinate the closure of a stream.
StreamFlush(), StreamQuery()
To flush all the pending (written but unread) data from a stream, call the routine
StreamFlush()
. This routine is passed two arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.
To find out how much free space is available in a stream, or how much data is waiting to be read, call
StreamQuery()
. This routine is passed four arguments:
GeodeHandle
of the stream driver.
StreamToken
of the stream.
StreamRoles
enumerated type. The only appropriate values here are STREAM_ROLES_WRITER (to find the amount of free space available for writing) or STREAM_ROLES_READER (to find the amount of data waiting to be read).
If the call is successful,
StreamQuery()
returns zero and writes its return value to the fourth argument. If you pass STREAM_ROLES_WRITER,
StreamQuery()
writes the number of bytes of free space available in the stream buffer. If you pass STREAM_ROLES_READER,
StreamQuery()
returns the number of bytes of data waiting to be read. If the call is unsuccessful,
StreamQuery()
returns a
StreamError
.
The serial driver uses streams to control the flow of data to and from serial ports. The kernel automatically copies data from the serial port into one stream for reading, and sends data from another stream into the serial port. An application which wishes to use the serial port simply reads and writes data from those streams.
Like the stream driver, the serial driver is not accessed directly from Goc code. Instead, a Goc application makes calls to the Stream Library, which passes the requests through to the Serial Driver's strategy routine. Each serial-port command must be passed the
GeodeHandle
of the Serial Library; again, you can find this handle by calling
GeodeGetInfo()
.
The serial driver uses two streams, one for data going out to the serial port (outgoing) and one for data coming in from the serial port (incoming). Your program is the writer of the outgoing and the reader of the incoming. (In both cases, the port acts as the opposite user.)
SerialOpen()
To open a serial port, call the routine
SerialOpen()
. This routine is passed the following arguments:
GeodeHandle
of the serial-port driver.
SerialUnit
enumerated type; this specifies which serial port is being opened. The type's members are SERIAL_COM1, SERIAL_COM2, and so on up to SERIAL_COM8.
StreamOpenFlags
enumerated type, indicating what to do if the requested serial port is busy (either STREAM_OPEN_NO_BLOCK, indicating that the routine should return an error immediately; or STREAM_OPEN_TIMEOUT, indicating that the routine should wait a specified number of clock ticks to see if the port will free up).
A flag is returned to indicate whether the serial port could be opened; if not, a value of type
StreamError
will be returned to indicate the reason. Possible stream error values are STREAM_BUFFER_TOO_LARGE and STREAM_CANNOT_CREATE, and the additional values STREAM_NO_DEVICE (if the serial port does not exist) or STREAM_DEVICE_IN_USE (if the device is busy and the
StreamOpenFlags
passed indicate not to wait).
Note that when using the serial driver, you do not identify the stream by a stream token but rather by the serial port number, known as a unit number . When accessing a serial port, you simply pass the port's unit number along with either STREAM_READ (if reading from the stream) or STREAM_WRITE (if writing to the stream); because each port has two streams associated with it, you must specify both parameters. The serial driver will understand which stream you are accessing.
SerialSetFormat(), SerialGetFormat(),SerialSetModem(), SerialGetModem(), SerialSetFlowControl()
Communication using a serial port requires that parity, speed, and flow control be properly set. To control these settings, call
SerialSetFormat()
, passing the following arguments:
GeodeHandle
of the serial-port driver.
SerialUnit
enumerated type.
SerialFormat
, specifying the parity, word length, and number of stop bits to be used on the serial line; this record is described below.
SerialMode
enumerated type, set to indicate the level of flow control: SM_COOKED to indicate XON/XOFF flow control with characters stripped to seven bits, SM_RARE to indicate XON/XOFF flow control but incoming characters left alone, or SM_RAW to indicate no flow control.
SerialBauds
, which has the following members:typedef enum { SERIAL_BAUD_115200 = 1, SERIAL_BAUD_57600 = 2, SERIAL_BAUD_38400 = 3, SERIAL_BAUD_19200 = 6, SERIAL_BAUD_14400 = 8, SERIAL_BAUD_9600 = 12, SERIAL_BAUD_7200 = 16, SERIAL_BAUD_4800 = 24, SERIAL_BAUD_3600 = 32, SERIAL_BAUD_2400 = 48, SERIAL_BAUD_2000 = 58, SERIAL_BAUD_1800 = 64, SERIAL_BAUD_1200 = 96, SERIAL_BAUD_600 = 192, SERIAL_BAUD_300 = 384 } SerialBaud;
SerialFormat
is a byte-sized record that specifies the parity, word-length, and number of stop bits for the serial line. The record has the following fields:
SerialParity
enumerated type, which has the following members:typedef enum { SERIAL_PARITY_NONE = 0, SERIAL_PARITY_ODD = 1, SERIAL_PARITY_EVEN = 3, SERIAL_PARITY_ONE = 5, SERIAL_PARITY_MARK = 5, SERIAL_PARITY_ZERO = 7, SERIAL_PARITY_SPACE = 7 } SerialParity;
To find out the current settings of a serial port, call
SerialGetFormat()
. This routine is passed five arguments:
GeodeHandle
of the serial-port driver.
SerialUnit
enumerated type.
SerialFormat
variable.
SerialGetFormat()
will write the format data to this variable.
SerialMode
variable.
SerialGetFormat()
will write the appropriate mode constant (SM_COOKED, XON/XOFF, or SM_RARE) to this variable.
SerialBaud
variable.
SerialFormat()
will write the appropriate constant to this variable.As with other serial port routines, if the routine is successful, it will return zero; if it is unsuccessful, it will return an error code.
If you are using a modem's hardware flow control, you will have to configure the modem appropriately. You can do this by calling
SerialSetModem()
. This routine is passed three arguments:
GeodeHandle
of the serial-port driver.
SerialUnit
enumerated type.
SerialModem
. This record has four fields: SERIAL_MODEM_OUT2, SERIAL_MODEM_OUT1, SERIAL_MODEM_RTS, and SERIAL_MODEM_DTR. Set these fields to indicate how the control-bits should be set.
To find out what flow control is being used, call
SerialGetModem()
. This routine is passed three arguments:
GeodeHandle
of the serial-port driver.
SerialUnit
enumerated type.
SerialModem
.
SerialGetModem()
will set this record's SERIAL_MODEM_OUT2, SERIAL_MODEM_OUT1, SERIAL_MODEM_RTS, and SERIAL_MODEM_DTR bits appropriately.
You can also set the flow control without setting the other format options. Do this by calling
SerialSetFlowControl()
. This routine is passed the following arguments:
GeodeHandle
of the serial-port driver.
SerialUnit
enumerated type.
SerialModem
. This record has four fields: SERIAL_MODEM_OUT2, SERIAL_MODEM_OUT1, SERIAL_MODEM_RTS, and SERIAL_MODEM_DTR. Set these fields to indicate how the control-bits should be set.
SerialMode
enumerated type, set to indicate the level of flow control: SM_COOKED to indicate XON/XOFF flow control with characters stripped to seven bits, SM_RARE to indicate XON/XOFF flow control but incoming characters left alone, or SM_RAW to indicate no flow control.
SerialModemStatus
to indicate which lines (chosen from DCD, DSR, and CTS) should be used to control outgoing data (if hardware flow control is selected). When one of the selected lines is de-asserted by the remote system, the serial driver will not transmit any more data until the state changes.SerialRead(), SerialReadByte(), SerialWrite(), SerialWriteByte(), SerialQuery(), SerialFlush(), SerialGetError(), SerialSetError(), SerialError
Communicating with a serial port is very much like using any other stream. Special versions of the stream routines are provided, but they function just like their stream counterparts.
To read data from a serial port, call
SerialRead()
or
SerialReadByte()
. These routines take the same arguments as their
Stream...()
counterparts, except that each one must be passed the handle of the Serial Driver, not the Stream Driver, and each routine is passed the
SerialUnit
for the appropriate port, instead of being passed a stream token. These routines behave exactly like their
Stream...()
counterparts.
To write data to a serial port, call
SerialWrite()
or
SerialWriteByte()
. Again, these routines behave like their
Stream...()
counterparts, and take similar arguments.
To find out if you can read or write data to the port, call
SerialQuery()
. Again, this routine behaves like its
Stream...()
equivalent. To flush any data from the input or output stream, call
SerialFlush()
.
To send an error to the other side of a serial connection, call
SerialSetError()
. This routine behaves much like
StreamSetError()
. The only difference is that the error code passed must be a member of the
SerialError
enumerated type. This type has the following members:
To read an error condition passed by the other side of a serial connection, call
SerialGetError()
. This routine behaves just like
StreamGetError()
. The error code returned will be a member of the
SerialError
enumerated type.
SerialClose(), SerialCloseWithoutReset()
To close a serial port, call the routine
SerialClose()
. This routine is passed three arguments:
GeodeHandle
of the serial-port driver.
SerialUnit
enumerated type.This function returns immediately whether the port was closed right away or not. However, if STREAM_LINGER is specified, the port may not be re-opened until all the data in the Serial Port's buffer has been dealt with.
You can also instruct the serial driver to close the stream to a port, without actually resetting the port. Do this by calling
SerialCloseWithoutReset()
. This routine is passed the same arguments as
SerialClose()
.
Using a parallel port is simpler than using a serial port since data goes in only one direction. GEOS does not currently support reading data from a parallel port.
Parallel ports are used primarily for printing, which is handled by the Spool Object Library. The information in this section is useful only to programmers whose applications will need to send data out through the parallel port without using the spooler. Most applications, however, will use the spooler for any and all parallel port use.
ParallelOpen()
To open a parallel port, call the routine
ParallelOpen()
. This routine is passed the following arguments:
GeodeHandle
of the parallel-port driver.
ParallelUnit
enumerated type; this specifies which parallel port is being opened. The type's members are PARALLEL_LPT1, PARALLEL_LPT2, PARALLEL_LPT3, and PARALLEL_COM4.
StreamOpenFlags
enumerated type, indicating what to do if the requested parallel port is busy (either STREAM_OPEN_NO_BLOCK, indicating that the routine should return an error immediately; or STREAM_OPEN_TIMEOUT, indicating that the routine should wait a specified number of clock ticks to see if the port will free up).
ParallelPortNums
.
A flag is returned to indicate whether the parallel port could be opened; if not, a value of type
StreamError
will be returned to indicate the reason. Possible stream error values are STREAM_BUFFER_TOO_LARGE and STREAM_CANNOT_CREATE, and the additional values STREAM_NO_DEVICE (if the parallel port does not exist) or STREAM_DEVICE_IN_USE (if the device is busy and the
StreamOpenFlags
passed indicate not to wait (or not to wait any longer)).
Note that when using the parallel driver, you do not identify the stream by a stream token but rather by the parallel port number, known as a unit number . When accessing a parallel port, you simply pass the port's unit number along with either STREAM_READ (if reading from the stream) or STREAM_WRITE (if writing to the stream); because each port has two streams associated with it, you must specify both parameters. The parallel driver will understand which stream you are accessing.
Once the port is selected, the PC will assert the SLCTIN signal, which usually will place the device on-line.
ParallelWrite(), ParallelWriteByte()
Writing to a parallel port is much like writing to any other stream. To write data, call
ParallelWrite()
or
ParallelWriteByte()
. These routines take the same arguments as their
Stream...()
components, except that each one must be passed the handle of the Parallel Driver, not the Stream Driver, and each routine is passed the
ParallelUnit
for the appropriate port, instead of being passed a stream token. These routines behave exactly like their
Stream...()
counterparts.
To send an error to the other side of a serial connection, call
ParallelSetError()
. (This routine is generally not called by applications.) This routine behaves much like
StreamSetError()
. It is passed four arguments:
GeodeHandle
of the parallel-port driver.
ParallelUnit
enumerated type.
StreamRoles
enumerated type.
ParallelError
record. This word-sized record has the following flags:
To read an error condition passed by the other side of a serial connection, call
ParallelGetError()
. This routine behaves much like
StreamGetError()
. The error code returned will be a member of the
ParallelError
enumerated type.
ParallelClose()
To close a parallel port,
ParallelClose()
. This routine takes the following arguments:
GeodeHandle
of the parallel-port driver.
ParallelUnit
enumerated type.This function returns immediately whether the port was closed right away or not. However, if STREAM_LINGER is specified, the port may not be re-opened until all the data in the parallel port's buffer has been dealt with.


An application for secure messaging between two clients.
Built by some of our Alumni, ACM's arcade cabinet provides members with access to the classics.


An authorization is a right assigned to users and profiles that is
checked by certain privileged programs to determine whether
users can execute restricted functionality. Each has a short code name
and a human readable description.
Typically, you will not need to add to or change any of the authorizations
on this page unless you are developing your own software that makes use of
RBAC to determine what users are allowed to do.


Invalidate sessions when users log out.
Invalidating sessions when users log out makes it harder to hijack them.
To invalidate sessions when users log out:
Identify logout functionality. Find code that is responsible for the logout functionality.
Add code to invalidate sessions. Add the following code to the logout function to invalidate the session:
session_destroy();
setcookie(session_name(), "", time() - 3600, "/");


In this area, specify which Emmet filters you want to be applied to an expanded
abbreviation before it is shown in the editor. Learn more about filters at http://docs.emmet.io/filters/.
To have a filter always applied by default, select the checkbox next to it. The available options are:


Pipeline Server URI:
Choose Pipeline: [Empty - Click Get Pipelines]
Choose Media Source: [Empty - Populate Media]
Destination Peer ID:
Actions: Inference on GPU Sync Playback
Chosen Pipeline:
Chosen Media Source:
Chosen Destination:
Pipeline Server Instance ID:
Pipeline Server Peer ID:
Our Peer ID:
Actions:


Module pl.utils
Generally useful routines.
See the Guide.
Dependencies: pl.compat
Functions
| pack (...) | pack an argument list into a table. |
| unpack (t[, i[, t]]) | unpack a table and return its contents. |
| quit (code, ...) | end this program gracefully. |
| printf (fmt, ...) | print an arbitrary number of arguments using a format. |
| fprintf (f, fmt, ...) | write an arbitrary number of arguments to a file using a format. |
| import (t, T) | take a table and ‘inject’ it into the local namespace. |
| escape (s) | escape any ‘magic’ characters in a string |
| choose (cond, value1, value2) | return either of two values, depending on a condition. |
| readfile (filename, is_bin) | return the contents of a file as a string |
| writefile (filename, str, is_bin) | write a string to a file |
| readlines (filename) | return the contents of a file as a list of lines |
| split (s, re, plain, n) | split a string into a list of strings separated by a delimiter. |
| splitv (s, re) | split a string into a number of values. |
| array_tostring (t, temp, tostr) | convert an array of values to strings. |
| quote_arg (argument) | Quote an argument of a command. |
| executeex (cmd, bin) | execute a shell command and return the output. |
| memoize (func) | ‘memoize’ a function (cache returned value for next call). |
| add_function_factory (mt, fun) | associate a function factory with a type. |
| string_lambda (lf) | an anonymous function as a string. |
| function_arg (idx, f, msg) | process a function argument. |
| bind1 (fn, p) | bind the first argument of the function to a value. |
| bind2 (fn, p) | bind the second argument of the function to a value. |
| assert_arg (n, val, tp, verify, msg, lev) | assert that the given argument is in fact of the correct type. |
| assert_string (n, val) | assert the common case that the argument is a string. |
| on_error (mode) | control the error strategy used by Penlight. |
| raise (err) | used by Penlight functions to return errors. |
| is_type (obj, tp) | is the object of the specified type?. |
| load (code, name, mode, env) | load a code string or bytecode chunk. |
| getfenv (f) | Get environment of a function. |
| setfenv (f, env) | Set environment of a function |
| execute (cmd) | execute a shell command. |
Functions
- pack (...)
-
pack an argument list into a table.
Parameters:
- ... any arguments
Returns:
-
a table with field n set to the length
- unpack (t[, i[, t]])
-
unpack a table and return its contents.
NOTE: this implementation differs from the Lua implementation in the way
that this one DOES honor the n field in the table t, such that it is ‘nil-safe’.
Parameters:
- t
index of the last element to unpack, defaults to
t.n
or #t (optional) - i index from which to start unpacking, defaults to 1 (optional)
- t
index of the last element to unpack, defaults to
t.n
or #t (optional)
Returns:
-
multiple returns values from the table
- t
index of the last element to unpack, defaults to
- quit (code, ...)
-
end this program gracefully.
Parameters:
- code The exit code or a message to be printed
- ... extra arguments for message’s format'
See also:
- printf (fmt, ...)
-
print an arbitrary number of arguments using a format.
Parameters:
- fmt The format (see string.format)
- ... Extra arguments for format
- fprintf (f, fmt, ...)
-
write an arbitrary number of arguments to a file using a format.
Parameters:
- f File handle to write to.
- fmt The format (see string.format).
- ... Extra arguments for format
- import (t, T)
-
take a table and ‘inject’ it into the local namespace.
Parameters:
- t The Table
- T An optional destination table (defaults to callers environment)
- escape (s)
-
escape any ‘magic’ characters in a string
Parameters:
- s The input string
- choose (cond, value1, value2)
-
return either of two values, depending on a condition.
Parameters:
- cond A condition
- value1 Value returned if cond is true
- value2 Value returned if cond is false (can be optional)
- readfile (filename, is_bin)
-
return the contents of a file as a string
Parameters:
- filename The file path
- is_bin open in binary mode
Returns:
-
file contents
- writefile (filename, str, is_bin)
-
write a string to a file
Parameters:
- filename The file path
- str The string
- is_bin open in binary mode
Returns:
- true or nil
- error message
Raises:
error if filename or str aren’t strings - readlines (filename)
-
return the contents of a file as a list of lines
Parameters:
- filename The file path
Returns:
-
file contents as a table
Raises:
errror if filename is not a string - split (s, re, plain, n)
-
split a string into a list of strings separated by a delimiter.
Parameters:
- s The input string
- re A Lua string pattern; defaults to ‘%s+’
- plain don’t use Lua patterns
- n optional maximum number of splits
Returns:
-
a list-like table
Raises:
error if s is not a string - splitv (s, re)
-
split a string into a number of values.
Parameters:
- s the string
- re the delimiter, default space
Returns:
-
n values
See also:
Usage:
first,next = splitv('jane:doe',':')
- array_tostring (t, temp, tostr)
-
convert an array of values to strings.
Parameters:
- t a list-like table
- temp buffer to use, otherwise allocate
- tostr custom tostring function, called with (value,index). Otherwise use tostring
Returns:
-
the converted buffer
- quote_arg (argument)
-
Quote an argument of a command.
Quotes a single argument of a command to be passed
to os.execute, pl.utils.execute or pl.utils.executeex.
Parameters:
- argument string the argument.
Returns:
-
quoted argument.
- executeex (cmd, bin)
-
execute a shell command and return the output.
This function redirects the output to tempfiles and returns the content of those files.
Parameters:
- cmd a shell command
- bin boolean, if true, read output as binary file
Returns:
- true if successful
- actual return code
- stdout output (string)
- errout output (string)
- memoize (func)
-
‘memoize’ a function (cache returned value for next call).
This is useful if you have a function which is relatively expensive,
but you don’t know in advance what values will be required, so
building a table upfront is wasteful/impossible.
Parameters:
- func a function of at least one argument
Returns:
-
a function with at least one argument, which is used as the key.
- add_function_factory (mt, fun)
-
associate a function factory with a type.
A function factory takes an object of the given type and
returns a function for evaluating it
Parameters:
- mt tab metatable
- fun func a callable that returns a function
- string_lambda (lf)
-
an anonymous function as a string. This string is either of the form
‘|args| expression’ or is a function of one argument, ‘_’
Parameters:
- lf function as a string
Returns:
-
a function
Usage:
string_lambda '|x|x+1' (2) == 3
string_lambda '_+1' (2) == 3
- function_arg (idx, f, msg)
-
process a function argument.
This is used throughout Penlight and defines what is meant by a function:
Something that is callable, or an operator string as defined by
pl.operator
, such as ‘>’ or ‘#’. If a function factory has been registered for the type, it will be called to get the function.Parameters:
- idx argument index
- f a function, operator string, or callable object
- msg optional error message
Returns:
-
a callable
Raises:
if idx is not a number or if f is not callable - bind1 (fn, p)
-
bind the first argument of the function to a value.
Parameters:
- fn a function of at least two values (may be an operator string)
- p a value
Returns:
-
a function such that f(x) is fn(p,x)
Raises:
same as function_argSee also:
- bind2 (fn, p)
-
bind the second argument of the function to a value.
Parameters:
- fn a function of at least two values (may be an operator string)
- p a value
Returns:
-
a function such that f(x) is fn(x,p)
Raises:
same as function_arg - assert_arg (n, val, tp, verify, msg, lev)
-
assert that the given argument is in fact of the correct type.
Parameters:
- n argument index
- val the value
- tp the type
- verify an optional verification function
- msg an optional custom message
- lev optional stack position for trace, default 2
Raises:
if the argument n is not the correct typeUsage:
assert_arg(1,t,'table')
assert_arg(n,val,'string',path.isdir,'not a directory')
- assert_string (n, val)
-
assert the common case that the argument is a string.
Parameters:
- n argument index
- val a value that must be a string
Raises:
val must be a string - on_error (mode)
-
control the error strategy used by Penlight.
Controls how
utils.raise
works; the default is for it to return nil and the error string, but if the mode is ‘error’ then it will throw an error. If mode is ‘quit’ it will immediately terminate the program.Parameters:
- mode
- either ‘default’, ‘quit’ or ‘error’
See also:
- mode
- raise (err)
-
used by Penlight functions to return errors. Its global behaviour is controlled
by
utils.on_error
Parameters:
- err the error string.
See also:
- is_type (obj, tp)
-
is the object of the specified type?.
If the type is a string, then use type, otherwise compare with metatable
Parameters:
- obj An object to check
- tp String of what type it should be
- load (code, name, mode, env)
-
load a code string or bytecode chunk.
Parameters:
- code Lua code as a string or bytecode
- name for source errors
- mode kind of chunk, ’t' for text, ‘b’ for bytecode, ‘bt’ for all (default)
- env the environment for the new chunk (default nil)
Returns:
- compiled chunk
- error message (chunk is nil)
- getfenv (f)
-
Get environment of a function.
With Lua 5.2, may return nil for a function with no global references!
Based on code by Sergey Rozhenko
Parameters:
- f a function or a call stack reference
- setfenv (f, env)
-
Set environment of a function
Parameters:
- f a function or a call stack reference
- env
a table that becomes the new environment of
f
- execute (cmd)
-
execute a shell command.
This is a compatibility function that returns the same for Lua 5.1 and Lua 5.2
Parameters:
- cmd a shell command
Returns:
- true if successful
- actual return code


« Take me back to saving the nation
Last updated: September 18, 2017
5calls.org ("us", "we", or "our") operates the 5 Calls website (the "Service").
This page informs you of our policies regarding the collection, use and disclosure of Personal Information when you use our Service.
We will not use or share your information with anyone except as described in this Privacy Policy.
We use your Personal Information for providing and improving the Service. By using the Service, you agree to the collection and use of information in accordance with this policy. Unless otherwise defined in this Privacy Policy, terms used in this Privacy Policy have the same meanings as in our Terms and Conditions.
Information Collection And Use
While using our Service, we may ask you to provide us with certain personally identifiable information that can be used to contact or identify you. Personally identifiable information may include, but is not limited to, your email address, name, phone number, or other information ("Personal Information").
We collect this information for the purpose of providing the Service, identifying and communicating with you, responding to your requests/inquiries, and improving our services.
Log Data
We collect information that your browser sends whenever you visit our Service ("Log Data"). This Log Data may include information such as your computer’s Internet Protocol ("IP") address, browser type, browser version, the pages of our Service that you visit, the time and date of your visit, the time spent on those pages and other statistics.
In addition, we may use third party services such as Google Analytics that collect, monitor and analyze this type of information in order to increase our Service’s functionality. These third party service providers have their own privacy policies addressing how they use such information.
When you access the Service by or through a mobile device, we may collect certain information automatically, including, but not limited to, the type of mobile device you use, your mobile device’s unique device ID, the IP address of your mobile device, your mobile operating system, the type of mobile Internet browser you use, your location information and other statistics.
Please see the section regarding Location Information below regarding the use of your location information and your options.
Location information
We may use and store information about your location depending on the permissions you have set on your device. We use this information to provide features of our Service, to improve and customize our Service. You can enable or disable location services when you use our Service at anytime, through your mobile device settings.
Cookies
Cookies are files with a small amount of data, which may include an anonymous unique identifier. Cookies are sent to your browser from a web site and transferred to your device. We use cookies to collect information in order to improve our services for you.
You can instruct your browser to refuse all cookies or to indicate when a cookie is being sent. The Help feature on most browsers provide information on how to accept cookies, disable cookies or to notify you when receiving a new cookie.
If you do not accept cookies, you may not be able to use some features of our Service and we recommend that you leave them turned on.
Service Providers
We may employ third party companies and individuals to facilitate our Service, to provide the Service on our behalf, to perform Service-related services and/or to assist us in analyzing how our Service is used.
These third parties have access to your Personal Information only to perform specific tasks on our behalf and are obligated not to disclose or use your information for any other purpose.
Specifically, we use OneSignal to help us send notifications. You can find their privacy policy located here.
Security
The security of your Personal Information is important to us, and we strive to implement and maintain reasonable, commercially acceptable security procedures and practices appropriate to the nature of the information we store, in order to protect it from unauthorized access, destruction, use, modification, or disclosure.
However, please be aware that no method of transmission over the internet, or method of electronic storage is 100% secure and we are unable to guarantee the absolute security of the Personal Information we have collected from you.
Links To Other Sites
Our Service may contain links to other sites that are not operated by us. If you click on a third party link, you will be directed to that third party’s site. We strongly advise you to review the Privacy Policy of every site you visit.
We have no control over, and assume no responsibility for the content, privacy policies or practices of any third party sites or services.
Children’s Privacy
Only persons age 18 or older have permission to access our Service. Our Service does not address anyone under the age of 13 ("Children").
We do not knowingly collect personally identifiable information from children under 13. If you are a parent or guardian and you learn that your Children have provided us with Personal Information, please contact us. If we become aware that we have collected Personal Information from a children under age 13 without verification of parental consent, we take steps to remove that information from our servers.
Changes To This Privacy Policy
This Privacy Policy is effective as of September 18, 2017 and will remain in effect except with respect to any changes in its provisions in the future, which will be in effect immediately after being posted on this page.
We reserve the right to update or change our Privacy Policy at any time and you should check this Privacy Policy periodically. Your continued use of the Service after we post any modifications to the Privacy Policy on this page will constitute your acknowledgment of the modifications and your consent to abide and be bound by the modified Privacy Policy.
If we make any material changes to this Privacy Policy, we will notify you either through the email address you have provided us, or by placing a prominent notice on our website.
Contact Us
If you have any questions about this Privacy Policy, please contact us.


This document contains some templates for websites.
What? A bunch of people coming together to talk about accessibility!
When? 18th of June, 14:00.
Till? Everyone discovers there is a limit on free drinks.
Where? ImpactHub, Haarlemmerweg 10C, 1014 BE Amsterdam.
(Location on Google Maps)
Costs? We will cover the venue, some snacks, and your first two drinks.
Sounds good right?
If you want to come, tell Job on Twitter or send Michiel an e-mail.
We are also looking for a few people to give a so called lightning talk—these are short talks that last anywhere between 5 and 10 minutes; so if you're up for that, please tell us.
Some of our attendees will give a lightning talk—short talks that last between 5 and 10 minutes.
These will fill about an hour and a half of our time.
If all goes as plannend, these lightning talks will start around 14:30.
You can roll right into the role=drinks venue! There is an elevator to take you to the second floor—and quite possibly also back down again. Guide animals—be it dogs or dinosaurs—are also welcome. There is a park right outside where you can walk your dinosaur to go poop.
A Dutch sign language (NGT) interpreter will be present for the lightning talks. We do ask you bring your own interpreter for the socialising part of role=drinks.
About 45 people will attend.
| Name | Company | Lightning talk? | |
|---|---|---|---|
| Michiel Bijl | @MichielBijl | The Paciello Group | A picture is worth more than 140 characters |
| Mathilde Pascal | @MathPascal | University of Oxford |
As Léonie says: Play nice with the other children!
If you need more information on how to behave, please have a look at these basic rules.
Don't hesitate to contact our support dinosaur if something does happen! You can call them at +31 6 305 161 92, tweet them at @roledrinks, or send them an e-mail.
Job, Eva, and Michiel somehow convinced people to come to a bar to drink free beer and talk about accessibility—how strange.


The IRA Spectrum Window
This window shows a conventional spectral display, such as one might expect to see on a laboratory RF spectrum analyzer.
The Spectral Maximum Control
This control determines the maximum value to be shown in the display, it is a slider control, which ranges from -10 to 120, and is calibrated in dB.
The Compression Method Control
This selects the method used to compress the SETI spectrum (usually several million bins) into the smaller conventional spectral display. The usual method is Average, but both Max and Median are also available.
The Flatten Control
This control allows you to “flatten” the spectrum, using a function that inverts the roll-off effects of the CIC filtering in the USRP FPGA.
The Create Postscript Control
This control allows you to create a postscript file of the spectral plot. It will pop-up a file browser to allow you to choose a directory and filename for the resulting PostScript file.
The Spectral Span Control
This slider control controls the total span of the spectral display, in dB. Smaller values give higher resolution in the Y axis, while larger values reduce the resolution in the Y axis.
The Notch Filter Length Control
This control determines the length of the notch filter. Individual notches can be set using the RIGHT mouse button at a point on the spectral display.
The Clear Notches Control
This control clears any notch filter points that have been set.
DISMISS
This control causes the IRA Spectral Window to close, but spectral data are still updated while the window is closed.


FILTER JOBS BY :
LOCATION
CREATIVE FIELD
SEARCH BY COMPANY
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance
Anywhere
7 Hours Ago
|
Freelance


--- layout: post title: 'dConstruct 2008: Steven Johnson: The Urban Web' date: 2008-09-05 00:00:00 categories: brighton digital-media interfaces-&-interaction social software-development ---
dConstruct 2008: Steven Johnson: The Urban Web
Wants to start with "a rousing speech about intestinal disease".
London, 1854 - mired in its own filth. A Victorian city with an Elizabethan health structure, creating a smelly environment regularly swept by cholera, particularly in the summer. The smell was seen to be the cause: the miasma theory "all smell was the disease".
A public watering hole in Broad St gets contaminated. August 28, 1854 the first victim dies, and following on 10% of the neighbourhood dies in the next 2 weeks.
The story: John Snow works out that cholera is caused by filthy water and creates a map visualising deaths and their relation to contaminated pumps. Snow was a local physician who saw the concentrated outbreak in his community as an opportunity to identify the source of water and thereby prove his theory. He produced a diagram showing location of deaths plotting on a street map - though this itself was nothing new. But he also plotted on the map the area within which local residents would walk to get water - i.e. showing who would be affected by this pump. This disproved the link between miasma (smell) and disease.
Another significant individual: the Reverend Henry Whitehead (local vicar, 25-26yo) was well known in the neighbourhood as a "connector" figure. The pump was well known for its water quality (!) so Whitehead set out to disprove the theory through interviews with local residents, in the process often uncovering data supporting a link back to the infected pump and identifying individuals who had left the area. Whitehead eventually discovered "patient zero".
Snow & Whitehead has access to archives of open data, created in the previous century by William Far (sp?) and in a standardised format allowing consumers to identify deaths from cholera by geography. The idea behind this was that third parties might do interesting things with this data: Snow & Whitehead's first mashup!
Snow's incredible intellectual skill was the ability to move between levels - individuals up to the water system of all London - and draw conclusions. His map was "a social network of dead people" - those united by their disease.
Cholera never returned to London after 1866.
So, to the geographic web. The initial web kicked off in part because of having a standardised means of locating pages: the URI. Stacks can be built of top of this information only because you know where it is. We're now starting to get standardised geographic formats for data online (e.g. Google/Yahoo mapping APIs).
We have local expertise (knowledgeable sources of local information, spread via self-publishing in blogs), open standards for information, and visualisation/mapping tools.
We should be able to filer queries and provide results by "what people near me are saying". Yet in real life things that are said near to us matter more than things said further awau.
Demos "outside.in GeoToolkit" - to help authors Geotag their content properly, then examine it.
Another product: Radar.
Amongst startups doing location products, there's a disproportionate emphasis on finding restaurants, local businesses, etc. Whilst this is valuable, there's a lot more to geography in everyday life.
Outside.in seems to provide a twitter-like feeling of connection to a location.
Geoweb could provide "eyes on the street" (quotes Jane Jacobs, "The Death and Life of American Cities" - sure I remember Adam Greenfield mentioning this at LIFT or PICNIC last year). These eyes, and the intelligence behind them, are what make cities great.
- snow go ethno
- what geo formats?


|
First you need to install qmail (it's better to place it in /var/qmail), you can download patch for qmail from http://iidea.pl/~paweln/proj/q-p/ (it's a special patch including most common needed stuff and also specially created to support some features of vq). Installing with PostgreSQL module. Install PostgreSQL, create user and database for mail system, if you want to use programs from contrib directory you should specify encoding for table as utf-8, or you'll have to modify source code for that programs. For more details see doc/pgsql directory, especially README file :-) Step-by-step ----------------------------- 1. create group vq, create user vq in group vq. default directory is /var/vq. 2. create databases and tables (see doc/pgsql/README) 3. edit conf/* files, or copy current configuration to conf directory. 4. make 5. ./install 6. make /var/vq/lib searchable by ld (on Linux add this directory to /etc/ld.so.conf, on OpenBSD edit /etc/rc.conf, variable shlib_dirs) 7. that's it folks, you may use vq Problems ----------------------------- There may be problems with gcc 3.x, I've changed sources to compile under this compiler, but I haven't tested it. I'm waiting on your response. |


{% load static %}
Dashboard
Business Coaching
Home
{% if user.is_authenticated %}
Dashboard
Find a Coach
{% endif %}
{% if user.is_authenticated %}
Profile
Logout
{% else %}
Login
Register as Coach
Register as Client
{% endif %}
Dedicated Pages
Calendar
Connections
{% if user.pk == profile.pk %}
{% endif %}
{{ profile.coach.first_name }} {{ profile.coach.last_name }}
{{ profile.coach.area_of_expertise }}
Dedicated Pages
[[ coachee_requests[index].coachee.first_name + ' ' + coachee_requests[index].coachee.last_name ]]
My Calendar
Authorize
Sign Out
Upcoming events this week
Requests
New Client Requests
[[ coachee_requests[index].coachee.first_name + ' ' + coachee_requests[index].coachee.last_name ]]
Accept
Reject
Schedule Meeting
New Meeting
Client Email
Choose a time for your appointment:
Enter Duration (in Minutes)
Schedule Meeting


{% extends "dashboard_base.html" %} {% block navigation %} LogTick Dashboard Manage Time Screen Captures Reports Overview Timesheet Details Current Week Timelog by project Lifetime TimeLog by project Weekly Timesheet Timelogs Administration Registration Page Forgot Password Page Projects New Project New Task Settings Messages 12 New New Messages: David Miller 11:21 AM Hey there! This new version of SB Admin is pretty awesome! These messages clip off when they reach the end of the box so they don't overflow over to the sides! Jane Smith 11:21 AM I was wondering if you could meet for an appointment at 3:00 instead of 4:00. Thanks! John Doe 11:21 AM I've sent the final files over to you for review. When you're able to sign off of them let me know and we can discuss distribution. View all messages Alerts 6 New New Alerts: Status Update 11:21 AM This is an automated server response message. All systems are online. Status Update 11:21 AM This is an automated server response message. All systems are online. Status Update 11:21 AM This is an automated server response message. All systems are online. View all alerts Logout {% endblock navigation %}