src/app/simulation/ltm-graph.ts
Simulation (LTM) graph.
constructor(graph: Graph)
|
||||||
|
Defined in src/app/simulation/ltm-graph.ts:491
|
||||||
|
Parameters :
|
| Protected edges |
edges:
|
Type : LtmEdge[]
|
Default value : []
|
|
Defined in src/app/simulation/ltm-graph.ts:489
|
| Protected nodes |
nodes:
|
Type : LtmNode[]
|
Default value : []
|
|
Defined in src/app/simulation/ltm-graph.ts:487
|
| Protected shortestPaths |
shortestPaths:
|
Type : [][][]
|
Default value : []
|
|
Defined in src/app/simulation/ltm-graph.ts:491
|
| Protected assignmentMatrix |
assignmentMatrix:
|
Type : [][][]
|
Default value : []
|
|
Inherited from
Graph
|
|
Defined in Graph:255
|
| Private drawingOptions |
drawingOptions:
|
Type : literal type
|
Default value : {}
|
|
Inherited from
Graph
|
|
Defined in Graph:262
|
|
Shortest paths drawing options. |
| Protected edges |
edges:
|
Type : Edge[]
|
Default value : []
|
|
Inherited from
Graph
|
|
Defined in Graph:244
|
| Private heap |
heap:
|
Type : Heap
|
|
Inherited from
Graph
|
|
Defined in Graph:257
|
| Protected incidenceMatrix |
incidenceMatrix:
|
Type : [][][]
|
Default value : []
|
|
Inherited from
Graph
|
|
Defined in Graph:253
|
| Protected nodes |
nodes:
|
Type : Node[]
|
Default value : []
|
|
Inherited from
Graph
|
|
Defined in Graph:242
|
| Protected relations |
relations:
|
Type : Relation[]
|
Default value : []
|
|
Inherited from
Graph
|
|
Defined in Graph:246
|
| Protected shortestPaths |
shortestPaths:
|
Type : [][][]
|
Default value : []
|
|
Inherited from
Graph
|
|
Defined in Graph:251
|
|
Paths for each O/D pair [pairs,paths,edges]. |
| Public addEdge | ||||||
addEdge(edge: LtmEdge)
|
||||||
|
Defined in src/app/simulation/ltm-graph.ts:538
|
||||||
|
Parameters :
Returns :
void
|
| Public addOrUpdateNode | ||||||
addOrUpdateNode(node: LtmNode)
|
||||||
|
Defined in src/app/simulation/ltm-graph.ts:520
|
||||||
|
Parameters :
Returns :
void
|
| Public getEdge | ||||||
getEdge(edgeId: number)
|
||||||
|
Defined in src/app/simulation/ltm-graph.ts:534
|
||||||
|
Parameters :
Returns :
LtmEdge
|
| Public getEdges |
getEdges()
|
|
Defined in src/app/simulation/ltm-graph.ts:512
|
|
Returns :
LtmEdge[]
|
| Public getNode | ||||||
getNode(nodeId: number)
|
||||||
|
Defined in src/app/simulation/ltm-graph.ts:516
|
||||||
|
Parameters :
Returns :
LtmNode | undefined
|
| Public getNodes |
getNodes()
|
|
Defined in src/app/simulation/ltm-graph.ts:508
|
|
Returns :
LtmNode[]
|
| Public getOriginNodes |
getOriginNodes()
|
|
Defined in src/app/simulation/ltm-graph.ts:530
|
|
Returns :
LtmNode[]
|
| Public getShortestPaths |
getShortestPaths()
|
|
Defined in src/app/simulation/ltm-graph.ts:542
|
|
Returns :
[][]
|
| Private mapEdge |
mapEdge(edge: LtmEdge, graphEdge: Edge)
|
|
Defined in src/app/simulation/ltm-graph.ts:583
|
|
Returns :
void
|
| Private mapGraph | ||||||
mapGraph(graph: Graph)
|
||||||
|
Defined in src/app/simulation/ltm-graph.ts:546
|
||||||
|
Parameters :
Returns :
void
|
| Private mapNode |
mapNode(node: LtmNode, graphNode: Node)
|
|
Defined in src/app/simulation/ltm-graph.ts:598
|
|
Returns :
void
|
| Public reset |
reset()
|
|
Defined in src/app/simulation/ltm-graph.ts:499
|
|
Returns :
void
|
| Public addEdge | ||||||
addEdge(edge: Edge)
|
||||||
|
Inherited from
Graph
|
||||||
|
Defined in Graph:296
|
||||||
|
Parameters :
Returns :
void
|
| Public addOrUpdateNode | ||||||
addOrUpdateNode(node: Node)
|
||||||
|
Inherited from
Graph
|
||||||
|
Defined in Graph:282
|
||||||
|
Parameters :
Returns :
void
|
| Public calcAssignmentMatrix | ||||||||
calcAssignmentMatrix(odPairs: OdPair[])
|
||||||||
|
Inherited from
Graph
|
||||||||
|
Defined in Graph:406
|
||||||||
|
Calculates the assignment matrix.
Parameters :
Returns :
Observable<any>
|
| Public calcIncidenceMatrix |
calcIncidenceMatrix()
|
|
Inherited from
Graph
|
|
Defined in Graph:378
|
|
Calculates the incidence matrix of paths for O/D pairs.
Returns :
Observable<any>
|
| Public calcMaxflows | ||||||||
calcMaxflows(factor: number)
|
||||||||
|
Inherited from
Graph
|
||||||||
|
Defined in Graph:442
|
||||||||
|
Calculates the max flow for each edge.
Parameters :
Returns :
Observable<any>
|
| Private calcPathCosts | ||||||
calcPathCosts(odPairs: OdPair[])
|
||||||
|
Inherited from
Graph
|
||||||
|
Defined in Graph:636
|
||||||
|
Parameters :
Returns :
[][]
|
| Public calcShortestPaths | ||||||||
calcShortestPaths(odPairs: OdPair[])
|
||||||||
|
Inherited from
Graph
|
||||||||
|
Defined in Graph:337
|
||||||||
|
Calculates the set of minimum paths.
Parameters :
Returns :
Observable<any>
|
| Private calcShortestPathsProbabilities | ||||||||
calcShortestPathsProbabilities(odPairs: OdPair[])
|
||||||||
|
Inherited from
Graph
|
||||||||
|
Defined in Graph:606
|
||||||||
|
Multinomial logit model.
Parameters :
Returns :
[][]
|
| Private drawPaths |
drawPaths()
|
|
Inherited from
Graph
|
|
Defined in Graph:547
|
|
Draws the polyline for each shortest path.
Returns :
void
|
| Private filterPaths | ||||||||
filterPaths(shortestPaths: Path[])
|
||||||||
|
Inherited from
Graph
|
||||||||
|
Defined in Graph:525
|
||||||||
|
Removes the alternative paths that differ only for two links.
Parameters :
Returns :
void
|
| Public findOppositeEdge | ||||||
findOppositeEdge(edge: Edge)
|
||||||
|
Inherited from
Graph
|
||||||
|
Defined in Graph:319
|
||||||
|
Parameters :
Returns :
Edge
|
| Public getAssignmentMatrix |
getAssignmentMatrix()
|
|
Inherited from
Graph
|
|
Defined in Graph:427
|
|
Returns :
[][]
|
| Public getEdge | ||||||
getEdge(edgeId: number)
|
||||||
|
Inherited from
Graph
|
||||||
|
Defined in Graph:292
|
||||||
|
Parameters :
Returns :
Edge
|
| Public getEdges |
getEdges()
|
|
Inherited from
Graph
|
|
Defined in Graph:270
|
|
Returns :
Edge[]
|
| Public getIncidenceMatrix |
getIncidenceMatrix()
|
|
Inherited from
Graph
|
|
Defined in Graph:398
|
|
Returns :
[][]
|
| Public getNode | ||||||
getNode(nodeId: number)
|
||||||
|
Inherited from
Graph
|
||||||
|
Defined in Graph:278
|
||||||
|
Parameters :
Returns :
Node | undefined
|
| Public getNodes |
getNodes()
|
|
Inherited from
Graph
|
|
Defined in Graph:266
|
|
Returns :
Node[]
|
| Public getOdNode | ||||||
getOdNode(label: string)
|
||||||
|
Inherited from
Graph
|
||||||
|
Defined in Graph:325
|
||||||
|
Parameters :
Returns :
Node
|
| Public getOdNodes |
getOdNodes()
|
|
Inherited from
Graph
|
|
Defined in Graph:329
|
|
Returns :
Node[]
|
| Public getPathsEdges |
getPathsEdges()
|
|
Inherited from
Graph
|
|
Defined in Graph:371
|
|
Returns :
Edge[]
|
| Public getPolylines |
getPolylines()
|
|
Inherited from
Graph
|
|
Defined in Graph:434
|
|
Gets shortest paths polylines.
Returns :
[][]
|
| Public getRelations |
getRelations()
|
|
Inherited from
Graph
|
|
Defined in Graph:274
|
|
Returns :
Relation[]
|
| Public getShortestPaths |
getShortestPaths()
|
|
Inherited from
Graph
|
|
Defined in Graph:367
|
|
Returns :
[][]
|
| Public isOneway | ||||||||
isOneway(edgeId: number)
|
||||||||
|
Inherited from
Graph
|
||||||||
|
Defined in Graph:304
|
||||||||
|
Parameters :
Returns :
boolean
|
| Public isRoundabout | ||||||||
isRoundabout(edgeId: number)
|
||||||||
|
Inherited from
Graph
|
||||||||
|
Defined in Graph:313
|
||||||||
|
Parameters :
Returns :
boolean
|
| Private isValidNode |
isValidNode(node: Node, path: Path)
|
|
Inherited from
Graph
|
|
Defined in Graph:511
|
|
Returns :
boolean
|
| Private ksp | ||||||||||||||||||||
ksp(o: Node, d: Node, pathType: string, k: number)
|
||||||||||||||||||||
|
Inherited from
Graph
|
||||||||||||||||||||
|
Defined in Graph:459
|
||||||||||||||||||||
|
Calculates the set of minimum paths between a source and destination node based on the link distance or duration attribute. k Shortest Paths algorithm in the Eppstein version.
Parameters :
Returns :
Path[]
The set of shortest paths |
| Private resetCount |
resetCount()
|
|
Inherited from
Graph
|
|
Defined in Graph:515
|
|
Returns :
void
|
| Private setPathsEdges |
setPathsEdges()
|
|
Inherited from
Graph
|
|
Defined in Graph:584
|
|
Returns :
void
|
| Private walk |
walk(o: Node, d: Node, pathType: string, k: number)
|
|
Inherited from
Graph
|
|
Defined in Graph:474
|
|
Breadth First Search (BFS) algorithm for traversing and searching tree data explores the neighbor nodes first, before moving to the next level neighbors.
Returns :
Path[]
|
import { linear } from 'everpolate';
import * as combine from 'mout/array/combine';
import { Node, Edge, Graph } from "../network/graph";
import { round } from "../utils";
import { uiConfig } from "../ui/ui-config";
/**
* Simulation (LTM) node.
*/
export class LtmNode extends Node {
public incomingEdges: LtmEdge[] = [];
public outgoingEdges: LtmEdge[] = [];
/**
* Origin node.
*/
public origin?: {
/**
* Number of vehicles that enters the network.
*/
sendingFlow: number;
/**
* Traffic demand disaggregated by route.
*/
expectedInflows: number[];
/**
* Traffic demand.
*/
expectedInflow: number;
/**
* Starting time of each route.
*/
startingTimes: number[];
};
/**
* Destination node.
*/
public destination?: {
/**
* Number of vehicles that leaves the network.
*/
receivingFlow: number;
/**
* Expected vehicles.
*/
expectedOutFlow: number;
};
/**
* The amount of vehicles that are transferred from incoming links to outgoing links disaggregated by route.
*/
public transitionFlows: any[] = [];
public reset(): void {
this.origin = null;
this.destination = null;
this.transitionFlows = [];
}
/**
* Calculates disaggregated transition flows of the node.
* @param timePeriods The cumulated time period
* @param timeInterval The time interval
* @param paths Existing paths
*/
public calcTransitionFlows(timePeriods: number[], timeInterval: number, paths: any[]): void {
for (let i = 0; i < paths.length; i++) {
this.transitionFlows[i] = {};
for (const incomingEdge of this.incomingEdges) {
// To destination.
if (this.destination) {
if (this.toDestination(i, incomingEdge, paths)) {
if (!this.transitionFlows[i][incomingEdge.label]) { this.transitionFlows[i][incomingEdge.label] = {}; }
this.transitionFlows[i][incomingEdge.label][this.label] =
this.calcOutflow(i, incomingEdge);
}
}
// Link to link.
for (const outgoingEdge of this.outgoingEdges) {
if (this.linkToLink(i, incomingEdge, outgoingEdge, paths)) {
if (!this.transitionFlows[i][incomingEdge.label]) { this.transitionFlows[i][incomingEdge.label] = {}; }
this.transitionFlows[i][incomingEdge.label][outgoingEdge.label] =
this.calcTransitionFlow(i, incomingEdge, outgoingEdge, paths);
}
}
}
// From origin.
if (this.origin) {
for (const outgoingEdge of this.outgoingEdges) {
if (this.fromOrigin(i, outgoingEdge, paths)) {
if (!this.transitionFlows[i][this.label]) { this.transitionFlows[i][this.label] = {}; }
this.transitionFlows[i][this.label][outgoingEdge.label] =
this.calcInflow(i, outgoingEdge, timePeriods, timeInterval);
}
}
}
}
}
/**
* Updates disaggregated and aggregated cumulative vehicles number.
* @param paths Existing paths
*/
public updateCumulativeFlows(paths: any[]): void {
let transitionFlow: number;
// Downstream.
for (const incomingEdge of this.incomingEdges) {
// Disaggregated.
transitionFlow = 0;
for (let i = 0; i < paths.length; i++) {
let disaggregatedTransitionFlow = 0;
if (this.destination) {
if (this.transitionFlows[i][incomingEdge.label] && this.transitionFlows[i][incomingEdge.label][this.label]) {
disaggregatedTransitionFlow = this.transitionFlows[i][incomingEdge.label][this.label];
// Updates the number of vechicles that leaves the network.
this.destination.receivingFlow += disaggregatedTransitionFlow;
}
}
for (const outgoingEdge of this.outgoingEdges) {
if (this.transitionFlows[i][incomingEdge.label] && this.transitionFlows[i][incomingEdge.label][outgoingEdge.label]) {
disaggregatedTransitionFlow = this.transitionFlows[i][incomingEdge.label][outgoingEdge.label];
}
}
incomingEdge.updateDownstream(disaggregatedTransitionFlow, incomingEdge.downstreams[i]);
transitionFlow += disaggregatedTransitionFlow;
}
// Aggregated.
incomingEdge.updateDownstream(transitionFlow, incomingEdge.downstream);
}
// Upstream.
for (const outgoingEdge of this.outgoingEdges) {
// Disaggregated.
transitionFlow = 0;
for (let i = 0; i < paths.length; i++) {
let disaggregatedTransitionFlow = 0;
if (this.origin) {
if (this.transitionFlows[i][this.label] && this.transitionFlows[i][this.label][outgoingEdge.label]) {
disaggregatedTransitionFlow = this.transitionFlows[i][this.label][outgoingEdge.label];
// Updates the number of vechicles that enters the network.
this.origin.sendingFlow += disaggregatedTransitionFlow;
}
}
for (const incomingEdge of this.incomingEdges) {
if (this.transitionFlows[i][incomingEdge.label] && this.transitionFlows[i][incomingEdge.label][outgoingEdge.label]) {
disaggregatedTransitionFlow = this.transitionFlows[i][incomingEdge.label][outgoingEdge.label];
}
}
outgoingEdge.updateUpstream(disaggregatedTransitionFlow, outgoingEdge.upstreams[i]);
transitionFlow += disaggregatedTransitionFlow;
}
// Aggregated.
outgoingEdge.updateUpstream(transitionFlow, outgoingEdge.upstream);
}
}
/**
* Calculates transition flow from link to link.
*/
private calcTransitionFlow(index: number, incomingEdge: LtmEdge, outgoingEdge: LtmEdge, paths: any[]): number {
let sendingFlow = 0;
for (const edge of this.incomingEdges) {
// Links should exist on the route.
if (this.linksOnPaths(edge, outgoingEdge, paths)) {
sendingFlow += edge.sendingFlow;
}
}
const receivingFlows: number[] = [];
for (const edge of this.outgoingEdges) {
// Links should exist on the route.
if (this.linksOnPaths(incomingEdge, edge, paths)) {
// The outgoing link should have a receiving flow greater than 0.
if (edge.receivingFlow > 0 || (edge.receivingFlow == 0 && edge.edgeId == outgoingEdge.edgeId)) {
receivingFlows.push(this.calcReceivingFlow(edge.receivingFlow, incomingEdge.sendingFlows[index], sendingFlow));
}
}
}
let receivingFlow = 0;
if (receivingFlows.length > 0) {
receivingFlow = Math.min(...receivingFlows);
}
return Math.min(
receivingFlow,
incomingEdge.sendingFlows[index]
);
}
private calcReceivingFlow(receivingFlow: number, inflow: number, sendingFlow: number): number {
const flow = sendingFlow > 0 ? receivingFlow * inflow / sendingFlow : 0;
if (flow <= 0) {
return 0;
} else if (flow > 0 && flow <= 1) {
return 1;
} else {
return round(flow);
}
}
/**
* Calculates outflow to destination node.
*/
private calcOutflow(index: number, incomingEdge: LtmEdge): number {
return incomingEdge.sendingFlows[index];
}
/**
* Calculates inflow from origin node.
*/
private calcInflow(index: number, outgoingEdge: LtmEdge, timePeriods: number[], timeInterval: number): number {
if (timePeriods[timePeriods.length - 1] + timeInterval > this.origin.startingTimes[index]) {
return Math.min(
this.origin.expectedInflows[index] -
outgoingEdge.upstreams[index][outgoingEdge.upstreams[index].length - 1],
this.calcReceivingFlow(outgoingEdge.receivingFlow, this.origin.expectedInflows[index], this.origin.expectedInflow)
);
}
return 0;
}
private linkToLink(index: number, incomingEdge: LtmEdge, outgoingEdge: LtmEdge, paths: any[]): boolean {
return paths[index][incomingEdge.label] == outgoingEdge.label;
}
private toDestination(index: number, incomingEdge: LtmEdge, paths: any[]): boolean {
return paths[index][incomingEdge.label] == this.label;
}
private fromOrigin(index: number, outgoingEdge: LtmEdge, paths: any[]): boolean {
return paths[index][this.label] == outgoingEdge.label;
}
private linksOnPaths(incomingEdge: LtmEdge, outgoingEdge: LtmEdge, paths: any[]): boolean {
let exist = false;
for (let i = 0; i < paths.length; i++) {
if (this.linkToLink(i, incomingEdge, outgoingEdge, paths)) {
exist = true;
break;
}
}
return exist;
}
}
/**
* Simulation (LTM) edge.
*/
export class LtmEdge extends Edge {
public origin: LtmNode;
public destination: LtmNode;
/**
* Max amount of vehicles that could leave the downstream end during time interval disaggregated by route.
*/
public sendingFlows: number[] = [];
/**
* Max amount of vehicles that could leave the downstream end during time interval.
*/
public sendingFlow: number;
/**
* Max amount of vehicles that could enter the upstream end during time interval.
*/
public receivingFlow: number;
/**
* The cumulative vehicles number at the upstream link end disaggregated by route.
*/
public upstreams: number[][] = [];
/**
* The cumulative vehicles number at the upstream link end.
*/
public upstream: number[] = [];
/**
* The cumulative vehicles number at the downstream link end disaggregated by route.
*/
public downstreams: number[][] = [];
/**
* The cumulative vehicles number at the downstream link end.
*/
public downstream: number[] = [];
/**
* The vehicles number of the link.
*/
public trafficVolume: number = 0;
/**
* Count of vehicles crossing the link during the simulation.
*/
public trafficCount: number = 0;
/**
* Count of how many times the link reaches a level of moderate traffic.
*/
public moderateTrafficCount: number = 0;
/**
* Count of how many times the link reaches a level of heavy traffic.
*/
public heavyTrafficCount: number = 0;
/**
* MOE: travel time in seconds or 'N/A'.
*/
public travelTime: number | string;
/**
* MOE: delay is the difference between the travel time and the free flow travel time.
*/
public delay: number | string;
/**
* MOE: stop time in seconds.
*/
public stops: number = 0;
public reset(): void {
this.sendingFlows = [];
this.upstreams = [];
this.upstream = [];
this.downstreams = [];
this.downstream = [];
this.trafficVolume = 0;
this.trafficCount = 0;
this.moderateTrafficCount = 0;
this.heavyTrafficCount = 0;
this.travelTime = 0;
this.delay = 0;
this.stops = 0;
this.draw(uiConfig.links.baseColor, 10, false);
}
/**
* Calculates disaggregated and aggregated sending flows of the incoming link.
* @param timePeriods The cumulated time period
* @param timeInterval The time interval
* @param paths Existing paths
*/
public calcSendingFlows(timePeriods: number[], timeInterval: number, paths: any[]): void {
const time = timePeriods[timePeriods.length - 1] + timeInterval - this.duration;
const capacity = this.getCapacity(timeInterval);
let interpolation: number[];
// Disaggregated.
for (let i = 0; i < paths.length; i++) {
interpolation = timePeriods.length > 1 ? linear([time], timePeriods, this.upstreams[i]) : [0];
this.sendingFlows[i] = this.calcSendingFlow(interpolation, capacity, this.upstreams[i], this.downstreams[i]);
}
// Aggregated.
interpolation = timePeriods.length > 1 ? linear([time], timePeriods, this.upstream) : [0];
this.sendingFlow = this.calcSendingFlow(interpolation, capacity, this.upstream, this.downstream);
}
/**
* Calculates the receiving flow of the outgoing link.
* @param timePeriods The cumulated time period
* @param timeInterval The time interval
*/
public calcReceivingFlow(timePeriods: number[], timeInterval: number): void {
const time = timePeriods[timePeriods.length - 1] + timeInterval + this.duration;
const capacity = this.getCapacity(timeInterval);
const maxCapacity = this.getCapacity(this.duration); // kjam * distance
const interpolation = timePeriods.length > 1 ? linear([time], timePeriods, this.downstream) : [0];
const receivingFlow = Math.min(
(interpolation[0] > 0 ? interpolation[0] : 0) +
maxCapacity -
this.upstream[this.upstream.length - 1],
capacity
);
if (receivingFlow <= 0) {
this.receivingFlow = 0;
} else if (receivingFlow > 0 && receivingFlow <= 1) {
this.receivingFlow = 1;
} else {
this.receivingFlow = round(receivingFlow);
}
}
/**
* Updates disaggregated or aggregated cumulative vehicles number at the upstream link end.
* @param transitionFlow The transition flow from incoming link
* @param upstream The upstream
*/
public updateUpstream(transitionFlow: number, upstream: number[]): void {
upstream.push(upstream[upstream.length - 1] + transitionFlow);
}
/**
* Updates disaggregated or aggregate cumulative vehicles number at the downstream link end.
* @param transitionFlow The transition flow to outgoing link
* @param downstream The downstream
*/
public updateDownstream(transitionFlow: number, downstream: number[]): void {
downstream.push(downstream[downstream.length - 1] + transitionFlow);
}
/**
* Updates the traffic volume as the difference between the cumulative flows.
*/
public updateTrafficVolume(): void {
this.trafficVolume = this.upstream[this.upstream.length - 1] - this.downstream[this.downstream.length - 1];
}
/**
* Updates traffic counts.
*/
public updateTrafficCounts(): void {
// Traffic count is the cumulative flow at the upstream link end.
this.trafficCount = this.upstream[this.upstream.length - 1];
// Heavy traffic.
if (this.trafficVolume > this.getCapacity(this.duration) * uiConfig.heavyTraffic) {
this.heavyTrafficCount++;
this.draw(uiConfig.links.heavyTrafficColor, 13);
// Moderate traffic.
} else if (this.trafficVolume > this.getCapacity(this.duration) * uiConfig.moderateTraffic) {
this.moderateTrafficCount++;
this.draw(uiConfig.links.moderateTrafficColor, 12);
// No traffic.
} else if (this.trafficVolume > 0 || this.trafficCount > 0) {
this.draw(uiConfig.links.noTrafficColor, 11);
}
}
/**
* Updates Measures of Effectiveness:
* - velocity
* - travel time
* - delay
* - stops
*/
public updateMoes(timeInterval: number): void {
// Velocity.
this.velocity = round(this.freeFlowVelocity - (this.trafficVolume * this.freeFlowVelocity / (this.getKjam() * this.distance)), 2);
if (this.velocity > 0) {
// Travel time.
this.travelTime = round(this.distance / this.velocity);
// Delay.
this.delay = this.travelTime - this.duration;
} else {
// Travel time.
this.travelTime = 'N/A';
// Delay.
this.delay = 'N/A';
// Stops.
this.stops += timeInterval;
}
}
private calcSendingFlow(interpolation: number[], capacity: number, upstream: number[], downstream: number[]): number {
const trafficVolume = upstream[upstream.length - 1] - downstream[downstream.length - 1];
let sendingFlow = 0;
// The sending flow should only be calculated in the presence of vehicles on the link.
if (trafficVolume > 0) {
sendingFlow = Math.min(
(interpolation[0] > 0 ? interpolation[0] : 0) -
downstream[downstream.length - 1],
capacity
);
}
if (sendingFlow <= 0) {
return 0;
} else if (sendingFlow > 0 && sendingFlow <= 1) {
return 1;
} else {
return round(sendingFlow);
}
}
}
/**
* Simulation (LTM) graph.
*/
export class LtmGraph extends Graph {
protected nodes: LtmNode[] = [];
protected edges: LtmEdge[] = [];
protected shortestPaths: LtmEdge[][][] = [];
constructor(graph: Graph) {
super();
this.mapGraph(graph);
}
public reset(): void {
for (const node of this.nodes) {
node.reset();
}
for (const edge of this.edges) {
edge.reset();
}
}
public getNodes(): LtmNode[] {
return this.nodes;
}
public getEdges(): LtmEdge[] {
return this.edges;
}
public getNode(nodeId: number): LtmNode | undefined {
return this.nodes.find((node: LtmNode) => node.nodeId == nodeId);
}
public addOrUpdateNode(node: LtmNode): void {
const existingNode = this.getNode(node.nodeId);
if (existingNode) {
existingNode.incomingEdges = combine(existingNode.incomingEdges, node.incomingEdges);
existingNode.outgoingEdges = combine(existingNode.outgoingEdges, node.outgoingEdges);
} else {
this.nodes.push(node);
}
}
public getOriginNodes(): LtmNode[] {
return this.nodes.filter((node: LtmNode) => node.origin);
}
public getEdge(edgeId: number): LtmEdge {
return this.edges.find((edge: LtmEdge) => edge.edgeId == edgeId);
}
public addEdge(edge: LtmEdge): void {
this.edges.push(edge);
}
public getShortestPaths(): LtmEdge[][][] {
return this.shortestPaths;
}
private mapGraph(graph: Graph): void {
// Edges and nodes.
const edges = graph.getPathsEdges();
for (let i = 0; i < edges.length; i++) {
const origin = this.getNode(edges[i].origin.nodeId) || new LtmNode(edges[i].origin.nodeId);
const destination = this.getNode(edges[i].destination.nodeId) || new LtmNode(edges[i].destination.nodeId);
const edge = new LtmEdge(edges[i].edgeId);
edge.origin = origin;
edge.destination = destination;
this.mapEdge(edge, edges[i]);
origin.outgoingEdges.push(edge);
destination.incomingEdges.push(edge);
this.mapNode(origin, edges[i].origin);
this.mapNode(destination, edges[i].destination);
this.addOrUpdateNode(origin);
this.addOrUpdateNode(destination);
this.addEdge(edge);
}
// Relations.
this.relations = graph.getRelations();
// Shortest paths.
const shortestPaths = graph.getShortestPaths();
for (let z = 0; z < shortestPaths.length; z++) {
this.shortestPaths[z] = [];
for (let n = 0; n < shortestPaths[z].length; n++) {
this.shortestPaths[z][n] = [];
for (let m = 0; m < shortestPaths[z][n].length; m++) {
const edge = this.getEdge(shortestPaths[z][n][m].edgeId);
this.shortestPaths[z][n][m] = edge;
}
}
}
// Matrices.
this.incidenceMatrix = graph.getIncidenceMatrix();
this.assignmentMatrix = graph.getAssignmentMatrix();
}
private mapEdge(edge: LtmEdge, graphEdge: Edge): void {
edge.label = graphEdge.label;
edge.tags = graphEdge.tags;
edge.distance = graphEdge.distance;
edge.duration = graphEdge.duration;
edge.durationInTraffic = graphEdge.durationInTraffic;
edge.freeFlowVelocity = graphEdge.freeFlowVelocity;
edge.velocity = graphEdge.velocity;
edge.density = graphEdge.density;
edge.flow = graphEdge.flow;
edge.linkFlow = graphEdge.linkFlow;
edge.maxFlow = graphEdge.maxFlow;
edge.drawingOptions = graphEdge.drawingOptions;
}
private mapNode(node: LtmNode, graphNode: Node): void {
node.label = graphNode.label;
node.lat = graphNode.lat;
node.lon = graphNode.lon;
node.tags = graphNode.tags;
node.drawingOptions = graphNode.drawingOptions;
node.count = graphNode.count;
}
}


P-Spline Baselearner. More...
#include <baselearner.h>
Public Member Functions | |
| BaselearnerPSpline (data::Data *, const std::string &, const unsigned int &, const unsigned int &, const double &, const unsigned int &, const bool &) | |
Default constructor of BaselearnerPSpline class. More... | |
| Baselearner * | clone () |
| Clean copy of baselearner. More... | |
| arma::mat | instantiateData (const arma::mat &) |
| Instatiate data matrix (design matrix) More... | |
| void | train (const arma::vec &) |
| Trianing of a baselearner. More... | |
| arma::mat | predict () |
| Predict on training data. More... | |
| arma::mat | predict (data::Data *) |
| Predict on newdata. More... | |
| ~BaselearnerPSpline () | |
| Destructor. More... | |
| Public Member Functions inherited from blearner::Baselearner | |
| arma::mat | getParameter () const |
| void | copyMembers (const arma::mat &, const std::string &, data::Data *) |
| void | setData (data::Data *) |
| std::string | getDataIdentifier () const |
| void | setIdentifier (const std::string &) |
| std::string | getIdentifier () const |
| void | setBaselearnerType (const std::string &) |
| std::string | getBaselearnerType () const |
| virtual | ~Baselearner () |
Private Attributes | |
| unsigned int | degree |
| Degree of polynomial functions as base models. More... | |
| unsigned int | n_knots |
| Number of inner knots. More... | |
| double | penalty |
| Penalty parameter. More... | |
| unsigned int | differences |
| Differences of penalty matrix. More... | |
| const bool | use_sparse_matrices |
| Flag if sparse matrices should be used: More... | |
Additional Inherited Members | |
| Protected Attributes inherited from blearner::Baselearner | |
| arma::mat | parameter |
| std::string | blearner_identifier |
| std::string | blearner_type |
| data::Data * | data_ptr |
P-Spline Baselearner.
This class implements the P-Spline baselearners. We have used de Boors algorithm (from the Nurbs Book) to create the basis. The penalty parameter can be specified directly or by using the degrees of freedom. If you are using the degrees of freedom insteat of the penalty parameter, then this is transformed to a penalty parameter using the Demmler-Reinsch Orthogonalization.
Please note, that this baselearner is just the dummy object. The most functionality is done while creating the data target which contains the most object which are used here.
| blearner::BaselearnerPSpline::BaselearnerPSpline | ( | data::Data * | data, |
| const std::string & | identifier, | ||
| const unsigned int & | degree, | ||
| const unsigned int & | n_knots, | ||
| const double & | penalty, | ||
| const unsigned int & | differences, | ||
| const bool & | use_sparse_matrices | ||
| ) |
Default constructor of BaselearnerPSpline
class.
Constructor of BaselearnerPSpline
class.
This constructor sets the members such as n_knots etc. The more computational complex data are stored within the data object which should be initialized first (e.g. in the factory or otherwise).
One note about the used knots. The number of inner knots is specified by n_knots
. These inner knots are then wrapped by the minimal and maximal value of the given data. For instance we have a feature
\[ x = (1, 2, \dots, 2.5, 6) \]
and we want to have 3 knots, then the inner knots with boundaries are:
\[ U = (1.00, 2.25, 3.50, 4.75, 6.00) \]
To get a full base these knots are wrapped by degree
( \(p\)) numbers on either side. If we choose degree = 2
then we have \(n_\mathrm{knots} + 2(p + 1) = 3 + 2(2 + 1) 9\) final knots:
\[ U = (-1.50, -0.25, 1.00, 2.25, 3.50, 4.75, 6.00, 7.25, 8.50) \]
Finally we get a \(9 - (p + 1)\) splines for which we can calculate the base.
| data | data::Data* Target data used for training etc. |
| identifier | std::string Identifier for one specific baselearner |
| degree | unsigned int Polynomial degree of the splines |
| n_knots | unsigned int Number of inner knots used |
| penalty | double Regularization parameter penalty = 0 yields b splines while a bigger penalty forces the splines into a global polynomial form. |
| differences | unsigned int Number of differences used for the penalty matrix. |
| blearner::BaselearnerPSpline::~BaselearnerPSpline | ( | ) |
Destructor.
|
virtual |
Clean copy of baselearner.
Baselearner*
An exact copy of the actual baselearner. Implements blearner::Baselearner.
|
virtual |
Instatiate data matrix (design matrix)
Instantiate data matrix (design matrix)
This function is ment to create the design matrix which is then stored within the data object. This should be done just once and then reused all the time.
Note that this function sets the data_mat
object of the data object!
| newdata | arma::mat Input data which is transformed to the design matrix |
arma::mat
of transformed data Implements blearner::Baselearner.
|
virtual |
|
virtual |
Predict on newdata.
| newdata | data::Data* new source data object |
arma::mat
of predicted values Implements blearner::Baselearner.
|
virtual |
Trianing of a baselearner.
Training of a baselearner.
This function sets the parameter
member of the parent class Baselearner
.
| response | arma::vec Response variable of the training. |
Implements blearner::Baselearner.
|
private |
Degree of polynomial functions as base models.
|
private |
Differences of penalty matrix.
|
private |
Number of inner knots.
|
private |
Penalty parameter.
|
private |
Flag if sparse matrices should be used:


Change Log
4.0.8 (2018/09/05)
- Non ASCII UTF8 characters are correctly received now, fixes: #46. Thanks Aleksandar Ivanov.
4.0.7 (2018/07/12)
- Fix - an issue in reconnection in some cases.
4.0.6 (2018/05/26)
4.0.5
- Ignore - incomplete release
4.0.4 (2018/05/22)
- GWT Compatibility, fixes #38
4.0.3 (2018/05/09)
- Add to Bower, fixes #26
- Several documentation cleanup, fixes #27
- Updated typescript definitions, Thanks Jimi Charalampidis. See: #33
- I need to be more disciplined. Caught up on ChangeLog updates :)
4.0.2 (2018/02/23)
- Dockerfile for RabbitMQ. Thanks Dillon Sellars. See: #22
- Add closeEventCallback to expose the websocket CloseEvent. Thanks Dillon Sellars. See: #23
- Cleanup disconnect code, fixes #21
4.0.1 (2018/01/29)
- Fixes #20
4.0.0 (2017/11/09)
- NodeJS has been upgraded to first class citizen. Dropped legacy support.
- Major version change as this version is not backward compatible.
3.1.2 (2017/11/04)
- Header value escaping as per STOMP 1.2 standard.
3.1.0 (2017/07/05)
- Updated tests to QUint latest version. Now using same set of tests for NodeJS environment.
- Pruned files and folders no longer needed.
- Updated dependencies.
- Updated build scripts.
- Refactored entire documentation.
- Enabled Travis CI (it runs all test cases using NodeJS).
- Documentation is hosted at GitHub pages.
- Updated TypeScript type definitions.
2.5.1 (2017/03/28)
- Added typescript definitions. Thanks Jimi Charalampidis (https://github.com/jimic)
- Published on npmjs.com.
2.5.0 (2017/02/15)
- Support for auto reconnect
- Minor documentation changes
2.4.9 (2016/04/01)
STOMP 1.2 and RabbitMQ support
- deletion of durable subscriptions
- STOMP 1.2 ack/nack headers
- graceful shutdown
API change
the
unsubscribe()
method returned bysubscribe()
now takes an optionalheaders
argument which can be used to pass headers likedurable:true
andauto-delete:false
required by RabbitMQ to delete durable subscriptionsfor STOMP 1.2,
ack()
andnack()
methods send anid
header rather than amessage-id
header to match the incoming MESSAGE frame.although the
disconnectCallback
is still called immediately after transmitting a DISCONNECT frame, the websocket is not closed by the client until a RECEIPT is received. Note that due to server-side behaviour with respect to connection lingering the RECEIPT may never be received and the socket will be closed by the server.2.0 (2012/11/29)
STOMP 1.1 support
- heart-beat
- nack
- content-length
API change
the
errorCallback
passed to theconnect()
method is no longer called when the client is properly disconnected by callingdisconnect()
.ack() method takes 3 parameters:
messageID
&subscription
are MANDATORY.headers
is OPTIONAL
the
client
object has aheartbeat
field which can be used to configure heart-beating by changing itsincoming
andoutgoing
integer fields (default value for both is 10000ms):client.heartbeat.outgoing = 20000 // client will send heartbeats every 20000ms client.heartbeat.incoming = 0 // client does not want to receive heartbeats
// from the server
Minified version
In addition to the regular stomp.js
file, the library is also available in a minified version stomp.min.js
Annotated source
The source is now documented :)


{% extends "instructions/Page.html" %}
{% load staticfiles otree %}
{% block title %}
INSTRUCTIONS - PART 1
MULTIPLIERS
{% endblock %}
{% block content %}
In each round, each participant is assigned a number, which we will call the participant's multiplier.
In each round, to determine a participant’s multiplier the computer will randomly select a number between 2 and 10.
Each value between 2 and 10 is equally likely to be selected.
Note also that the multiplier of each participant is independent from the multipliers of others.
Each player knows his or her multiplier. Players have no information about the multipliers of others.


Field
public struct Field
A Field
represent one specific input (usually a text field) that the user need to enter in order to add a credential.
-
The current text input of the field. Update this to reflect the user’s input.
Declaration
Swift
public var text: String
-
The name of the field.
Declaration
Swift
public let name: String
-
The validation rules that determines whether the
text
property is valid.Declaration
Swift
public let validationRules: ValidationRules
-
The attributes of the field.
You can use the attributes to set up a text field properly. They contain properties like input type, placeholder and description.
Declaration
Swift
public let attributes: Attributes
-
Declaration
Swift
public struct ValidationRules
-
Attributes to apply to a UI element that will represent a field.
See moreDeclaration
Swift
public struct Attributes
-
Describes a field validation error.
See moreDeclaration
Swift
public enum ValidationError : Error, LocalizedError
-
Returns a Boolean value indicating whether the field is valid.
To check why
text
wasn’t valid iffalse
, callvalidate()
and check the thrown error for validation failure reason.Declaration
Swift
public var isValid: Bool { get }
Return Value
true
if the field pass the validation rules; otherwise,false
. -
Validate field.
Use this method to validate the current
text
value of the field or to catch the value if invalid.Declaration
Swift
public func validate() throws


Art collection, an accumulation of works of art by a private individual or a public institution.
Art collecting has a long history, and most of the world’s art museums grew out of great
private collections formed by royalty,the aristocracy, or the wealthy.
Vivid has given workshops on traditional Nigerian textiles to audiences in the US and Europe.


{% extends 'base.html' %} {% block title %}Home{% endblock %} {% block content %}
We do not want to mislead you. We did not design this program for everyone. In fact, it takes a special type of person to persist through our program. And on top of that,we do not offer your money back ... ever!. So please think very carefully before commiting to join the program. Here are some reasons why our approach may not suit you:


Secret Easter Egg!
Ok, maybe not that secret
Your browser does not support the HTML5 canvas tag
PLAY AGAIN


Structures¶
This part describe the structures (BipStruct
) and structure members
(BStructMember
). This two objects inherit from BipRefElt
which make them able to be referenced by xref and possible to recuperate using
the GetElt()
function.
Those classes represent
the element view in the Struct
tab. of IDA and are different from the
BipType
which is used for referencing the type of some elements in
IDA, however they are obviously linked.
Except xrefs the most common way to get a structure is using the
get()
class method which expect its name. For creating one
the create()
class method is available. Once a struct has
been recuperated it is possible to access the members as a dict by using
their name or their offset (this is not a list and so it is the offset of
the member which is expected not its index).
BipStruct API¶
-
class
bip.base.
BipStruct
(st)¶ Class for representing and manipulating a structure in IDA. Static functions
create()
andget()
allow to easilly get an instance of those object.Todo
get/set alignement
Todo
support deletion of members
Todo
allow to iterate on all structure and other stuff like that
Todo
test
-
__init__
(st)¶ Constructor for a
BipStruct
object. There is few reason to directly use this constructor, see functionsget()
orcreate()
.Parameters: st – A structure struc_t
from IDA such as return byget_struc
or an sid (int) representing a structure.Raises: ValueError – If an integer is provided and is not a valid sid, or if an incorrect type is provided as st
.
-
__init__
(st) Constructor for a
BipStruct
object. There is few reason to directly use this constructor, see functionsget()
orcreate()
.Parameters: st – A structure struc_t
from IDA such as return byget_struc
or an sid (int) representing a structure.Raises: ValueError – If an integer is provided and is not a valid sid, or if an incorrect type is provided as st
.
-
_struct
= None¶ Internal
struct_t
object from IDA.
-
_sid
¶ Property which return the sid for this
BipStruct
object. The sid is the struct id number (tid_t
) from IDA and there is no reason it should be used except for interfacing with the standard API from IDA.Returns: An int corresponding to the sid.
-
classmethod
_is_this_elt
(idelt)¶ Return true if
idelt
correspond to a sid.
-
name
¶ Property which return the name (as a string) of this structure.
-
size
¶ Property returning the size of the structure as an integer.
-
__str__
() <==> str(x)¶
-
comment
¶ Property which return the comment associated with a structure. For repeatable comment see
rcomment()
Property for knowing if a struct is fully shown in the gui.
Returns: True if the structure is “collapsed”, False if it is shown.
-
members
¶ Property which return a list of
BStructMember
objects representing the members of this structure.Return type: A list of BStructMember
object.
-
members_iter
¶ Property returning an iterable of
BStructMember
representing the different members of this struct. This is similar toBipStruct.members()
.Todo
maybe delete this ? I am worried because of the get_member property which may create problem if the number of members change during the iteration.
Return type: Iterable of BStructMember
object.
-
member_at
(off)¶ Method which return the member of this
BipStruct
at the offset provided in argument. This will return the correct member even if the offset is not aligned.Parameters: off (int) – The offset of the member to get. Raises: IndexError – If the member was not found (offset bigger than the struct). Returns: An BStructMember
object corresponding to the member.
-
member_by_name
(name)¶ Method which return the member of this
BipStruct
from its name.Parameters: name (str) – The name of the member to get. Raises: KeyError – If the member was not found. Returns: An BStructMember
object corresponding to the member.
-
__getitem__
(key)¶ Getitem method which allow access to the members of the struct.
Parameters: key – If key is a string it will search the member by name, if it is a integer it will search the member by offset.
Raises: - ValueError – If the member was not found.
- TypeError – If
key
is not an integer or a string.
Returns: An
BStructMember
object corresponding to the member.
-
__iter__
()¶ Iter method for accessing the members as a list. This is equivalent to
members_iter()
.Note
By default python will try to use the __getitem__ method which is not what we want because the __getitem__ method takes offset.
Returns: An iterator on the BStructMember
object of this struct.
-
add
(name, size, comment=None, offset=None)¶ Add a new member to the structure (at the end by default).
Parameters: - name (str) – The name of the field to add. If None or an empty
string the default name used by IDA will be used (
field_
). - size (int) – The size of the field to add in bytes, can be 1, 2, 4 or 8.
- comment (str) – Optional parameter which allow to add a comment associated with the new member.
- offset (int) – The offset at which to add the new member, by default (None) it will be added at the end.
Raises: - TypeError – If one argument is not of the correct type or with the correct value.
- ValueError – If an error occur when adding the member.
Returns: An
BStructMember
object corresponding to the member added.- name (str) – The name of the field to add. If None or an empty
string the default name used by IDA will be used (
-
add_varsize
(name, comment=None)¶ Add a variable size new member at the end of the structure.
Parameters: - name (str) – The name of the field to add.
- comment (str) – Optional parameter which allow to add a comment associated with the new member.
Raises: ValueError – If an error occur when adding the member.
Returns: An
BStructMember
object corresponding to the member added.
-
fill
(size, prefix='field_')¶ Add new members to the structure until it reach
size
. Thie function add field the size of a pointer at the end of the structure.Parameters: - size (int) – The size in bytes wanted for the structure.
- prefix (str) – Prefix for the name of the structure member.
Default is
field_
.
-
classmethod
get
(name)¶ Class method allowing to get a
BipStruct
object from the name of an existing structure.Todo
support providing a sid directly instead of a name ?
Todo
support typedef on struct
Parameters: name (str) – The name of the structure to get. Raises: ValueError – if the structure name
does not exist.Returns: A BipStruct
object corresponding to the structure identified by the name provided.
-
classmethod
create
(name)¶ Class method allowing to create a new empty struct.
Parameters: name (str) – The name of the structure to create.
Raises: - ValueError – If the structure
name
already exist. - BipError – If it was not possible to create the structure.
Return type: A
Struct
object.- ValueError – If the structure
-
static
delete
(name)¶ Static method allowing to delete a struct by its name.
Parameters: name (str) – The name of the structure to delete.
Raises: - ValueError – If the structure
name
does not exist. - RuntimeError – If it was not possible to delete the strucutre.
- ValueError – If the structure
-
BStructMember API¶
-
class
bip.base.
BStructMember
(member, istruct=None)¶ Class for representing and manipulating a member of an
BipStruct
structure.Todo
flags
Todo
implement comparaison with other members (mid) and test for presence in a struct.
-
__init__
(member, istruct=None)¶ Constructor for a
BStructMember
object. There is no reason this constructor should be used.There is few reason to use directly this constructor except for interfacing directly with IDA.
Parameters: - member – A
member_t
object from ida corresponding to this member or a member id (int, long) corresponding to this member. - istruct – A
BipStruct
object corresponding to the structure from which member this member is part of. If it isNone
the structure will found dynamically.
Raises: ValueError – If the parameter is incorrect.
- member – A
-
__init__
(member, istruct=None) Constructor for a
BStructMember
object. There is no reason this constructor should be used.There is few reason to use directly this constructor except for interfacing directly with IDA.
Parameters: - member – A
member_t
object from ida corresponding to this member or a member id (int, long) corresponding to this member. - istruct – A
BipStruct
object corresponding to the structure from which member this member is part of. If it isNone
the structure will found dynamically.
Raises: ValueError – If the parameter is incorrect.
- member – A
-
_member
= None¶ member_t
object from ida corresponding to this member.
-
classmethod
_is_this_elt
(idelt)¶ Return true if
idelt
correspond to a mid.
-
_mid
¶ Property which return the member id corresponding to this object. This is used internally by IDA and there should be few reason to use this except for interfacing with IDA native interface.
-
name
¶ Property which return the name of this member.
-
fullname
¶ Property which return the full name of this member. The fullname correspond to the struct name follow by the name of this member seperated by a point:
STRUCT.MEMBER
.
-
size
¶ Property which return the size of this member as an integer.
-
offset
¶ Property providing access to the start offset of this member in the structure as an integer.
-
end_offset
¶ Property which return the end offset of this member as an integer. This should be equivalent to use
offset + size
.
-
__str__
() <==> str(x)¶
-
comment
¶ Return the comment associated with this member as a string.
-
rcomment
¶ Return the repeatable comment associated with this member as a string.
-
has_type
¶ Property which return True if this member as a type defined (which can be recuperated through
BStructMember.type()
) False if no type is defined for this member.
-
del_type
()¶ Method which allow to delete the type for this member.
Todo
handle failure
-
set_type
(new_type, userspecified=True, may_destroy=False, compatible=False, funcarg=False, bytil=False)¶ Method which allow to change the type of this member.
Parameters: - new_type – An object which inherit from
BipType
which represent the new type for this member. - userspecified (bool) – Is this type specified by the user, True by default.
- may_destroy (bool) – Is the setting of this type can destroy other members of the struct, default is False.
- compatible (bool) – The new type should be compatible with the previous one. Default is False.
- funcarg (bool) – Is the member used as argument of a function, in particular this forbid the setting of array. Default is False.
- bytil (bool) – The new type was created by the type subsystem. Default False.
Raises: - RuntimeError – If setting the type failed.
- TypeError – If the argument is not an
BipType
object.
- new_type – An object which inherit from
-
type
¶ Property which return an object which inherit from
BipType
and represent the type of this member.Raises: RuntimeError – If it was not possible to get the type of this member, this may happen in particular if has_type()
returned false.
-
is_nested
¶ Return True if this member represent a nested struct included inside the current one. The structure can be recuperated using
nested_struct()
.
-
nested_struct
¶ If this member represent a nested structure this property allows to get the
BipStruct
corresponding to the nested struct.Raises: RuntimeError – If this member does not have a nested struct. This can be tested using is_nested()
.Returns: An BipStruct
object corresponding to the nested struct.
-
static
_is_member_id
(mid)¶ Allow to check if an id (address) from IDA represent a member id. This is a wrapper on
ida_struct.is_member_id
and there should not be any reason to use this method except for interfacing with the IDAPython interface.Parameters: mid (int) – The id to check for being a member id. Returns: True
ifmid
is a member id which can be used for getting aBStructMember
object,False
otherwise.
-
classmethod
_from_member_id
(mid)¶ Class method for getting a
BStructMember
object from an id which represent a member in IDA. There should be no reason to use this method except for interfacing with the IDAPython interface.Parameters: mid (int) – The member id to convert to a BStructMember
.Raises: ValueError – If the argument mid
is not a valid member id. This can be check using the static method_is_member_id()
.Returns: A BStructMember
object corresponding to the member with idmid
.
-


About Blood Donation
Learn how you can be a blood donation hero? There are some facts you have know about blood donation.
Being a donor
Discover blood facts and statistics, and what happens to donated blood.. read more
Eligibility Requirements
Learn more about the eligibility requirements for donating blood.. read more
Donation Process
Learn about the blood donation process, and what to know before making a donation.. read more
FAQs
General queries simply answered here for you.. read more


Typeahead address picker
Demo to show how to use 2 address picker input fields with one map. The map displays the 2 markers.
Very usefull to build a form with a departure and a destination and to compute a route for example.
This example display the route between from and to location but it's up to you to do whatever you want when user changes from or to address.


You can report a bug, submit a new function enhancement recommendation, or submit a development patch about the content above directly.
Submit an Issue
- Before submitting an issue, please go through a comprehensive search to make sure the problem cannot be solved just by searching.
- Check the Issue List to make sure the problem is not repeated.
- Create a new issue.
- Define the issue with a clear and descriptive title.
- If what you submit is a bug, please try to provide the following information:
- Detailed descriptions about the procedures to reproduce it, including the SQL used, configuration, the expected result, the actual result and detailed TRACE log.
- ShardingSphere and the operating system version.
- Demo codes to reproduce the problem on github.
- Full stack log if exception thrown.
- Screenshot or animated gif, if possible, to help in demonstrating the problem production procedure.
- Profile screenshot of CPU, memory or network disk IO, if performance problem concerned.
- If what you submit is a recommendation, please try to provide the following information:
- Detailed descriptions of the behavior mode of enhancement function.
- Explanations for why this function is useful to most users, because a new function should be generally applicable.
- Similar functions that other database middleware already have, if possible, from both open source software and business software.
- Assign appropriate labels after submitting an issue, such as bug, enhancement, discussion, etc.
- Please stay focused on the submitted issue and provide further necessary information.
- Please close the solved issue. If you do not do that in time, we will close it after 7 days.
- Please reopen the issue closed previously, if it has new progress. Please notice that, you have only the right to reopen the issue closed by yourself, but not the one expired and shut down by us.
Submit Pull Request
- Please choose the issue to be edited. If it is a new issue discovered or a new function enhancement to offer, please create an issue and set the right label for it.
- After choosing the relevant issue, please reply with a deadline to indicate that you are working on it.
- Find a mentor from the Developer List and he/she will give you feedback about the design and the implementation of function in time.
- Fork a branch to your own repo to work.
- Please obey the Code of Conduct during the process of development and finish the check before submitting the pull request.
- Send a pull request to the dev branch rather than the master branch of shardingsphere after it is finished.
- The mentor will do code review before discussing some details (including the design, the implementation and the performance) with you. The request will be merged into the branch of current development version after the edit is well enough.
- At last, congratulate to be an official contributor of ShardingSphere!


This plugin provides Flash fallback as well. Flash fallback uses headers property to send extra items as query string. AtomUpload is derived from AtomItemsControl, items property contains an array of selected files for upload. You can customize itemTemplate property to change look and feel.
Headers property can contain JavaScript object with key-value pair that will be added as query string in case of flash fallback. As Flash does not tranmit cookies, it is recommended that you can generate temporary Upload tokens that can be verified on server with query string.
HTTP URL where files will be uploaded.
Value field contains comma separated properties of uploaded result specified as value-path property.
Path of property to bind for uploaded result.
Let's assume, server returns an object representing server's file storage model. Each item contains property 'result' which contains JavaScript object returned from server after successful upload.
<div atom-type="AtomUploader" atom-upload-url="/Upload/UploadTemp" atom-value-path="TempFileID" atom-accept="image/*" atom-value="$[data.UploadedTempFileIDs]"> </div>
Let's assume server returns following,
[{ TempFileID:1, Url: "http://a.b/a" }, { TempFileID:e, Url: "http://a.b/b" } ]
Then $data.UploadedTempFileIDs will contain '1,2'


Error!
No such car with this id.
Car:
Make
Model
Travelled distance
Car parts:
Part name
Part price with discount
Add parts
Add part


USERS, WEBSITE ACCESS, CONTENTUnless otherwise specified on this website, all content on this website and all intellectual property rights therein are owned by Pindler & Pindler, Inc. ("Pindler") or their respective owners. Other than the non-exclusive right of use by "users" as specified herein, no rights to such content or portions thereof, regardless of the form in which it is presented, are conveyed to anyone by its appearance on this website or by the accessing thereof by any user. Subject to these Terms of Use and all applicable laws and regulations, Pindler grants users a non-exclusive, non-transferable, personal, limited license to access, view and use this website and the content and information which Pindler makes available to users from time to time on the terms and conditions set forth in these Terms of Use. This authorization is not a transfer of title to the website or the content contained herein, or any part, and any downloading, modification, reproduction, copying, publication or redistribution for commercial purposes of any information or content or design elements of the website is strictly prohibited without the prior written consent of Pindler. Requests for permission to reproduce any information contained on this website should be addressed to Pindler at<EMAIL_ADDRESS>This license does not include the right to modify this website, or any portion of it, except with the express written consent of Pindler. Any resale or commercial use of this website or the content, any collection and use of any product listings, descriptions, or prices; any derivative use of this website or its contents; any downloading or copying of information for the benefit of another; any sending of unsolicited e-mail, including promotions and/or advertising of products or services; any submission of a virus to website, overloading, flooding, mail bombing or crashing; any use of data mining, robots, or similar data gathering and extraction rules; or any other form of hacking, interference, spamming, sabotage or manipulation is prohibited. Users agree to all additional restrictions displayed on the website as it may be updated from time to time. Users agree to use this website for lawful purposes only and not to post or transmit any information or material which in any way infringes or violates the rights of others or which is unlawful, defamatory, threatening, invasion of privacy or publicity, obscene, harassing or otherwise objectionable. Users will not sublicense, transfer or assign the Terms of Use or any of the rights or licenses granted under the Terms of Use. Any attempted transfer in violation of the foregoing is void. Pindler reserves the right, at its sole discretion, to pursue all of its legal remedies, including but not limited to prosecution of users in violation of these terms and conditions. USAGEBy visiting, using and accessing this website at WWW.PINDLER.COM, users agree to be legally bound and will be deemed to have read, complied, and accepted these Terms of Use. Users must immediately discontinue use of this website if they do not agree or accept all of these Terms of Use. Pindler retains the right to remove and limit access to this website to any user at any time. ONLINE ACCOUNTSPindler may in its sole discretion provide its clients, representatives and associates online access to restricted portions this website. Users with online accounts are solely responsible for protecting the confidentiality of any logon information and any actions or inactions in connection with such account. NO ENDORSEMENTPindler does not recommend, endorse or support any third party business, service, or product, except as expressly stated by Pindler on this website. This website may provide information about third parties or provide third party content, including links to third party websites. Pindler shall not be responsible or liable for any injury or damage incurred by users of this website related to any third party information, even if such information contains mistakes, errors, or inaccuracies. Users who decide to visit any linked site or use any information on this website, do so at their own risk. Pindler does not make any warranty or representation regarding, or endorse or otherwise sponsor, any linked websites or the information appearing thereon or any of the products or services described thereon. Links do not imply that Pindler is affiliated or associated with the linked site, or is legally authorized to use any trademark, trade name, logo or copyright symbol displayed in or accessible through the links; or that any linked site is affiliated or associated with Pindler or is authorized to use any trademark, trade name, logo or copyright symbol of Pindler. Users are prohibited from linking any website or other electronic medium to this site or any other site owned or operated by Pindler without our express written permission.  SOME JURISDICTIONS DO NOT ALLOW THE EXCLUSION OR LIMITATION OF INCIDENTAL OR CONSEQUENTIAL DAMAGES, SO THE ABOVE LIMITATIONS MAY NOT APPLY UNDER SOME CIRCUMSTANCES, AND IN SUCH INSTANCES, PINDLER’S LIABILITY IS LIMITED TO THE GREATEST EXTENT PERMITTED BY APPLICABLE LAW. PINDLER SHALL NOT HAVE ANY LIABILITY OR RESPONSIBILITY FOR ANY ACTIONS, OPINIONS OR CONDUCT OF ANY USER OR OTHER THIRD PARTY.  DISCLAIMER OF WARRANTYTO THE EXTENT PERMITTED BY LAW, A USER’S USE OF THIS WEBSITE IS AT THEIR SOLE RISK. PINDLER MAKES NO REPRESENTATION ABOUT THE FUNCTIONALITY AND USABILITY OF THE CONTENT AND INFORMATION ON THIS WEBSITE.  SOME JURISDICTIONS DO NOT ALLOW FOR THE EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSIONS OF IMPLIED WARRANTIES MAY NOT BE APPLICABLE UNDER CERTAIN CIRCUMSTANCES AND IN SUCH INSTANCES, PINDLER’S LIABILITY IS LIMITED TO THE GREATEST EXTENT PERMITTED BY APPLICABLE LAW. Users should not assume that the content and information on this website is always updated. This website may be inoperable, non-functional, or interrupted on occasion. Users are warned that the content and information herein may contain technical errors, mistakes, inaccuracies, bugs, unknown viruses, and omissions. Users assume all risk related to this website. INDEMNITYUsers agree to defend, indemnify and hold harmless Pindler and its
directors, officers, employees and/or representatives from any claim,
judgment, demand, liability, cause of action, and/or damages (including
but not limited to reasonable attorneys’ fees and disbursements) arising
out of any use of and/or related to this website, including, but not
limited to claims, judgments, demands, liability, causes of action
and/or damage arising out of and/or related to users (i) infringement or
misappropriation of any intellectual property rights, (ii) defamation,
libel, slander, obscenity and/or violation of rights of privacy, (iii)
spamming, or other offensive harassing or illegal conduct, or (iv)
violation of these Terms of Use, or, incorrect website information,
content, or third party products and services. CHANGESThis website and its content and information are subject to change without notice, but Pindler has no responsibility to update any content or information on this website. Pindler reserves the right to change or modify these Terms of Use at any time. Such changes, modifications, additions, or deletions to these Terms of Use shall be effective immediately upon notice thereof, which may be given by any means including, but not limited to, posting new Terms of Use on this website. Any use of this website after such change or modification shall be deemed to constitute acceptance by users of such changes, modifications, additions, or deletions. Pindler may terminate, change, suspend or discontinue any aspect of this website, including the availability of any features of this website, at any time without notice. Pindler may also impose limits on certain features and services or restrict users’ access to parts of this website without notice or liability. TERMINATIONThese Terms of Use and the rights granted herein will terminate automatically and without notice if users fail to comply with any term or condition of these Terms of Use, provided, however, that all provisions relating to disclaimers, limitation of liability, copyright, patent, trademarks, trade secrets and other proprietary rights of Pindler shall survive the termination of these Terms of Use. APPLICABLE LAWThese Terms of Use may only be interpreted and enforced under the laws of the State of California, without reference its principles on conflicts of laws. In the event of any dispute, user and Pindler shall be deemed to have consented to the exclusive jurisdiction of any State or Federal Court in California having jurisdiction, and to have waived any right to contest the inconvenience of such forum. ENTIRE AGREEMENTThese Terms of Use shall constitute the entire agreement between Pindler and users and supersedes any previous oral, written or electronic communications or documents with respect to the subject matter herein. If any part of these Terms of Use and is found invalid or unenforceable by a court of competent jurisdiction, that provision shall be enforced to the maximum extent permissible so as to effect the intent of the parties, and the remainder of these Terms of Use shall continue in full force and effect. INTELLECTUAL PROPERTYThis website, including all information and content contained in it, are copyrighted and protected by worldwide copyright, trademark and other laws and treaty provisions. Users agree to comply with all copyright, patent, trademark and other laws worldwide in use of this website and to prevent any copying, reproduction, modification, distribution, displaying, performing or transmission in violation thereof or of these Terms of Use. Except as expressly provided in these Terms of Use, Pindler does not grant any express or implied license or third party right to you under any patents, trademarks, copyrights or trade secret information of Pindler or of any third party. All website design, text, graphics and the selection and arrangement thereof, are the property of Pindler. All rights in the product or service names, company names, trademarks, trade names, website marks, logos, domain names, product packaging and designs of Pindler or third party products, services or websites whether or not appearing in large print or with the trademark symbol, belong exclusively to Pindler or their respective owners and are protected under national and international trademark and copyright laws. Users are not permitted to use same without the prior express written consent of the owner of such mark. QUESTIONS / COMMENTSUsers having any questions or comments on the terms of use this website, should contact the Webmaster at the following email address<EMAIL_ADDRESS>Users may also write the Webmaster at the following address: Pindler & Pindler, Inc. Pindler & Pindler Contact Info Pindler & Pindler, Inc. Corporate Office and Warehouse COPYRIGHT/TRADEMARKSAll Content Copyright @ 2009 Pindler & Pindler, Inc. and its licensors. All Copyrights and Trademarks Reserved.
Effective Date April 1, 2009 Thank you for visiting www.pindler.com (“Site”), owned and operated by Pindler & Pindler, Inc. (“Pindler”). Pindler is committed to treating the personal and corporate information of our users with respect and sensitivity. Our privacy commitment is described in this Privacy Policy. As our services evolve and we perceive the need or desirability of using information collected in other ways, we may from time to time amend this Privacy Policy. We encourage you to check our Site frequently to see the current Privacy Policy and Terms of Use in effect and any changes that may have been made to them. If we make material changes to this Policy we will post the revised Policy and the revised effective date on this Site. Please check back here periodically or contact us at the address listed at the end of this Policy. This Policy is part of the attached Terms of Use Agreement. General InformationWe believe that you have the right to understand how your information is stored and used. We require that sites linked to our Site contain a notice identifying their privacy policies. We are not responsible for the privacy practices of any third parties or the content of linked sites Information You Provide Us In general, you can visit our Site without telling us who you are or revealing any information about yourself. If you choose to submit information, and are 18 years of age or older, we will collect your name, email address, telephone number and street address along with other information you may choose to submit when contacting us ("Personally Identifiable Information" or "PII"). By providing your PII to us, you explicitly agree to our collection and use of such information as described in this Privacy Policy. Protecting Children's Privacy This Site is not designed nor intended to be attractive to users under the age of 18. Our terms and conditions of Use specifically prohibit the submission of information through the Site by those under the age of 18. We do not knowingly collect information from any person under the age of 18. Cookies We may use cookies to personalize our Site for you and to collect aggregate information about site usage by all of our users. A cookie is a text file that our Site transfers to your computer's hard drive for record-keeping purposes and to enhance the quality of your visit to our Site. The cookie assigns a random, unique number to your computer. It does not contain information which would personally identify you, although we can associate the cookie with any personal identifying information that you provide us while visiting our Site. Our cookie may record "clickstream" information (data reporting the URLs or names of the pages on our Site that you have visited). You can set your browser to refuse cookies, but doing so will limit system performance and may even cause certain features of the Site to malfunction or not to work at all. Use of InformationThe use of your information is subject to the Privacy Policy and Terms of Use in effect at the time of use. The provisions contained herein supersede all previous notices or statements regarding our privacy practices with respect to this Site. We sometimes use aggregated data (independent of any personal identifiers) for research and commercial purposes. This information includes what areas our users visit most frequently and what services they access most often. This information helps us develop a better site that is more useful and accessible to you. We may use your email address to contact you to respond to your inquiries or to provide information to you. You can elect not to receive emails from us by "unsubscribing" to an email you receive or by contacting us as indicated below. We reveal Personally Identifiable Information about you to unaffiliated third parties if: (1) you request or authorize it; (2) the information is provided to help complete a transaction for you; (3) the information is provided to comply with the law, applicable regulations, court orders or subpoenas, to enforce our Terms of Use or other agreements, or to protect our rights, property or safety or the rights, property or safety of our users or others (e.g., to a consumer reporting agency for fraud protection etc.); (4) the disclosure is done as part of a purchase, transfer or sale of services or assets (e.g., in the event that substantially all of our assets are acquired by another party, customer information may be one of the transferred assets); (5) the information is provided to our agents, outside vendors or service providers to perform functions on our behalf (e.g., analyzing data, providing marketing assistance, providing customer service, processing orders, etc.); or (6) to others as described in this Privacy Policy. Access and SecurityWe use industry-standard, established security measures in place in our physical facilities and in our computer systems, databases, and communications networks that are designed reasonably to protect information contained within our systems from loss, misuse or alteration. However, information submitted through the Site is not encrypted or otherwise secured. Corporate InformationIf you choose to submit information to us about yourself or your company in order to register with us, the submission is governed by this Privacy Policy. While we respect your ideas and innovations, we are not responsible for maintaining the confidentiality of any non-public information that you provide us. Please do not submit sensitive information (such as date of birth or Social Security Numbers) to us through our Site. Contacting UsThis site is owned and operated by Pindler & Pindler. If you have any questions or suggestions with respect to this policy, or if you wish to ask us to delete, correct, or show you your information as provided above, please contact the Webmaster at the following email address<EMAIL_ADDRESS>Users may also write the Webmaster at the following address: Pindler & Pindler, Inc. Pindler & Pindler Contact Info Pindler & Pindler, Inc. (c) Copyright 2009 by Pindler & Pindler, Inc.. All rights reserved.
ACCEPTANCE OF ORDERS. All orders placed by you are subject to acceptance by Pindler & Pindler, Inc. and our credit department. Each order placed by you and accepted by us is a sale subject to these Terms and Conditions and indicates your assent to these Terms and Conditions unless otherwise mutually agreed in writing. MINIMUM ORDER. One yard. WHEN ORDERING. Often much time can be saved and your order more satisfactorily filled, if you will specify the end use for which the fabric is intended; and if it is for draperies or curtains, you specify the lengths needed. CORRELATED PRINTS. Correlated prints are designed and colored so they may be used successfully together as companion designs in color correlated decorating plans. But, color correlations should not be confused with an exact dye lot match. Commercial textile printing techniques makes exact dye lot matches between various designs frequently impossible. The real color test for these fabrics is how well they look when installed in your room setting. MULTIPLE WIDTH DRAPERIES. Although in printing every effort is made to avoid distortion, occasionally it will exist. Therefore, when planning multiple width draperies, please make certain before cutting, that the pattern alignment is adequate to produce a satisfactory end result. DRAPERIES. Be tolerant of small fluctuations in length. No fabric is completely stable. It is reasonable to expect a 3% change in any drapery length depending on the fabric involved. Drapery fabrics, due to yarn contents, construction, humidity, etc., will expand or contract under certain atmospheric conditions. You should allow sufficient fabric in the hems for later adjustments, should it be necessary. F.O.B.: Moorpark, CA RETURNS & CLAIMS. No returns accepted without a return authorization number. All authorized returns without fault of the vendor will be subject to a 25% restocking charge, plus freight both ways. No piece less than ten (10) yards on drapery and five (5) yards on upholstery will be accepted under any circumstances. No fabrics with special finishes will be accepted for return. No returns will be accepted after 30 days from the date of shipment. All authorized returns must be in the original wrapping materials in the same condition received by Buyer. Your request for return authorization must include the invoice number, date of invoice, pattern, color, yardage and reason. Fabric can not be returned for credit after it has been cut. Yardage must be inspected for flaws, correctness of color, pattern, quantity and quality before cutting as no allowance will be made for cut fabric. When shipments are made direct to workrooms it is your responsibility to send a cutting to the workroom to enable them to verify the goods are correct before processing. No claims or returns will be accepted for drop shipments made per customers’ request. All authorized returns for “damaged” fabric will be subject to inspection. Since color variation often can not be avoided from one dye lot to another, we do not guarantee dye lots, and can issue no credit for dye lot variation unless a cutting for approval was requested with the order. Refused shipments, customer duplication of orders, or cancellations after shipment has been made are subject to a 25% restocking charge and all freight charges. No fabric can be returned for credit if it has been processed by the purchaser in any way. Fabric damage or failure due to color fading, pilling or shrinking is not valid where there is evidence of heavy soiling, abuse, or improper cleaning. HANDLOOMED AND NATURAL FIBER FABRICS. Handwoven and natural fiber fabrics may have slight variation in weave and color which are not to be considered flaws. These variations are inherent to handloom textiles and natural fiber fabrics and are part of their unique character. The characteristics slubs enhance its natural beauty and texture. This texture is produced through a natural processing in carding, spinning and weaving. In many cases, the color is natural and not dyed. Because of variations in dyelots, yarns and weaves, the fabric in stock may vary from samples, we recommend a cutting from current stock be required. No guarantees are made regarding colorfastness, fading or exact matching. All measurements quoted for repeats are approximate. Side matching of repeats on ikats, stripes, checks, plaids and ribbed patterns will not be exact. FADING. The best available dyes are used, but our fabrics are not guaranteed against color fading through exposure to the sun or atmospheric conditions. Some colors are more fugitive than others. Colors can fade by oxidation, “gas fading,” if fabrics are kept in storage for too long a period without airing. Impurities in the air may cause as much fading as the direct rays of the sun. MEMO SAMPLES. Loan samples are available at all our showrooms. We do not guarantee to match colors. If these memo samples are not returned within 30 days they will be billed and not accepted for credit after due date. The return date from memo samples may be extended upon request. CAUTION. Due to the possibility of differences in dye lots, we recommended that all fabrics necessary to complete the job be in your possession before any work is started. Paints and special dye jobs should be made up to match actual fabrics, not sample equipment. No claims will be recognized on fabric after it has been in any way processed by the purchaser. We do not guarantee to match colors. If an exact match is required, a cutting of current stock should be requested. No fabric will be accepted for return due to dye lot variation. WARRANTY AND LIMITATIONS ON LIABILITY. Seller warrants that the merchandise will, at the time it is delivered to Buyer, be free from defects in materials or workmanship, within generally accepted industry standards. This warranty is in lieu of all other warranties with respect to the merchandise, including any implied warranties of merchantability or fitness. Any claim under this warranty shall be deemed waived unless made in writing within 30 days of receipt of the merchandise by the Buyer and before any part of the merchandise has been used, resold or transferred. Upon Seller’s approval, non-conforming merchandise may be returned to Seller for credit or replacement, at Seller’s option. Seller expressly disclaims any responsibility for and is not liable to Buyer and/or any user for (1) special or consequential damages arising out of or in any way connected with the sale or use of the merchandise, and (2) variances in and/or damage to merchandise to which any after-market finish and/or treatment has been applied (e.g., Teflon, Flame Proofing, Laminating, Paper or Acrylic Backing, Soil and Stain Protection, etc.). In no event shall Seller’s liability exceed the amount paid by Buyer to Seller for the non-conforming merchandise. In no event shall Seller be liable for any failure or delay in delivery of all or any part of the merchandise, due, in whole or part, to lockouts, labor disputes, production or transportation interruptions or limitations, shortages or delays in delivery or receipt of materials, acts of God or any other cause beyond Seller’s economically reasonable control. In no event may any action be brought against Seller more than one (1) year after the merchandise was delivered to Buyer. VENUE. All sale and purchase agreements, purchase orders and invoices are made and performed in Moorpark, California, and shall be interpreted and construed in accordance with the laws of California. Any action brought to resolve a dispute arising from the interpretation or construction of or to enforce any such agreement, purchase order and/or invoice shall be brought in a court of competent jurisdiction in Ventura County, California and the parties consent to venue and jurisdiction of such courts. AFTER-MARKET FINISHES. All after-market finishes and/or treatments are done at customers request and risk. Seller expressly disclaims any responsibility for and is not liable to Buyer and/or any user for variances in and/or damage to merchandise to which any after-market-finish and/or treatment has been applied (e.g., Teflon, Flame Proofing, Laminating, Paper or Acrylic Backing, Soil and Stain Protection, etc.). Any after-market finish and/or treatment applied on washed fabrics may alter the prewashed characteristics. Shrinkage must be allowed. The below prices are based on yardage of identical style and color. Prices are subject to change without notice. |


It’s the birth of another open source project live on this week’s Coder Radio. Plus it’s an open mic edition & we discuss a wide range of topics from Microsoft’s big mobile strategy that nobody is noticing, the best Linux development environment, setting expectations, your feedback & more!
Thanks to:
Direct Download:
MP3 Audio | OGG Audio | Video | Torrent | YouTube
RSS Feeds:
MP3 Feed | OGG Feed | Video Feed | Torrent Feed | iTunes Audio | iTunes Video
Become a supporter on Patreon:
– Show Notes: –
Feedback / Follow Up:
Content needed for the Best of Moments:
- Episode Title:
- Link to Episode:
- Timecode:
- What was the topic:
submit the content on the following form, http://goo.gl/forms/pK0zNG4F3i
OpenYourMouth
Dev Hoopla:
Microsoft today announced it had acquired HockeyApp, a crash analytics service for mobile apps. The company intends to integrate HockeyApp into Visual Studio Online to improve support for iOS and Android development in addition to Windows Phone.
HockeyApp provides a variety of tools for helping developers distribute and test mobile apps, including crash reporting, beta software distribution and feedback, and cross-platform support for iOS, Android and Windows Phone.
In the coming months, Microsoft will announce new iOS and Android SDKs for its Application Insights software to take advantage of the new tools. HockeyApp for its part says that nothing will change for its users at the moment; their apps and accounts will continue to work the same.
Today we announce Go 1.4, the fifth major stable release of Go, arriving six
months after our previous major release Go 1.3.
It contains a small language change, support for more operating systems
and processor architectures, and improvements to the tool chain and libraries.
As always, Go 1.4 keeps the promise of compatibility, and almost everything
will continue to compile and run without change when moved to 1.4.
For the full details, see the Go 1.4 release notes.The most notable new feature in this release is official support for Android.
Using the support in the core and the libraries in the
golang.org/x/mobile repository,
it is now possible to write simple Android apps using only Go code.
At this stage, the support libraries are still nascent and under heavy development.
Early adopters should expect a bumpy ride, but we welcome the community to get involved.
The focus of Apple’s censorship lies in the full-body scanner introduced a few levels into the game that tasks the player with ensuring the person attempting to enter Arstotzka isn’t carrying any kind of contraband. The PC, Mac, and Linux versions of the game depicted fully nude (albeit in low resolution given the nature of the game’s graphics) versions of characters when put through this scanner, with an option to censor the nudity by including underwear on the characters.
Papers, Please for iPad, however, removes the choice from the equation, automatically covering the characters in underwear when scanned by the player.


RISE AND PINE CO.Ambassadors of The Big (Pine)Apple
Our Vision
The addictive energy of New York City is rivaled by no other. RISE AND PINE is an ambassador for this place we call home, spreading that feeling that anything is possible under the bright city lights.
Our Story
City Inspired
RISE AND PINE is based in New York City, the city that never sleeps and the mecca for hustlers. From the suit & ties in Midtown to the laid back vibes of the East Village, it is this addictive energy that only those who have been here can understand.
Our designs are a fun representation of the eclectic personalities that make up the Big (Pine)Apple.
THE BIG (PINE)APPLE
A Pineapple wearing a suit hustling around the big city: what's there not to love?
RISE AND PINE aims to capture that Go! Go! Go! rush of energy bundled up into a fun little mascot.
Our Products
We are committed to sourcing locally in the U.S., choosing only the highest quality materials and manufacturers to best represent our brand.
As we expand our line (shirts are next), we promise to remain rooted in our core values and continuously provide a splash of fun for the city lifestyle.


fraud_backend.core package¶
Submodules¶
fraud_backend.core.classification_result module¶
-
class
fraud_backend.core.classification_result.
ClassificationResult
(label=None, score=None)[source]¶ Bases:
object
This class describes the classification result.
It basically consists of a label such as ‘FRAUD / NOT_FRAUD’ and a value/score that is a probability of the predicted label.
-
label
¶ Get the label.
-
score
¶ Get the score.
-
fraud_backend.core.feature module¶
-
class
fraud_backend.core.feature.
Feature
(description=None, kind=None, name=None, value=None, position=None, is_target=None)[source]¶ Bases:
object
This class describes a feature.
A Feature is essentially an attribute of a more concrete data collection that is called Transaction. The characteristics of the Feature class are described bellow.
-
description
¶ Return the feature’s description.
-
is_target
¶ Return true if feature is a target variable.
-
kind
¶ Return the feature’s type.
-
name
¶ Return the feature’s name.
-
position
¶ Return the feature’s order.
-
value
¶ Return the feature’s value.
-
fraud_backend.core.insight module¶
-
class
fraud_backend.core.insight.
Insight
(description=None, name=None, value=None)[source]¶ Bases:
object
This class describes an insight.
An insight may be a statistical metric calculated from a transaction or any other information about the transaction that is considered to be important.
-
description
¶ Return the insight’s description.
-
name
¶ Return the insight’s name.
-
value
¶ Return the insight’s value.
-
fraud_backend.core.transaction module¶
-
class
fraud_backend.core.transaction.
Transaction
[source]¶ Bases:
object
This class describes a Transaction.
A Transaction is the most important data source and it is expressed as a list of features. The characteristics of the Transaction class are described bellow.
-
add_feature
(feature)[source]¶ Add a feature to the transaction.
Parameters: feature – the feature object to be added to a transaction
-
get_feature
(index)[source]¶ Get a feature from transaction.
Parameters: index – the index of the feature object to be retrieved Returns: a feature Return type: Feature
-
id
¶ The size of features of a transaction.
-
number_of_features
()[source]¶ Get the number of features.
Returns: the number of features of a transaction Return type: int
-
transaction
= None¶ The id of the transaction.
-
Module contents¶
Init file of core
package.
-
class
fraud_backend.core.
Feature
(description=None, kind=None, name=None, value=None, position=None, is_target=None)[source]¶ Bases:
object
This class describes a feature.
A Feature is essentially an attribute of a more concrete data collection that is called Transaction. The characteristics of the Feature class are described bellow.
-
description
¶ Return the feature’s description.
-
is_target
¶ Return true if feature is a target variable.
-
kind
¶ Return the feature’s type.
-
name
¶ Return the feature’s name.
-
position
¶ Return the feature’s order.
-
value
¶ Return the feature’s value.
-
-
class
fraud_backend.core.
Transaction
[source]¶ Bases:
object
This class describes a Transaction.
A Transaction is the most important data source and it is expressed as a list of features. The characteristics of the Transaction class are described bellow.
-
add_feature
(feature)[source]¶ Add a feature to the transaction.
Parameters: feature – the feature object to be added to a transaction
-
get_feature
(index)[source]¶ Get a feature from transaction.
Parameters: index – the index of the feature object to be retrieved Returns: a feature Return type: Feature
-
id
¶ Get transaction’s id.
-
-
class
fraud_backend.core.
Insight
(description=None, name=None, value=None)[source]¶ Bases:
object
This class describes an insight.
An insight may be a statistical metric calculated from a transaction or any other information about the transaction that is considered to be important.
-
description
¶ Return the insight’s description.
-
name
¶ Return the insight’s name.
-
value
¶ Return the insight’s value.
-
-
class
fraud_backend.core.
ClassificationResult
(label=None, score=None)[source]¶ Bases:
object
This class describes the classification result.
It basically consists of a label such as ‘FRAUD / NOT_FRAUD’ and a value/score that is a probability of the predicted label.
-
label
¶ Get the label.
-
score
¶ Get the score.
-


"ABIHAIL "father of might. (1.) Numbers 3:35. (2.) 1 Chronicles 2:29. (3.) 1 Chronicles 5:14. (4.) The second wife of King Rehoboam (2 Chronicles 11:18), a descendant of Eliab, David’s eldest brother. (5.) The father of Esther and uncle of Mordecai (Esther 2:15).
"ABIHAIL "father of might. (1.) Numbers 3:35. (2.) 1 Chronicles 2:29. (3.) 1 Chronicles 5:14.
(4.) The second wife of King Rehoboam (2 Chronicles 11:18), a descendant of Eliab, David’s eldest brother.
(5.) The father of Esther and uncle of Mordecai (Esther 2:15).


--- layout: post title: BlueDevil 1.0.4 released categories: - KDE - Software Libre tags: [] status: publish type: post published: true meta: _edit_last: '2' dsq_thread_id: '2244597974' author: login: afiestas email<EMAIL_ADDRESS>display_name: afiestas first_name: Àlex last_name: Fiestas ---
Fourth patch version or our KDE Bluetooth Stack, this time containing an important fix:
Downloads:
BlueDevil tarball:
md5sum: 016e8b048bd834548a436fb0440667a9
download: here
Note:
This version, as the one before (1.0.3) depends on libbluedevil 1.8.1, so be sure to ship them both!
The tag and tarball for 1.1 are done, I will try to publish a graphic/video changelog shortly!


---
layout: default
---
Here are some small problems I have solved. These problems will range from simple Python puzzles to useful pieces of code for using tools like AWS S3, for instance. All posts will contain tags as well, check them out to have a little overview of the material covered in each post!
industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting,
industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting,
industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting,
Use the grid-gap property to adjust the space between the columns and the rows.
Thanks for checking this out!


| between {dplyr} | R Documentation |
This is a shortcut for x >= left & x <= right
, implemented
efficiently in C++ for local values, and translated to the
appropriate SQL for remote tables.
between(x, left, right)
x |
A numeric vector of values |
left, right |
Boundary values (must be scalars). |
between(1:12, 7, 9) x <- rnorm(1e2) x[between(x, -1, 1)] ## Or on a tibble using filter filter(starwars, between(height, 100, 150))


LOGO
ABOUT
ARTICLES
SUBSCRIBE
GREEN
HOLISTIC HEALTH
Title
Subtitle
Title
Subtitle
Title
Subtitle
ABOUT
ARTICLES
SUBSCRIBE


{{people?.population?.total}}
country comparison to the world: {{people?.population?.rank}}
noun: {{people?.nationality?.noun}}
adjective: {{people?.nationality?.adjective}}
{{people?.ethnic?.group}}
0">notes: {{people?.ethnic?.note}}
{{people?.language?.lg}}
0">notes: {{people?.language?.notes}}
{{people?.religion}}
0-14 years: {{people?.age?.a14}}
15-24 years: {{people?.age?.a24}}
25-54 years: {{people?.age?.a54}}
55-64 years: {{people?.age?.a64}}
65 years and over: {{people?.age?.over}}
total dependency ratio: {{people?.dependency?.total}}
youth dependency ratio: {{people?.dependency?.youth}}
elderly dependency ratio: {{people?.dependency?.elderly}}
potential support ratio: {{people?.dependency?.support}}
total dependency ratio: {{people?.median?.total}}
male: {{people?.median?.male}}
female: {{people?.median?.female}}
country comparison to the world: {{people?.median?.rank}}
{{people?.growth?.rate}}
country comparison to the world: {{people?.growth?.rank}}
{{people?.birth?.rate}}
country comparison to the world: {{people?.birth?.rank}}
{{people?.death?.rate}}
country comparison to the world: {{people?.death?.rank}}
{{people?.migration?.rate}}
country comparison to the world: {{people?.migration?.rank}}
{{people?.distribution}}
urban population: {{people?.urbanization?.urban}}
rate of urbanization: {{people?.urbanization?.rate}}
{{people?.urban_areas}}
at birth: {{people?.sex?.birth}}
0-14 years: {{people?.sex?.a14}}
15-24 years: {{people?.sex?.a24}}
25-54 years: {{people?.sex?.a54}}
55-64 years: {{people?.sex?.a64}}
65 years and over: {{people?.sex?.over}}
total population: {{people?.sex?.total}}
{{people?.mother_first_birth}}
{{people?.mother_death?.rate}}
country comparison to the world: {{people?.mother_death?.rank}}
total: {{people?.infant_death?.total}}
male: {{people?.infant_death?.male}}
female: {{people?.infant_death?.female}}
country comparison to the world: {{people?.infant_death?.rank}}
total: {{people?.life_birth?.total}}
male: {{people?.life_birth?.male}}
female: {{people?.life_birth?.female}}
country comparison to the world: {{people?.life_birth?.rank}}
{{people?.fertility?.rate}}
country comparison to the world: {{people?.fertility?.rank}}
{{people?.contraceptive}}
{{people?.health_exp?.rate}}
country comparison to the world: {{people?.health_exp?.rank}}
{{people?.physicians}}
{{people?.hospital}}
Improved:
urban: {{people?.drink_water?.imp?.urban}}
rural: {{people?.drink_water?.imp?.rural}}
total: {{people?.drink_water?.imp?.total}}
Unimproved:
urban: {{people?.drink_water?.unimp?.urban}}
rural: {{people?.drink_water?.unimp?.rural}}
total: {{people?.drink_water?.unimp?.total}}
Improved:
urban: {{people?.sanitation?.imp?.urban}}
rural: {{people?.sanitation?.imp?.rural}}
total: {{people?.sanitation?.imp?.total}}
Unimproved:
urban: {{people?.sanitation?.unimp?.urban}}
rural: {{people?.sanitation?.unimp?.rural}}
total: {{people?.sanitation?.unimp?.total}}
{{people?.hiv_prevalence?.rate}}
country comparison to the world: {{people?.hiv_prevalence?.rank}}
{{people?.hiv_living?.rate}}
country comparison to the world: {{people?.hiv_living?.rank}}
{{people?.hiv_death}}
{{people?.obesity?.rate}}
country comparison to the world: {{people?.obesity?.rank}}
{{people?.underweight?.rate}}
country comparison to the world: {{people?.underweight?.rank}}
{{people?.educ_exp?.rate}}
country comparison to the world: {{people?.educ_exp?.rank}}
definition: {{people?.literacy?.def}}
total: {{people?.literacy?.total}}
male: {{people?.literacy?.male}}
female: {{people?.literacy?.female}}
total: {{people?.school?.total}}
male: {{people?.school?.male}}
female: {{people?.school?.female}}
total: {{people?.unemploy?.total}}
male: {{people?.unemploy?.male}}
female: {{people?.unemploy?.female}}
country comparison to the world: {{people?.unemploy?.rank}}
{{people?.people_note}}