- main(String[]) - Static method in class main.java.view.ApplicationInterface
-
- main(String[]) - Static method in class main.java.view.ConsoleView
-
Main entry point into program This class and therefore method is only used to
test functionality and program flow before GUI was created
- Main - Class in main.java.view
-
- Main() - Constructor for class main.java.view.Main
-
- main(String[]) - Static method in class main.java.view.Main
-
- main(String[]) - Static method in class main.java.view.SalesSelection
-
- main.java.controller - package main.java.controller
-
Package for holding all objects which control data
- main.java.delivery - package main.java.delivery
-
Package for holding all objects which involve the delivery process.
- main.java.exceptions - package main.java.exceptions
-
Package for holding all exceptions
- main.java.stock - package main.java.stock
-
Package for holding all objects related to stock control
- main.java.view - package main.java.view
-
Package for all user interface objects
- Manifest - Class in main.java.delivery
-
- Manifest(Stock) - Constructor for class main.java.delivery.Manifest
-


Wallace fined $50,000 by NASCAR for intentional spin
by JENNA FRYERAVONDALE, Ariz. (AP) — Bubba Wallace was fined $50,000 by NASCAR for causing a caution last week at Texas that affected the race for at least one playoff driver.
Wallace was also docked 50 points in the driver standings.
His spin in last Sunday’s race was criticized by Kyle Larson as intentional and it brought out a caution for Wallace.
Wallace had a flat tire and needed to go to pit road and was attempting to minimize the impact to his race. But it changed the outcome of Larson’s race and dropped him into a deep hole before the final race to qualify for NASCAR’s championship round.
Larson’s criticism brought the issue of deliberate cautions to the forefront during an intense competition for the two remaining positions in the final four.
JENNA FRYER


Warehouse Connect is a warehouse matching service designed to bring those looking to rent a warehouse for a period of time from a professional, registered warehouse owner. We pride ourselves on our dedication to providing quality and consistent service to leasees and warehouse owners alike!
"I am a small business owner, and I struggled for years to find the right warehouses to store my products as I continute to expand my operations in new locations. The flexibility and limitless options WarehouseConnect provides has made my job so much easier."
"When I inherited my warehouse property from my late great uncle, I had no idea what to do with it. The WarehouseConnect platform is simple to use, and made it incredibly easy for me to advertise and rent out my property."
"Between my family business and my three kids, I am constantly busy. I'm so grateful that I can count on WarehouseConnect to quickly connect me to reliable warehouse properties operated by reputable warehouse owners."
Can we add a cool image of a map with pushpins on locations or something like that?


The people in the small village near the border had to abandon their homes and cordon off their land in order to protect themselves from an impending enemy attack. [G|D]
There was an abundance of cotyledons in the garden, and the friendly old man named Don was always keen to point them out to anyone who passed by. [G|D]
The ancient tribe of Myrmidons once used the bones of the mastodon as tools, and they were renowned for their strength and wisdom. [G|D]
The air inside the cave was filled with a deadly amount of radon, and the adventurers had to be careful to avoid any contact with the fragile tendons located in its walls. [G|D]


Overview
Sudoku Puzzle Solver is a simple Eclipse
view that allows you to solve Sudoku
puzzles. You can create a new blank puzzle, enter pre-set
values yourself, and then solve the puzzle. Or you can have a puzzle
with pre-set values generated for you.
To start the Sudoku Puzzle Solver, that is to open the Sudoku view,
select the Sudoku menu item
and then Open Sudoku Puzzle.
Copyright 2006 by John
Kellerman


v1.0.2
Released: April 11, 2019
New User interface.
Html Support.
Premium Member support.
More generator options.
Stable.
Multiple pages of options.
Multi limited proxy support.
v1.0.1
Released: March 6, 2019
Fixed crashing bug.
v1.0
Released: March 6, 2019
Recreated generator.
Multiple email services.
Semi Stable.


Serializing
The following methods are used for serializing Config
objects back into INI files:
Both methods are thread safe.
The Config
class implements the {@link oaj.Writable} which means it can be
returned as-is by REST methods to be serialized as INI text.


package mutable
The mutable
package within graphalytics
contains classes, traits and objects
for graph analytics on mutable Trees, 'DAG's and Directed Graphs.
- Alphabetic
- By Inheritance
- mutable
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
Type Members
-
class
Ball
[TLabel] extends AnyRef
The
Ball
class provides an implementation for ball construction.The
Ball
class provides an implementation for ball construction. A ball consists of all vertices within a given radius of a given center.- See also
ieeexplore.ieee.org/xpl/login.jsp?tp=&arnumber=6691601&tag=1&url=http%3A%2F%2Fieeexplore.ieee.org%2Fxpls%2Fabs_all.jsp%3Farnumber%3D6691601%26tag%3D1
-
case class
BiconnectedComp
[TLabel](g_: Graph[TLabel]) extends Product with Serializable
The
BiconnectedComp
class provides methods for finding the cut points and blocks in undirected graphs.The
BiconnectedComp
class provides methods for finding the cut points and blocks in undirected graphs. Removal of a cut point will make the graph disconnected. Cut points and blocks are also referred to as articulation points and biconnected components, respectively.- g_
the graph whose cut points/blocks are sought
-
case class
Block
(_id: Int) extends Product with Serializable
The
Block
class is used record information about biconnected components (blocks). -
class
BoundedTreeWidthBN
extends Error
The
BoundedTreeWidthBN
class provides bounded treewidth Bayesian Networks. -
class
DualIso
[TLabel] extends GraphMatcher[TLabel]
The
DualIso
class provides an implementation for Subgraph Isomorphism that uses Dual Graph Simulation for pruning. -
class
DualSim
[TLabel] extends GraphMatcher[TLabel]
The
DualSim
class provides an implementation for Dual Graph Simulation usingGraph
and is based onDualSim2
, which differs fromDualSim
by not using inverse adjacency sets ('pa') in order to save space. -
class
DualSimCAR
[TLabel] extends GraphMatcher[TLabel]
The 'DualSimCAR' classs provides an implementation for Dual Graph Simulation.
-
class
Graph
[TLabel] extends Cloneable
The
Graph
class stores vertex-labeled directed graphs using an adjacency set 'ch' representation, e.g., 'ch = { {1, 2}, {0}, {1} }' means that the graph has the following edges { (0, 1), (0, 2), (1, 0), (2, 1) }.The
Graph
class stores vertex-labeled directed graphs using an adjacency set 'ch' representation, e.g., 'ch = { {1, 2}, {0}, {1} }' means that the graph has the following edges { (0, 1), (0, 2), (1, 0), (2, 1) }. Optionally, inverse adjacency via the 'pa' array can be stored at the cost of nearly doubling the storage requirements. ---------------------------------------------------------------------------- -
class
GraphDFS
[TLabel] extends AnyRef
The
GraphDFS
performs Depth First Search (DFS) or Breadth First Search (BFS) on a Directed Graph.The
GraphDFS
performs Depth First Search (DFS) or Breadth First Search (BFS) on a Directed Graph. The class currently supports three predicates: (1) to find a matching label, and (2) to see if a destination vertex is reachable. -
class
GraphGen
[TLabel] extends Error
The
GraphGen
object is used to build random graphs with various characteristics.The
GraphGen
object is used to build random graphs with various characteristics. Needs to generate vertex labels of various types includingInt
,Double
,String
,VectorD
based on theTLabel
type. -
class
GraphIO
[TLabel] extends Error
The
GraphIO
class is used to write digraphs to a file. -
abstract
class
GraphMatcher
[TLabel] extends AnyRef
The
GraphMatcher
abstract class serves as a template for implementing specific algorithms for graph pattern matching. -
class
GraphMetrics
[TLabel] extends AnyRef
The
GraphMetrics
class provides methods for determining graph metrics that can be efficiently computed using Breadth-First Search (BFS).The
GraphMetrics
class provides methods for determining graph metrics that can be efficiently computed using Breadth-First Search (BFS). This works for undirected graphs. If a directed graph is passed in, it will be converted to a corresponding undirected graph. -
class
GraphSim
[TLabel] extends GraphMatcher[TLabel]
The
GraphSim
class provides a second implementation for Simple Graph Simulation.The
GraphSim
class provides a second implementation for Simple Graph Simulation. It differ fromGraphSim
in the parent directory in the looping order in the main for-loop and early termination when 'phi(u)' is empty. -
class
GraphSimCAR
[TLabel] extends GraphMatcher[TLabel]
The
GraphSimCAR
class provides an implementation for Simple Graph Simulation. -
class
MDualIso
[TLabel] extends GraphMatcher[TLabel]
The
MDualIso
class provides an implementation for Subgraph Isomorphism that uses Dual Graph Simulation for pruning. -
class
MDualSim
[TLabel] extends GraphMatcher[TLabel]
The
MDualSim
class provides a second implementation for Dual Graph Simulation.The
MDualSim
class provides a second implementation for Dual Graph Simulation. It differs fromDualSim
by not using inverse adjacency sets ('pa') in order to save space. -
class
MDualSimCAR
[TLabel] extends GraphMatcher[TLabel]
The 'MDualSimCAR' classs provides an implementation for Dual Graph Simulation.
-
class
MDualSimW
[TLabel] extends GraphMatcher[TLabel]
The
MDualSimW
class provides a second implementation for Dual Graph Simulation.The
MDualSimW
class provides a second implementation for Dual Graph Simulation. It differs fromDualSim
by not using inverse adjacency sets ('pa') in order to save space. This version also supports wildcards and regex. -
class
MGraph
[TLabel] extends Graph[TLabel] with Cloneable
The
MGraph
class stores vertex/edge-labeled multi-directed graphs using an adjacency set 'ch' representation, e.g., 'ch = { {1, 2}, {0}, {1} }' means that the graph has the following edges { (0, 1), (0, 2), (1, 0), (2, 1) }.The
MGraph
class stores vertex/edge-labeled multi-directed graphs using an adjacency set 'ch' representation, e.g., 'ch = { {1, 2}, {0}, {1} }' means that the graph has the following edges { (0, 1), (0, 2), (1, 0), (2, 1) }. Optionally, inverse adjacency via the 'pa' array can be stored at the cost of nearly doubling the storage requirements. ---------------------------------------------------------------------------- -
class
MGraphGen
[TLabel] extends AnyRef
The
MGraphGen
object is used to build random graph with various characteristics. -
class
MGraphIO
[TLabel] extends Error
The
MGraphIO
class is used to write multi-digraphs to a file. -
class
MGraphSim
extends GraphMatcher[Double]
The
MGraphSim
class provides a second implementation for Simple Graph Simulation.The
MGraphSim
class provides a second implementation for Simple Graph Simulation. It differ fromGraphSim
in the looping order in the main for-loop and early termination when 'phi(u)' is empty. -
class
MGraphSimCAR
[TLabel] extends GraphMatcher[TLabel]
The
MGraphSimCAR
class provides an implementation for Simple Graph Simulation. -
class
MStrictSim
[TLabel] extends GraphMatcher[TLabel]
The 'MStrictSim' class provides an implementation for strict simulation graph pattern matching.
The 'MStrictSim' class provides an implementation for strict simulation graph pattern matching. This version uses
DualSim
.- See also
hipore.com/ijbd/2014/IJBD%20Vol%201%20No%201%202014.pdf
-
class
MStrictSimCAR
[TLabel] extends GraphMatcher[TLabel]
The 'MStrictSimCAR' class provides an implementation for strict simulation graph pattern matching.
The 'MStrictSimCAR' class provides an implementation for strict simulation graph pattern matching. This version uses
DualSim
.- See also
hipore.com/ijbd/2014/IJBD%20Vol%201%20No%201%202014.pdf
-
class
MTightSim
[TLabel] extends GraphMatcher[TLabel]
The 'MTightSim' class provides an implementation for tight simulation graph pattern matching.
The 'MTightSim' class provides an implementation for tight simulation graph pattern matching. This version uses
DualSim
.- See also
hipore.com/ijbd/2014/IJBD%20Vol%201%20No%201%202014.pdf
-
class
MTightSimCAR
[TLabel] extends GraphMatcher[TLabel]
The 'MTightSimCAR' class provides an implementation for tight simulation graph pattern matching.
The 'MTightSimCAR' class provides an implementation for tight simulation graph pattern matching. This version uses
DualSim
.- See also
hipore.com/ijbd/2014/IJBD%20Vol%201%20No%201%202014.pdf
-
class
MinSpanningTree
extends Error
The
MinSpanningTree
class is used to build minimum cost spanning trees from graphs.The
MinSpanningTree
class is used to build minimum cost spanning trees from graphs. Edge cost/weights are given by edge labels.MinSpanningTree
implements Prim's algorithm.- See also
www.cse.ust.hk/~dekai/271/notes/L07/L07.pdf
-
class
Partition
[TLabel] extends AnyRef
The
Partition
class is used to partition large directed graphs.The
Partition
class is used to partition large directed graphs. It support the following three algorithms: 'group_ran', 'group_ord', 'group_lp'.(1) Random Partitioning - excellent balance, poor edge cuts Each vertex is given a randomly assigned integer label 'ilabel' and is grouped accordingly.
(2) Ordered Partitioning - excellence balance, edge cuts may or may not be good Each vertex is assigned an integer label 'ilabel' incrementally and is grouped accordingly, e.g., {0, 1, ..., 9}, {10, 11, ..., 19}, ...
(3) Label Propagation partitioning - fair balance, fair edge cuts Each vertex is initially given a unique integer label 'ilabel'. On each iteration, each vertex will have its 'ilabel' reassigned to the most popular/frequent 'ilabel' in its neighborhood (which includes its children, parents and itself).
- See also
research.microsoft.com/pubs/183714/Partition.pdf ----------------------------------------------------------------------------
-
case class
Query
[TLabel](triples: (TLabel, TLabel, TLabel)*)(implicit evidence$1: ClassTag[TLabel]) extends Product with Serializable
The
Query
class provides a means for entering queries as a sequence of triples.The
Query
class provides a means for entering queries as a sequence of triples. A triple may be viewed as (subject, predicate, object), (s, p, o) or (source vertex, edge, target vertex). Support for wildcards, regexes and variables are provided.- triples
the sequence of triples forming the query
-
class
SSShortestPath
extends AnyRef
The
SSShortestPath
class is used to solve shortest path problems for graphs stored in matrices.The
SSShortestPath
class is used to solve shortest path problems for graphs stored in matrices. It solves the Single-Source Shortest Path 'SSSP' problem for directed graphs (both digraphs and multi-digraphs). TheSSShortestPath
companion object is used to form a matrix from anMGraph
. ---------------------------------------------------------------------------- The edge cost/distance (must be non-negative) can be stored in either a dense or sparse matrix. Dijkstra's Algorithm is used.- See also
thescipub.com/PDF/jcssp.2013.377.382.pdf ----------------------------------------------------------------------------
en.wikipedia.org/wiki/Dijkstra%27s_algorithm ---------------------------------------------------------------------------- For multi-digraphs, each multi-edge between a pair vertices has it own edge weight (
TLabel
=VectorD
in this case). The minimum is taking when forming the corresponding matrix.
-
class
SpanningTree
extends Error
The
SpanningTree
class is used to build spanning trees from graphs. -
class
StrictSim
[TLabel] extends GraphMatcher[TLabel]
The 'StrictSim' class provides an implementation for strict simulation graph pattern matching.
The 'StrictSim' class provides an implementation for strict simulation graph pattern matching. This version uses
DualSim
.- See also
hipore.com/ijbd/2014/IJBD%20Vol%201%20No%201%202014.pdf
-
class
StrictSimCAR
[TLabel] extends GraphMatcher[TLabel]
The 'StrictSimCAR' class provides an implementation for strict simulation graph pattern matching.
The 'StrictSimCAR' class provides an implementation for strict simulation graph pattern matching. This version uses
DualSim
.- See also
hipore.com/ijbd/2014/IJBD%20Vol%201%20No%201%202014.pdf
-
class
TightSim
[TLabel] extends GraphMatcher[TLabel]
The 'TightSim' class provides an implementation for tight simulation graph pattern matching.
The 'TightSim' class provides an implementation for tight simulation graph pattern matching. This version uses
DualSim
.- See also
hipore.com/ijbd/2014/IJBD%20Vol%201%20No%201%202014.pdf
-
class
TightSimCAR
[TLabel] extends GraphMatcher[TLabel]
The 'TightSimCAR' class provides an implementation for tight simulation graph pattern matching.
The 'TightSimCAR' class provides an implementation for tight simulation graph pattern matching. This version uses
DualSim
.- See also
hipore.com/ijbd/2014/IJBD%20Vol%201%20No%201%202014.pdf
Value Members
-
object
BiconnectedCompTest
extends App
The
BiconnectedCompTest
object tests theBiconnectedComp
class.The
BiconnectedCompTest
object tests theBiconnectedComp
class.- See also
www.geeksforgeeks.org/biconnected-components > run-main scalation.graphalytics.mutable.BiconnectedCompTest
-
object
BiconnectedCompTest2
extends App
The
BiconnectedCompTest2
object tests theBiconnectedComp
class.The
BiconnectedCompTest2
object tests theBiconnectedComp
class. See Figure 7.a in- See also
pluto.huji.ac.il/~galelidan/papers/ElidanGouldJMLR.pdf > run-main scalation.graphalytics.mutable.BiconnectedCompTest2
-
object
BoundedTreeWidthBNTest
extends App
The
BoundedTreeWidthBNTest
is used to test theBoundedTreeWidthBN
class.The
BoundedTreeWidthBNTest
is used to test theBoundedTreeWidthBN
class. > run-main scalation.graphalytics.mutable.BoundedTreeWidthBNTest -
object
BoundedTreeWidthChains
The
BoundedTreeWidthChains
object is used to find bounded tree width chains to add edges to a Bayesian Network graph. -
object
Cycle
The
Cycle
object provides a means for building a precedence/directed graph and checking it for cycles.The
Cycle
object provides a means for building a precedence/directed graph and checking it for cycles. For cycle detection, vertices are marked with traffic-light colors:- GreeN means go/unexplored,
- YelloW means caution/been there before,
- ReD mean stop/already fully explored.
-
object
CycleTest
extends App
The
CycleTest
object tests theCycle
class using a label-free precedence graph.The
CycleTest
object tests theCycle
class using a label-free precedence graph. Graphs are created by passing in an array of adjacency sets (one for each vertex). > run-main scalation.graphalytics.mutable.CycleTest -
object
DualIsoTest
extends App
The
DualIsoTest
object is used to test theDualIso
class.The
DualIsoTest
object is used to test theDualIso
class. > run-main scalation.graphalytics.mutable.DualIsoTest -
object
DualIsoTest2
extends App
The
DualIsoTest2
object is used to test theDualIso
class.The
DualIsoTest2
object is used to test theDualIso
class. > run-main scalation.graphalytics.mutable.DualIsoTest2 -
object
DualIsoTest3
extends App
The
DualIsoTest3
object is used to test theDualIso
class.The
DualIsoTest3
object is used to test theDualIso
class. > run-main scalation.graphalytics.mutable.DualIsoTest3 -
object
DualSimCARTest
extends App
The
DualSimCARTest
object is used to test theDualSimCAR
class.The
DualSimCARTest
object is used to test theDualSimCAR
class. > run-main scalation.graphalytics.mutable.DualSimCARTest -
object
DualSimCARTest2
extends App
The
DualSimCARTest2
object is used to test theDualSimCAR
class.The
DualSimCARTest2
object is used to test theDualSimCAR
class. > run-main scalation.graphalytics.mutable.DualSimCARTest2 -
object
DualSimTest
extends App
The
DualSimTest
object is used to test theDualSim
class.The
DualSimTest
object is used to test theDualSim
class. > run-main scalation.graphalytics.mutable.DualSimTest -
object
DualSimTest2
extends App
The
DualSimTest2
object is used to test theDualSim
class.The
DualSimTest2
object is used to test theDualSim
class. > run-main scalation.graphalytics.mutable.DualSimTest2 -
object
DualSimTest3
extends App
The
DualSimTest3
object is used to test the 'DualSim' class.The
DualSimTest3
object is used to test the 'DualSim' class. > run-main scalation.graphalytics.mutable.DualSimTest3 -
object
ExampleGraphD
The
ExampleGraphD
object contains example query and data digraphs in which the vertex label typeTLabel
isDouble
. -
object
ExampleGraphI
The
ExampleGraphI
object contains example query and data digraphs in which the vertex label typeTLabel
isInt
. -
object
ExampleGraphS
The
ExampleGraphS
object contains example query and data digraphs in which the vertex label typeTLabel
isString
. -
object
ExampleMGraphD
The
ExampleMGraphD
object contains example query and data multi-digraphs in which the vertex label typeTLabel
isDouble
. -
object
ExampleMGraphI
The
ExampleMGraphI
object contains example query and data multi-digraphs in which the vertex label typeTLabel
isInt
. -
object
ExampleMGraphS
The
ExampleMGraphS
object contains example query and data multi-digraphs in which the vertex label typeTLabel
isString
. -
object
Graph
The
Graph
companion object contains build methods and example query digraphs. -
object
GraphDFSTest
extends App
The
GraphDFSTest
is used to test theGraphDFS
class.The
GraphDFSTest
is used to test theGraphDFS
class. > run-main scalation.graphalytics.mutable.GraphDFSTest -
object
GraphGenTest
extends App
The
GraphGenTest
object is used to test theGraphGen
class for building random graphs where a vertex's degree is uniformly distributed.The
GraphGenTest
object is used to test theGraphGen
class for building random graphs where a vertex's degree is uniformly distributed. This work build graphs withInt
vertex labels. > run-main scalation.graphalytics.mutable.GraphGenTest -
object
GraphGenTest2
extends App
The
GraphGenTest2
object is used to test theGraphGen
class for building random graphs where a vertex's degree is uniformly distributed.The
GraphGenTest2
object is used to test theGraphGen
class for building random graphs where a vertex's degree is uniformly distributed. This work build graphs withDouble
vertex labels. > run-main scalation.graphalytics.mutable.GraphGenTest2 -
object
GraphGenTest3
extends App
The
GraphGenTest3
object is used to test theGraphGen
class for building random graphs where a vertex's degree is uniformly distributed.The
GraphGenTest3
object is used to test theGraphGen
class for building random graphs where a vertex's degree is uniformly distributed. This work build graphs withString
vertex labels. > run-main scalation.graphalytics.mutable.GraphGenTest3 -
object
GraphGenTest4
extends App
The
GraphGenTest4
object is used to test theGraphGen
class for building power law graphs.The
GraphGenTest4
object is used to test theGraphGen
class for building power law graphs. > run-main scalation.graphalytics.mutable.GraphGenTest4 -
object
GraphGenTest5
extends App
The
GraphGenTest5
object is used to test theGraphGen
class for extracting query graphs from data graphs.The
GraphGenTest5
object is used to test theGraphGen
class for extracting query graphs from data graphs. > run-main scalation.graphalytics.mutable.GraphGenTest5 -
object
GraphIO
extends Error
The
GraphIO
object is the companion object to theGraphIO
class and is used for reading digraphs from files. -
object
GraphIOTest
extends App
The
GraphIOTest
object is used to test theGraphIO
class and object.The
GraphIOTest
object is used to test theGraphIO
class and object. > run-main scalation.graphalytics.mutable.GraphIOTest -
object
GraphMetricsTest
extends App
The
GraphMetricsTest
object is used to test theGraphMetrics
class.The
GraphMetricsTest
object is used to test theGraphMetrics
class.- See also
http://math.stackexchange.com/questions/240556/radius-diameter-and-center-of-graph
-
object
GraphSimCARTest
extends App
The
GraphSimCARTest
object is used to test theGraphSimCAR
class.The
GraphSimCARTest
object is used to test theGraphSimCAR
class. > run-main scalation.graphalytics.GraphSimCARTest -
object
GraphSimCARTest2
extends App
The
GraphSimCARTest2
object is used to test theGraphSimCAR
class.The
GraphSimCARTest2
object is used to test theGraphSimCAR
class. > run-main scalation.graphalytics.GraphSimCARTest2 -
object
GraphSimTest
extends App
The
GraphSimTest
object is used to test theGraphSim
class.The
GraphSimTest
object is used to test theGraphSim
class. > run-main scalation.graphalytics.mutable.GraphSimTest -
object
GraphSimTest2
extends App
The
GraphSimTest2
object is used to test theGraphSim
class.The
GraphSimTest2
object is used to test theGraphSim
class. > run-main scalation.graphalytics.mutable.GraphSimTest2 -
object
GraphSimTest3
extends App
The
GraphSimTest3
object is used to test theGraphSim
class.The
GraphSimTest3
object is used to test theGraphSim
class. > run-main scalation.graphalytics.mutable.GraphSimTest3 -
object
GraphTest
extends App
The
GraphTest
object is used to test theGraph
class using example digraphs from theExampleGraphI
object, which contains graph whose vertex labels are of typeInt
.The
GraphTest
object is used to test theGraph
class using example digraphs from theExampleGraphI
object, which contains graph whose vertex labels are of typeInt
. > run-main scalation.graphalytics.mutable.GraphTest -
object
GraphTest2
extends App
The
GraphTest2
object is used to test theGraph
class using example digraphs from theExampleGraphD
object, which contains graph whose vertex labels are of typeDouble
.The
GraphTest2
object is used to test theGraph
class using example digraphs from theExampleGraphD
object, which contains graph whose vertex labels are of typeDouble
. > run-main scalation.graphalytics.mutable.GraphTest2 -
object
GraphTest3
extends App
The
GraphTest3
object is used to test theGraph
class using the digraphs given in theGraph
companion object.The
GraphTest3
object is used to test theGraph
class using the digraphs given in theGraph
companion object. > run-main scalation.graphalytics.mutable.GraphTest3 -
object
GraphTest4
extends App
The
GraphTest4
object is used to test theGraph
class using a randomly generated digraph.The
GraphTest4
object is used to test theGraph
class using a randomly generated digraph. > run-main scalation.graphalytics.mutable.GraphTest4 -
object
GraphTest5
extends App
The
GraphTest5
object is used to test theGraph
class by calling the apply in theGraph
companion object.The
GraphTest5
object is used to test theGraph
class by calling the apply in theGraph
companion object. > run-main scalation.graphalytics.mutable.GraphTest5 -
object
LabelFunctions
The
LabelFunctions
object provides methods for obtaining child and parents labels for the corresponding data and query graphs. -
object
MDualIsoTest
extends App
The
MDualIsoTest
object is used to test theMDualIso
class.The
MDualIsoTest
object is used to test theMDualIso
class. > run-main scalation.graphalytics.mutable.DualIsoTest -
object
MDualIsoTest2
extends App
The
MDualIsoTest2
object is used to test theMDualIso
class.The
MDualIsoTest2
object is used to test theMDualIso
class. > run-main scalation.graphalytics.mutable.DualIsoTest2 -
object
MDualIsoTest3
extends App
The
MDualIsoTest3
object is used to test theMDualIso
class.The
MDualIsoTest3
object is used to test theMDualIso
class. > run-main scalation.graphalytics.mutable.DualIsoTest3 -
object
MDualSimCARTest
extends App
The
MDualSimCARTest
object is used to test theMDualSimCAR
class.The
MDualSimCARTest
object is used to test theMDualSimCAR
class. > run-main scalation.graphalytics.mutable.MDualSimCARTest -
object
MDualSimCARTest2
extends App
The
MDualSimCARTest2
object is used to test theMDualSimCAR
class.The
MDualSimCARTest2
object is used to test theMDualSimCAR
class. > run-main scalation.graphalytics.mutable.MDualSimCARTest2 -
object
MDualSimTest
extends App
The
MDualSimTest
object is used to test theMDualSim
class.The
MDualSimTest
object is used to test theMDualSim
class. run-main scalation.graphalytics.mutable.MDualSimTest -
object
MDualSimWTest
extends App
The
MDualSimWTest
object is used to test theMDualSimW
class.The
MDualSimWTest
object is used to test theMDualSimW
class. run-main scalation.graphalytics.mutable.MDualSimWTest -
object
MGraph
The
MGraph
companion object provides builder methods and example query multi-digraphs. -
object
MGraphGenTest
extends App
The 'MGraphGenTest' object is used to test the 'MGraphGen' class for building random graphs where a vertex's degree is uniformly distributed.
The 'MGraphGenTest' object is used to test the 'MGraphGen' class for building random graphs where a vertex's degree is uniformly distributed. > run-main scalation.graphalytics.mutable.MGraphGenTest
-
object
MGraphGenTest2
extends App
The 'MGraphGenTest2' object is used to test the 'MGraphGen' class for building power law graphs.
The 'MGraphGenTest2' object is used to test the 'MGraphGen' class for building power law graphs. > run-main scalation.graphalytics.mutable.MGraphGenTest2
-
object
MGraphGenTest3
extends App
The
MGraphGenTest3
object is used to test theMGraphGen
class for extracting query graphs from data graphs.The
MGraphGenTest3
object is used to test theMGraphGen
class for extracting query graphs from data graphs. > run-main scalation.graphalytics.mutable.MGraphGenTest3 -
object
MGraphIO
extends Error
The
MGraphIO
object is the companion object to theMGraphIO
class and is used for reading graphs from files or graph databases. -
object
MGraphIOTest
extends App
The
MGraphIOTest
object is used to test theMGraphIO
class and object.The
MGraphIOTest
object is used to test theMGraphIO
class and object. > run-main scalation.graphalytics.mutable.MGraphIOTest -
object
MGraphSimCARTest
extends App
The
MGraphSimCARTest
object is used to test theMGraphSimCAR
class.The
MGraphSimCARTest
object is used to test theMGraphSimCAR
class. > run-main scalation.graphalytics.mutable.MGraphSimCARTest -
object
MGraphSimCARTest2
extends App
The
MGraphSimCARTest2
object is used to test theMGraphSimCAR
class.The
MGraphSimCARTest2
object is used to test theMGraphSimCAR
class. > run-main scalation.graphalytics.mutable.MGraphSimCARTest2 -
object
MGraphSimTest
extends App
The
MGraphSimTest
object is used to test theMGraphSim
class.The
MGraphSimTest
object is used to test theMGraphSim
class. > run-main scalation.graphalytics.mutable.MGraphSimTest -
object
MGraphTest
extends App
The
MGraphTest
object is used to test theMGraph
class using examples from theExampleMGraphI
object, which contains multi-digraphs whose vertex and edge labels are of typeInt
.The
MGraphTest
object is used to test theMGraph
class using examples from theExampleMGraphI
object, which contains multi-digraphs whose vertex and edge labels are of typeInt
. > run-main scalation.graphalytics.mutable.MGraphTest -
object
MGraphTest2
extends App
The
MGraphTest2
object is used to test theMGraph
class using examples from theExampleMGraphD
object, which contains multi-digraphs whose vertex and edge labels are of typeDouble
.The
MGraphTest2
object is used to test theMGraph
class using examples from theExampleMGraphD
object, which contains multi-digraphs whose vertex and edge labels are of typeDouble
. > run-main scalation.graphalytics.mutable.MGraphTest2 -
object
MGraphTest3
extends App
The
MGraphTest3
object is used to test theMGraph
class using a randomly generated multi-digraph.The
MGraphTest3
object is used to test theMGraph
class using a randomly generated multi-digraph. > run-main scalation.graphalytics.mutable.MGraphTest3 -
object
MStrictSimCARTest
extends App
The
MStrictSimCARTest
object is used to test theMStrictSimCAR
class.The
MStrictSimCARTest
object is used to test theMStrictSimCAR
class. > run-main scalation.graphalytics.mutable.MStrictSimCARTest -
object
MStrictSimCARTest2
extends App
The
MStrictSimCARTest2
object is used to test theMStrictSimCAR
class.The
MStrictSimCARTest2
object is used to test theMStrictSimCAR
class. > run-main scalation.graphalytics.mutable.MStrictSimCARTest2 -
object
MStrictSimTest
extends App
The
MStrictSimTest
object is used to test theMStrictSim
class.The
MStrictSimTest
object is used to test theMStrictSim
class. > run-main scalation.graphalytics.mutable.MStrictSimTest -
object
MStrictSimTest2
extends App
The
MStrictSimTest2
object is used to test theMStrictSim
class.The
MStrictSimTest2
object is used to test theMStrictSim
class. > run-main scalation.graphalytics.mutable.MStrictSimTest2 -
object
MStrictSimTest3
extends App
The
MStrictSimTest3
object test theMStrictSim
class by passing data graph and query graph relative file paths.The
MStrictSimTest3
object test theMStrictSim
class by passing data graph and query graph relative file paths. > run-main scalation.graphalytics.mutable.MStrictSimTest3 -
object
MTightSimCARTest
extends App
The
MTightSimCARTest
object is used to test theMTightSimCAR
class.The
MTightSimCARTest
object is used to test theMTightSimCAR
class. > run-main scalation.graphalytics.mutable.MTightSimCARTest -
object
MTightSimCARTest2
extends App
The
MTightSimCARTest2
object is used to test theMTightSimCAR
class.The
MTightSimCARTest2
object is used to test theMTightSimCAR
class. > run-main scalation.graphalytics.mutable.MTightSimCARTest2 -
object
MTightSimTest
extends App
The
MTightSimTest
object is used to test theMTightSim
class.The
MTightSimTest
object is used to test theMTightSim
class. > run-main scalation.graphalytics.mutable.MTightSimTest -
object
MTightSimTest2
extends App
The
MTightSimTest2
object is used to test theMTightSim
class.The
MTightSimTest2
object is used to test theMTightSim
class. > run-main scalation.graphalytics.mutable.MTightSimTest2 -
object
MTightSimTest3
extends App
The
MTightSimTest3
object test theMTightSim
class by passing data graph and query graph relative file paths.The
MTightSimTest3
object test theMTightSim
class by passing data graph and query graph relative file paths. > run-main scalation.graphalytics.mutable.MTightSimTest3 -
object
MinSpanningTreeTest
extends App
The
MinSpanningTreeTest
object is used to test theMinSpanningTree
class.The
MinSpanningTreeTest
object is used to test theMinSpanningTree
class. > run-main scalation.graphalytics.mutable.MinSpanningTreeTest -
object
MinSpanningTreeTest2
extends App
The
MinSpanningTreeTest2
object is used to test theMinSpanningTree
class.The
MinSpanningTreeTest2
object is used to test theMinSpanningTree
class.- See also
www.cse.ust.hk/~dekai/271/notes/L07/L07.pdf > run-main scalation.graphalytics.mutable.MinSpanningTreeTest2
-
object
MinSpanningTreeTest3
extends App
The
MinSpanningTreeTest3
object is used to test theMinSpanningTree
class.The
MinSpanningTreeTest3
object is used to test theMinSpanningTree
class. This test the Maximum Spanning Tree option.- See also
www.cse.ust.hk/~dekai/271/notes/L07/L07.pdf > run-main scalation.graphalytics.mutable.MinSpanningTreeTest3
-
object
PartitionTest
extends App
The
PartitionTest
object is used to test thePartition
class.The
PartitionTest
object is used to test thePartition
class. This test uses random partitioning. > run-main scalation.graphalytics.mutable.PartitionTest -
object
PartitionTest2
extends App
The
PartitionTest2
object is used to test thePartition
class.The
PartitionTest2
object is used to test thePartition
class. This test uses ordered partitioning. > run-main scalation.graphalytics.mutable.PartitionTest2 -
object
PartitionTest3
extends App
The
PartitionTest3
object is used to test thePartition
class.The
PartitionTest3
object is used to test thePartition
class. This test uses label propagation for partitioning. > run-main scalation.graphalytics.mutable.PartitionTest3 -
object
Query
extends Serializable
The
Query
companion object provides methods that work on triples. -
object
QueryTest
extends App
The
QueryTest
object is used to test theQuery
class.The
QueryTest
object is used to test theQuery
class. It converts a sequence of triples into a graph. > run-main scalation.graphalytics.mutable.QueryTest -
object
QueryTest2
extends App
The
QueryTest2
object is used to test theQuery
class.The
QueryTest2
object is used to test theQuery
class. It checks if variables or wildcards exist in a triple's labels. > run-main scalation.graphalytics.mutable.QueryTest2 -
object
QueryTest3
extends App
The
QueryTest3
object is used to test theQuery
class.The
QueryTest3
object is used to test theQuery
class. It converts a sequence of triples into a graph. > run-main scalation.graphalytics.mutable.QueryTest3 -
object
SSShortestPath
The
SSShortestPath
companion object provides factory methods for theSSShortestPath
class. -
object
SSShortestPathTest
extends App
The
SSShortestPathTest
object is used to test theSSShortestPath
class.The
SSShortestPathTest
object is used to test theSSShortestPath
class. Input is in the form of matrices (MatrixD
orSparseMatrixD
). > run-main scalation.graphalytics.mutable.SSShortestPathTest -
object
SSShortestPathTest2
extends App
The
SSShortestPathTest2
object is used to test theSSShortestPath
class.The
SSShortestPathTest2
object is used to test theSSShortestPath
class. Input is in the form of graphs (MGraph
).- See also
http://thescipub.com/PDF/jcssp.2013.377.382.pdf (Fig. 1) > run-main scalation.graphalytics.mutable.SSShortestPathTest2
-
object
SpanningTreeTest
extends App
The
SpanningTreeTest
object is used to test theSpanningTree
class.The
SpanningTreeTest
object is used to test theSpanningTree
class. > run-main scalation.graphalytics.mutable.SpanningTreeTest -
object
StrictSimCARTest
extends App
The
StrictSimCARTest
object is used to test theStrictSimCAR
class.The
StrictSimCARTest
object is used to test theStrictSimCAR
class. > run-main scalation.graphalytics.StrictSimCARTest -
object
StrictSimCARTest2
extends App
The
StrictSimCARTest2
object is used to test theStrictSimCAR
class.The
StrictSimCARTest2
object is used to test theStrictSimCAR
class. > run-main scalation.graphalytics.StrictSimCARTest2 -
object
StrictSimTest
extends App
The
StrictSimTest
object is used to test theStrictSim
class.The
StrictSimTest
object is used to test theStrictSim
class. > run-main scalation.graphalytics.mutable.StrictSimTest -
object
StrictSimTest2
extends App
The
StrictSimTest2
object is used to test theStrictSim
class.The
StrictSimTest2
object is used to test theStrictSim
class. > run-main scalation.graphalytics.mutable.StrictSimTest2 -
object
StrictSimTest3
extends App
The
StrictSimTest3
object test theStrictSim
class by passing data graph and query graph relative file paths.The
StrictSimTest3
object test theStrictSim
class by passing data graph and query graph relative file paths. > run-main scalation.graphalytics.mutable.StrictSimTest3 -
object
TightSimCARTest
extends App
The
TightSimCARTest
object is used to test theTightSimCAR
class.The
TightSimCARTest
object is used to test theTightSimCAR
class. > run-main scalation.graphalytics.mutable.TightSimCARTest -
object
TightSimCARTest2
extends App
The
TightSimCARTest2
object is used to test theTightSimCAR
class.The
TightSimCARTest2
object is used to test theTightSimCAR
class. > run-main scalation.graphalytics.mutable.TightSimCARTest2 -
object
TightSimTest
extends App
The
TightSimTest
object is used to test theTightSim
class.The
TightSimTest
object is used to test theTightSim
class. > run-main scalation.graphalytics.mutable.TightSimTest -
object
TightSimTest2
extends App
The
TightSimTest2
object is used to test theTightSim
class.The
TightSimTest2
object is used to test theTightSim
class. > run-main scalation.graphalytics.mutable.TightSimTest2 -
object
TightSimTest3
extends App
The
TightSimTest3
object test theTightSim
class by passing data graph and query graph relative file paths.The
TightSimTest3
object test theTightSim
class by passing data graph and query graph relative file paths. > run-main scalation.graphalytics.mutable.TightSimTest3 -
object
TopSort
The
TopSort
object provides the 'topSort' method for creating a topological sort of the vertices in a directed graph.The
TopSort
object provides the 'topSort' method for creating a topological sort of the vertices in a directed graph. It also perform cycle detection. -
object
TopSortTest
extends App
The
TopSortTest
object tests theTopSort
object using a directed graph.The
TopSortTest
object tests theTopSort
object using a directed graph. Graphs are created by passing in an array of adjacency sets (one for each vertex). > run-main scalation.graphalytics.mutable.TopSortTest


WE ARE CREATIVE
Digital Agency
We pride ourselves in great work ethic, integrity and providing end-results.
We pride ourselves in great work ethic, integrity and providing end-results.
We are deep group. Our company philosophy is to create the kind of website that most businesses want: easy to find, stylish and appealing, quick loading, mobile responsive and easy to buy from.
Trained as industrial designers we have a deep-rooted belief in rational function and sustainable aesthetics. Our methodical approach is focused on revealing the essence of each design challenge to allow us to create holistic and durable solutions.


Inline Sparkline: 1,4,4,7,5,9,10.
Sparkline with dynamic data: Loading..
Bar chart with dynamic data:
Bar chart with inline data:
Timeline chart with time marks: Loading..
Timeline chart without time marks:
Line chart: Loading..
Bar chart:
Tristate chart: Loading..
Bullet chart: Loading..
Discrete chart: Loading..
Pie chart: Loading..
Box chart: Loading..
Stack chart: Loading..
Line chart: Loading..
Bar chart:
Tristate chart: Loading..
Bullet chart: Loading..
Discrete chart: Loading..
Pie chart: Loading..
Box chart: Loading..
Stack chart: Loading..


Associates Degree
This is by far one of my proudest achievements yet. I went to Bard High School Early College Queens and this school is a very accelerated high school in which everyone completes their high school classes in 2 years and the last 2 years are spent taking college classes, by the conclusion of the program we graduated with an associates degree and a high school diploma.
Robot Design Project
I worked in a team of 4 people and we were tasked to build a robot from scratch with the Snappy XO kit the professor gave to us. I did all of the programming for the robot using an arduino uno microcontroller. I controlled the motors and the sensors to program the robot to perform its tasks.


13 December 2007
The Ministry of Health of Indonesia has announced a new case of human infection of H5N1 avian influenza. A 47-year-old male from Tangerang City, Banten Province developed symptoms on 2 December and was hospitalized on 9 December. The source of his exposure is currently under investigation.
Of the 115 cases confirmed to date in Indonesia, 92 have been fatal.


Times:
None submitted.
Best Time: DNF
Worst Time: DNF
Current Average of 5: DNF
Current Average of 12: DNF
Current Average of 100: DNF
Session Average: DNF
Session Mean: DNF
Welcome to MinimalisTimer - with a twist! Yes, this is an experimental styling of your favorite timer in Materialize. It does look different, huh?
Sadly, this version does not work offline for now. Sorry!


Clicking the button sends the ceiling back up to its original position. But after a few seconds, it begins to descend again, and none of the exits are reopening. What do you do?


Why You’re Here
So you know those talks where the person on stage has these hopeful messages filled with positivity?

And then offers you a small glimpse of hope.
From: "Computer Architecture: A Quantitative Approach, 6th Edition
So: Here is the last 40 years of single threaded performance improvemnets.
After a first happy couple of decades, at 2003, we’re start seeing an ever increasing
slowdown in this rate, even thogh transistor density has been doubling all the way
till 2015 until we reach our current time, which is the dark ages at 3.5% per year.
Now, no one knows for sure what the future holds,
But I think we can all agree that the present sucks.
Dennard observes that transistor dimensions are scaled by 30% (0.7x) every technology generation, thus reducing their area by 50%. This reduces the delay by 30% (0.7x) and therefore increases operating frequency by about 40% (1.4x). Finally, to keep the electric field constant, voltage is reduced by 30%, reducing energy by 65% and power (at 1.4x frequency) by 50%.[note 1] Therefore, in every technology generation the transistor density doubles, the circuit becomes 40% faster, and power consumption (with twice the number of transistors) stays the same.
Amdahl’s law can be formulated in the following way:
${\displaystyle S_{\text{latency}}(s)={\frac {1}{(1-p)+{\frac {p}{s}}}}}$
where:
$S_{\text{latency}}$ is the theoretical speedup of the execution of the whole task;
s is the speedup of the part of the task that benefits from improved system resources;
p is the proportion of execution time that the part benefiting from improved resources originally occupied.
"The reason processor performance is sub-linear with transistor count is [because] it's limited by unpredictability :
Branch predictability, Data-predictability, Instruction predictability."
Jim Keller
From: Moore’s Law is Not Dead
But I did say I also have some hope to offer you:
This is a quote by Jim Keller who is a famous CPU architecht,
Who gave this ironically titled talk: “Moore’s law is not dead”, where he says
that the reason for this slowdown, is unpredictability:
branch, data, and instrunction unpredictability.
So the flip-side of this, is my message of hope to you: that by providing the CPU with predictability
we can definitely improve our odds at running code faster, and a very effective
way of doing this is with intrinsics…
Branch Prediction
A single core executes hundreds of instructions at any given moment…
To do this, CPUs guess the target of branches!
It usually does a good job
But when it fails we get penalized
~15 cycles for a single mis-prediction!
A modern CPU is processing hundreds of instructions in some form or another
at any given moment.
To pull this crazy feat, it has to guess the result of the conditions in our code.
So every if, while etc. has to be predicted, for the CPU not to be out of work.
Normally, it can do a pretty good job at this.
But it can’t always be successful.
I magine that we feed it with purely random data.
It won’t do any better than flipping a coin.
Every time it fails, the penalty is huge: 15 cycles on a modern Intel CPU for example.
To make it worse, in many cases, the code behind that branch is 1-2 cycles long…
Now that I’ve got you scared motivated enough…
Let’s get busy!
So now that you're scared...
Intrinsics in English
A way to directly embed specific CPU instructions via special, fake method calls that the JIT replaces at code-generation time
What are these intrinsics we're going to fix the world with?
Simply speaking, intrinsics are fake functions we call in our code, that the JIT
will replace, for us, with a very specific 1-2 CPU instructions. So you can think of a
bit like writing assembly code through function calls…
But why do we need it?
Used to expose processor functionality that doesn’t map well to the language:
Atomic operations
System-Programming (e.g. kernel mode)
Crypto instructions
Niche instructions
Vectorization - Instructions that work on vectors
Traditionally, CPUs always had lot of functionality that can't be mapped easily
into our programming languages, There are about 1,200 intrinsics in Intel CPUs alone, and
they cover this entire gamut, but if we're honest, it all comes down to vectorization.
That's about 96% of those 1,200 on Intel CPUs!
Vectorization 101
Usually 1-3 CPU cycles!
Math is hard, let’s go sorting!
I needed to sort numbers, and really fast.
"Eh, I'll rewrite Array.Sort* .
QuickSort.
With intrinsics...
How bad could it be?"
6 months later, and I'm still at it...
But,
Let's go and sort some numbers!
So, a while back I decided I’d tackle a problem that both close to my heart
and my line of work…
I thought to my self, "I’ll re-write quicksort, or really Array.Sort, because they’re
very close to eachother. With intrinsics! I mean, really, how bad could it be?
So, that was 5 months ago! And I’m still having way too much fun with this…
But, I can share here something with you, thats…
Why QuickSort?
Universally known
Non-trivial use of intrinsics
Pretty close to Array.Sort
*
Now if you think you kind of remember how quicksort works, could you raise your hand and keep it up?
Great, now those of you who’ve implemented it, even if you were drunk and it was 20 years ago, can you keep you hand up?
OK!
So, as you can see, it’s universally known.
Also, as we’ll see, this will be a non-trivial use of intrinsics.
It’s not one of those "Let’s sum all the numbers in a array in 5 lines of code, then pat ourselves on the shoulder to say “good job” and move on…
And finally, as I’ve mentioned, our baseline for comparison isn’t something we copy-pasted from stack-overflow, it’s the actual
code we all rely on in the class libraries for .NET
Refresher
QuickSort uses a divide-and-conquer approach
Has average O(n log n ) comparisons for n items
Performs an in-place sort
So, a quick refresher about quicksort:
It uses a divide an conquer approach. So it’s recursive
Has n*log(n) comparisons to sort N items
And most importantly, it’s an in-place sort, so we don’t need to allocate more memory
to sort numbers.
This last point, as we’ll see, it great for users, but is going to haunt me…
Pick a pivot value
Partition the array around the pivot value
Recurse on the left side of the pivot
Recurse on the right side of the pivot
So in quicksort we:
Pick a pivot: which really means pick some number from the array. can really be anything
Re-arrange the array so that all the numbers on the left are smaller than the pivot,
Then we have the pivot, in its final resting place, and then all the numbers larger that
the pivot! This is really the big thing we will be working on, since other than that we simple:
Recurse on the left hand side of the new pivot position
And finally recurse on the right hand side.
It’s that simple!
int Partition(int[] array, int pivot, int left, int right)
{
while (left <= right) {
while (array[left] < pivot) left++;
while (array[right] > pivot) right--;
if (left <= right) {
var t = array[left];
array[left++] = array[right];
array[right--] = t;
}
}
return left;
}
Branches, Branches Everywhere!
👎 Unpredictable 👎
👍 Predictable 👍
Finally, before moving on to intrinsics: Here's the code for a pretty standard partition function.
We can see that it scan the array from left to right, comparing and swapping elements.
It’s easy to see there are 4 branches in this function.
But’s they’re not the same.
These two, are pretty horrible, as we’re branching based on actual, unsorted, so called random data
that we were tasked to sort… So these are pretty bad for the CPU to predict, if we remember our observation
about unpredictability!
On the other hand, these two branches are rather easy to predict, since they’re simply
true, 99% of the time.
By the numbers
Stat
100
1K
10K
100K
1M
10M
Max Depth
8
14
21
28
35
42
# Partitions
33
342
3,428
34,285
342,812
3,428,258
# Comparisons
422
6,559
89,198
1,128,145
13,698,171
155,534,152
I also collected some stats from running quick-sort,
And for example, for 1M elements, in this table you can see
how deep the recursion is, how many calls to the partition function there are
and how many comparisons are involved, and it's clear there is a lot of work involved here.
Plan
Redo Partition
with vectorized intrinsics.
What intrinsics do we use?
How do they work?
How?
How can an instruction operate on a vector?
Does it operate directly on memory?
Generally: No!
Vectors Types / Registers
These intructions operate on special vector types that are supported at the CPU level: registers
Vector registers have constant size (in bits).
All of these instruction accept and/or return special vector types, at the CPU level.
So really: registers!
The registers have a constant width in bits, let’s look at what’s there:
SIMD registers in CoreCLR 3.0
C# vectorized intrinsics accept and return these types:
Where T
is some primitive type.
So in CoreCLR, we have these 3 vector types: Vector 64, 128, and 256 of T.
These are special types recognized by the JIT, just like int or double are special.
Example:
Vector256<T>
can be:
byte / sbyte
⮚ 32 x 8b == 256b
short / ushort
⮚ 16 x 16b == 256b
int / uint
⮚ 8 x 32b
== 256b
long / ulong
⮚ 4 x 64b == 256b
float
⮚ 8 x 32b == 256b
double
⮚ 4 x 64b == 256b
Let's take 256 as an example, since we'll use it for the rest of the talk:
As you can see, we can use all these various primitive types instead of T, and then we get anywhere
from 32 down to 4 elements per such vector! But in all cases, we will end up with 256 bits in total
which is the size of the vector.
Vectorized Partition Block
We're going to partition 8 x int
s at a time
Load ⮚ Compare ⮚ Permute ⮚ Store
With no branching(!)
Now what?
mask
tells us which element goes where!
We could loop over the bits in the mask
Back to square one: 8-branches
I did not fly all the way to Moscow for this!
Famous Quote
Give me a lever long enough and a fulcrum on which to place it, and I shall move the world
- Synagoge, Book VIII, 340 A.D.
Less Famous Quote
Give me vectorized intrinsics and a large enough look-up table, and I can make anything 4x faster
- Intel Software Optimization Guide, 2003 A.D.
Permutation Tables
There are 256 possible mask values (28 )
We can precompute all permutations in a table
Each permutation entry will provide the correct order
for a given mask
The table is simply part of the source code
8-Way Permute
C#:
Vector256<int> data, perm;
Vector256<int> result = Avx2.PermuteVar8x32(data, perm);
asm:
vpermd ymm1, ymm2, ymm1 ; 3 cycle latency, 1 cycle throughput
There’s little to say here on the C#
Or the assembly
But this is a clear “one picture is worth 1000 words” type of situation.
static int[] PermTable => new[] {
0, 1, 2, 3, 4, 5, 6, 7, // 0 => 0b00000000
// ...
3, 4, 5, 6, 7, 0, 1, 2, // 7 => 0b00000111
// ...
0, 2, 4, 6, 1, 3, 5, 7, // 170 => 0b10101010
// ...
0, 1, 2, 3, 4, 5, 6, 7, // 255 => 0b11111111
};
Everything stays in place
Move 3 from left to right
4/4 split
var P = Vector256.Create(pivot);
...
var current = Avx2.LoadDquVector256(nextPtr);
var mask = (uint) Avx.MoveMask(
Avx2.CompareGreaterThan(current, P).AsSingle()));
current = Avx2.PermuteVar8x32(current,
LoadDquVector256(PermTablePtr + mask * 8));
Avx.Store(writeLeft, current);
Avx.Store(writeRight, current);
var popCount = PopCnt.PopCount(mask);
writeRight -= popCount;
writeLeft += 8 - popCount;
We generate a vectorized pivot, once per partition
Load 8 elements from somewhere.
Compare to pivot, cast to Vector256<float>
(because ¯\(ツ) /¯
)
Generate an 8-bit mask from the comparison result
Load permutation vector from table
Permute data (partition)
Store 8 elements to the left.
Store 8 elements to the right.
Count 1 bits ⮚ How many are elemenets are > than pivot.
Advance right by popCount.
Advance left by 8 - popCount.
8.5 cycle throughput
From the top:
We start with creating a vectorized pivot value, once per partition call
Somewhere, insdie a loop body we will shortly discuss, we continue to:
Load data
Compare it to the vectorized pivot 8-elements at a time
Compress the result back to a regular integer
Use that to load a pre-fabricate permutation entry! (which we will discuss)
Call the permutation intrinsic with our data and new order
Store all 8 elements to the left side
Store them again(!) to the right side
Call PopCount() to get the number of elements INSIDE our vector that belonged to the right!
Update the next write pointers using that pop count value!
OK, So now the vector is partitioned, what’s next?

We are going to read and partition 8 elements, at a time, within a vector256 inside the CPU!
Load, Compare, Permute, Write
But once we finish partitioning, we have, in our vector both elements larger and smaller,
So we write the resulting vector to BOTH sides of our original array!
We’ll see that in a moment, but let’s look at the code first
stackalloc to the rescue
We “cheat” just a bit: ¯\(ツ) /¯
stackalloc Vector256<int>[3]
Total temp memory: 96 bytes
Constant
No matter how much we sort
Yeah yeah, are we fast yet?
N,100,1K,10K,100K,1M,10M
ArraySort, 1 , 1 , 1, 1 , 1 , 1
AVX2DoublePumpedNaive, 1.149425287, 1.666666667, 1.724137931, 2.564102564, 2.702702703, 2.702702703,
What’s the Speed Limit?
There’s tons of stuff we could still do:
Inspect MSIL
Inspect asm code
Use HW counters
Vectorization Tweaks
Special code for small arrays
MSIL
C# compiler uses definite assignment analysis
CS0165: Use of unassigned local variable…
But tells JIT to initialize locals regardless
a.k.a .locals init
.method private hidebysig static int32*
VectorizedPartitionInPlace(
int32* left,
int32* right,
int32* tmp
) cil managed
{
.maxstack 3
.locals init (
[0] int32 pivot,
...
[22] int32 v,
[23] valuetype [System.Runtime]System.ReadOnlySpan`1<int32> V_23
)
Why?
5min hack
2-3% Improvement
Inspecting ASM
while (readRight >= readLeft) {
int *nextPtr;
if (readLeft - writeLeft <=
writeRight - readRight) {
nextPtr = readLeft;
readLeft += 8;
} else {
nextPtr = readRight;
readRight -= 8;
}
var current = Avx.LoadDquVector256(nextPtr);
//...
}
Anything left to partition?
Which side is closer to being overwritten?
Pick left
Pick right
We already saw the assmebly code for the vectorized block,
but what about the rest of the code around it?
ASM Code
mov rcx, rdi ; rdi -> readLeft
sub rcx, r12 ; r12 -> writeLeft
mov r8, rcx
sar r8, 0x3f
and r8, 0x3
add rcx, r8
sar rcx, 0x2
mov r9, rsi ; rsi -> writeRight
sub r9, r13 ; r13 -> readRight
mov r10, r9
sar r10, 0x3f
and r10, 0x3
add r9, r10
sar r9, 0x2
cmp rcx, r9
Load, Subtract…
Compare
What the…?
Look at all that arithmetic… Why?
The JIT is not optimizing the int
pointer math
when comparing differences ...
We can get past this!
Before:
if (readLeft - writeLeft <=
writeRight - readRight) {
// ...
} else {
// ...
}
After:
if ((byte *) readLeft - (byte *) writeLeft) <=
(byte *) writeRight - (byte *) readRight)) {
// ...
} else {
// ...
}
Much better
mov rcx, rdi ; rdi -> readLeft
sub rcx, r12 ; r12 -> writeLeft
mov r9, rsi ; rsi -> writeRight
sub r9, r13 ; r13 -> readRight
cmp rcx, r9
Ugly, But Effective
6-9% Improvement!
HW Counters
CPUs have HW counters that give stats!
$ perf stat -a --topdown ...
Performance counter stats for 'system wide':
retiring bad speculation frontend bound backend bound
S0-C3 1 37.6% 37.3% 16.9% 13.2%
Almost 40% of all branches are mis-predicted
Bad Speculation is Bad
That “pick a side” logic is super bad for perf
We snuck in branch unpredictability!
100% random data ⮚ Flip a coin
Every mis-prediction costs us 15 cycles
Remember our block is 8 cycles!
We’re doing nothing 50% of the time!
Branch ⮚ Arithmetic
What if we can make the CPU run the same code, for both branches?
Turn the branch into a data dependency!
Before:
int x, y;
if (x > y) {
ptr += 8;
}
After:
int x, y;
// + => 0, - => 0xFFFFFFFF
var condAsMask = (y - x) >> 31;
//Always perform the addition, sometimes with 0!
ptr += 8 & condAsMask;
Poor-man’s CMOV
This is a age-old technique of replacing badly speculated branches
with simple arithmetic.
It only works for simple branches.
CoreCLR will hopefully learn to cmov
in the future.
Unroll the code
Change the ratio between work/branches predicted
CPU prediction will continue to suck
But once every N partitioning operations
We need to allocate more temporary space:
2*N*Vector256<int>
2*4*8*4 == 256 bytes
while (readRight >= readLeft) {
int *nextPtr;
if (readLeft - writeLeft <=
writeRight - readRight) {
nextPtr = readLeft;
readLeft += 8*4;
} else {
nextPtr = readRight;
readRight -= 8*4;
}
var L0 = LoadDquVector256(nextPtr + 0*8);
var L1 = LoadDquVector256(nextPtr + 1*8);
var L2 = LoadDquVector256(nextPtr + 2*8);
var L3 = LoadDquVector256(nextPtr + 3*8);
var m0 = (uint) MoveMask(CompareGreaterThan(L0, P).AsSingle());
var m1 = (uint) MoveMask(CompareGreaterThan(L1, P).AsSingle());
var m2 = (uint) MoveMask(CompareGreaterThan(L2, P).AsSingle());
var m3 = (uint) MoveMask(CompareGreaterThan(L3, P).AsSingle());
L0 = PermuteVar8x32(L0, GetIntPermutation(pBase, m0));
L1 = PermuteVar8x32(L1, GetIntPermutation(pBase, m1));
L2 = PermuteVar8x32(L2, GetIntPermutation(pBase, m2));
L3 = PermuteVar8x32(L3, GetIntPermutation(pBase, m3));
var pc0 = PopCount(m0);
var pc1 = PopCount(m1);
var pc2 = PopCount(m2);
var pc3 = PopCount(m3);
Store(writeRight, L0);
writeRight -= pc0;
Store(writeRight, L1);
writeRight -= pc1;
Store(writeRight, L2);
writeRight -= pc2;
Store(writeRight, L3);
writeRight -= pc3;
pc0 = 8 - pc0;
pc1 = 8 - pc1;
pc2 = 8 - pc2;
pc3 = 8 - pc3;
Store(writeLeft, L0);
writeLeft += pc0);
Store(writeLeft, L1);
writeLeft += pc1);
Store(writeLeft, L2);
writeLeft += pc2);
Store(writeLeft, L3);
writeLeft += pc3);
}
Can you spot the difference?
Load x4
Compare+MoveMask x4
Permute x4
PopCount x4
Store on the right x4
8 - PopCount x4
Store Left x4
Show me the money!
Do we have less branch mis-predictions now?
Not really!
(Not in percent)
But less branches in total
Does it run faster though?
Sure Does!
20-30% Improvement!

But what are we fixing?
The Remainder problem
All vectorized code needs to deal with remainders.
length % 8 != 0
Between 1-7 elements, handled with pure scalar code!
Cacheline Boundaries
When reading memory, we really read from cache.
Single int ⮚ full cacheline: 64 bytes
What if our data is across two cachelines?
The CPU needs to ask for 2(!) cache-lines
Alignment
Normally, we shouldn’t care!
The JIT & allocator work to minimize this!
“Stuff” is aligned to pointer size: 4/8 bytes
When not: 4 ⁄64 ⮚ 6.25% rate
of cross-cacheline reads
But what about Vector256? (32-bytes)
Is this true for partitioning?
No love!
Not a single pointer is naturally aligned to Vector256.
With partitioning, the data dictates the alignment
50% of our reads are reading 2 cachelines!!!
Two birds, one stone
Let’s fix both of these issues!
By doing more work!
The safe approach is to align inward
Align with scalar code
No more remainder at the end
But this means more scalar work:
1-7 elements on each side!
But what if we align outwards?
It’s legal (But not trivial!)
100% vectorized* !!!
Totally worth it!
10%-20% improvement
* When in cache
Small array sorting
Another common trick is to sort very small partitions directly without quicksort.
Array.Sort uses this.
Can we? With Vectors?
Yes we can!
Bitonic Sort
Parallel Sorting Algorithm
O(n * log2 (n)) comparisons
Generates 2 monotonic series
Increasing/Decreasing
Bitonic
No branches
Final Speedup
N,100,1K,10K,100K,1M,10M
ArraySort, 1 , 1 , 1, 1 , 1 , 1
AVX2DoublePumpedOverlinedUnrolledWithBitonicSort, 2.04, 4.80, 7.67, 8.73, 9.02, 8.93,
In summary
We can and should re-approach even on age old problems to find ways
to increase the predictablity of our code by using instrinsics!
This is now available to us in C#/.NET as part of CoreCLR 3.0.
Be nice to your CPUs!
Also, while I could not possible show it in this talk, there are many more optimizations
that I ended up , and probably more in the future all had to do with fighting this
monster that is hiding in plain sight insid our code.


Package fitTetra contains three functions that can be used to assign genotypes to a collection of tetraploid samples based on bialleleic marker assays. Functions fitTetra (to fit several models for one marker from the data and select the best fitting) or saveMarkerModels (calls fitTetra for multiple markers and saves the results to files) will probably be the most convenient to use. Function CodomMarker offers more control and fits one specified model for a given marker.
| Version: | 1.0 |
| Depends: | R (≥ 2.10) |
| Suggests: | doMC, foreach, RSvgDevice, devEMF |
| Published: | 2013-05-28 |
| Author: | Roeland Voorrips and Gerrit Gort |
| Maintainer: | Gerrit Gort <gerrit.gort at wur.nl> |
| License: | GPL (≥ 2.2) |
| NeedsCompilation: | no |
| CRAN checks: | fitTetra results |
| Reference manual: | fitTetra.pdf |
| Package source: | fitTetra_1.0.tar.gz |
| Windows binaries: | r-devel: fitTetra_1.0.zip, r-release: fitTetra_1.0.zip, r-oldrel: fitTetra_1.0.zip |
| OS X binaries: | r-release: fitTetra_1.0.tgz, r-oldrel: fitTetra_1.0.tgz |
Please use the canonical form https://CRAN.R-project.org/package=fitTetra to link to this page.


Mongolduu NextGen Mobile App for Android
Android Developer:
Tuguldur Erdene-Ochir [ Tugstugi ] -<EMAIL_ADDRESS>Artwork & Design Contributors:
Server & Media Development:
Khundaga Khurelbaatar [Hundaga] -<EMAIL_ADDRESS>www.twitter.com/hundaga
Asuult.NET ©2000-2011.
Copyright & Music catalog questions please check the www.Mongolduu.com website.
Under the DMCA (Digital Millenium Copyright Act), if your music is in our catalog without your permission and you would like to have it removed, please contact us and we will gladly to do so. Most artists send their new/old music to us to increase their visibility and popularity among the Mongolian music lovers around the world. We do NOT put new album music that is currently still on sale in Mongolia, unless the artist/studio has released it already for promotional purpose in public domain. We look forward to working with every Mongolian creative people to make our music industry a better place for artists, studios and consumers.
Contact: Uilchilgee@asuult.net


PropertyPro-Lite is the leading real estate property center platform in Nigeria. with a web-based platform for property retails and sales. We provide user with the best property search experience both online and offline by connecting them with legitimate and verified real estate agents.


A leader who don't leave others behind.
A leader who bring others with you side by side.
A leader whose behind the shadow.
A leader who make sure the lights will stay on for others.
A leader who always want best for others.


--- layout: page title: About Me description: This is what I do. background: '//img/main-images/squigglyline.png' ---
You know that "inspirational" graphic about success that looks, essentially, like a squiggly pile of yarn? That's my life.
I was an artist that got into technical theater as a kid. In undergrad, I went in thinking I would get a degree in computer science and left it with a degree in biology. I started my career out in biotech, and now I find myself in a completely unrelated industry - working on machine learning.
If you have any questions about me that aren't answered by this site, please feel free to reach out.
Focused bioinformatic coursework, including genomic analyses and regulatory affairs.
Minor in chemistry; coursework specializing in infectious disease and natural product drug discovery.
Deskins, CE. et al. Phytochemical Investigations of Lonchocarpus Bark Extracts from Monteverde, Costa Rica. Natural Product Communications. April 2014. doi:10.1177/1934578X1400900421
Dickinson, G.S., et al. IL-7 Enables Antibody Responses to Bacterial Polysaccharides by Promoting B Cell Receptor Diversity. The Journal of Immunology August 15, 2018, 201 (4) 1229-1240; DOI: 10.4049/jimmunol.1800162


"Watch the bikes!" Extreme Feedback with Traffic Lights
We have a lot of fun with our team at Ericsson Backnang (Germany) using these nice Traffic Lights as feedback device for our hudson builds.
See the movie
Get the code
There is a kenai project with the code we use: hudson efd control
Thanks
Special thanks to Simon Wiest for the inspiration.
Also many thanks to Maurice Link for his mechanical and electrical knowledge.
And finally to my team at Ericsson Backnang for the support of this project.
Hartmut Lang
Attachments:
trafficLights2.jpg (image/jpeg)


Resident Evil 7: Biohazard is a survival horror game that has been rumored to make some people wet themselves. The game was developed by Capcom, and realeased in January 2017. This is the eleventh installment in the Resident Evil series. It is the first to be played from a first-person perspective and be compatible with the Playstation VR (Virtual Reality).


This section of my site will contain coding notes and observations on the Golang(Go) programming language and some C. GO is mainly my focus but I like to sprinkle some 'C' in there dependent on time. I find that looking and coding GO & C exercises the muscles I have that seem to get weak from sitting on the ROR couch all day. Also is in keeping with my belief that reviewing multiple languages is always a benefit to the main language you happen be focused on. You see coding approaches/idea's that open you mind a bit.
The C Programming Language
I have come across references to The C programming language many times in my career...in the following sense..I see constructs in java or C# or javascript or python or ruby or perl...Swift/objective C...just about any language..and they all show their roots in C. If fact even the operating systems of the IBM platforms i used to work on were written in C/C++. Most open source languages have libraries underneath which came from C.
The GO(golang) Programming Language
GO was created by a few of the guys who created C as sort of a replacement. At Google Robert Griesemer, Rob Pike, and Ken Thompson were attempting to create a language for modern systems programming that solved real -world problems they encountered while building large systems at scale.
Some interesting things about GO:
Go-Go Gophers
- It has a built in package system
- It has a built in tools for testing, documentation and a code-formatter.
- Natively supports multiple function return values with out some type of hacking
- Concurrency with goroutines and channels
- GO has a built in webserver since it does not need one to do the multi-threading among other things.


Product name:
Product price:
Product category:
Product weight:
Product volume:
Product quantityInStock:


Cohabitat is a free, cross-platform app that heps you sort out your household tasks in your co-living household, so that you can focus on the more important task:
"Enjoy my dream Co-live Experience with COHABITAT!"
"With COHABITAT, share house life have never been easier before!"
"Thanks COHABITAT for providing one-site application solution to us!"
Ready to get started? Sign up for our newsletter now!


matches
/matchesSelector
is pretty hot :fire:, but has
vendor-prefix baggage :handbag: :pouch:. This helper function takes care of that, without augmenting Element.prototype
.
matchesSelector( elem, selector );
matchesSelector( myElem, 'div.my-hawt-selector' );
// this DOES NOT polyfill myElem.matchesSelector
Download matches-selector.js
Install with Bower: bower install matches-selector
Install with npm: npm install desandro-matches-selector
Install with Component: component install desandro/matches-selector
matchesSelector is released under the MIT license


GETTING STARTED
A stepper is a fundamental part of material design guidelines. It makes forms simplier and a lot of other stuffs.
Unfortunately, one of the best material design front-end frameworks we have today, Materilizecss, doesn't have an implemented stepper. So I decided to create one.
Here you going to find some demos and some code, but you can find the full documentation on GitHub.
I hope you like and help me improve it.
PREREQUISITES
Since it's an implementation to Materializecss framework, you'll need it. If you want the stepper to verify required inputs, you'll need jQuery Validation Plugin, but it's optional since 2.0.1:
- jQuery (obviously)
- Materializecss framework
- Google Material Icons
- jQuery Validation Plugin (optional)
INSTALLING
You just need to import the .css and the .js files after you import the prerequisites listed above:

<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/materialize/0.98.0/css/materialize.min.css">

<link href="http://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">

<link rel="stylesheet" href="materialize-stepper.min.css">

Linear Stepper
-
Step 1
-
Step 2
-
Step 3Finish!
Linear Stepper is the most common one. In it, you can't navigate freely between steps. It's step by step, obeying the validation ruled by the required inputs (if you're using jQuery Validation Plugin).
Example:

...

Non-Linear Stepper
-
Step 1
-
Step 2
-
Step 3Finish!
In the Non-Linear Stepper you can navigate freely between steps. You can also use the buttons for validation (if you're using jQuery Validation Plugin), but if the user wants to move arbitrarily around the steps, it's allowed by clicking on the steps instead of the buttons.
Example:

...

Horizontal Stepper
There is a horizontal version now (since 2.0). All the options above listed is working with it. And since version 2.1 horizontal steppers are responsive and turns to vertical from 992px (width) down:
To use it, you just need to add a ".horizontal" class to your primary "ul" tag:
Example:

...

-
Step 1
-
Step 2
-
Step 3Finish!
Feedback Step
-
Step 1
-
Step 2
-
Step 3Finish!
If you want, for example, to check if an e-mail exists in your DB, you can define a feedback function with data-feedback attribute in your next button.
When the user try to move forward, a loading screen will overlay the active step until you trigger .nextStep manually.
Example:

Changelog
To get the change log, visit CHANGELOG.md page.
Ps: date format: d/m/y
Credits
Stepper is a plugin created by me, Igor Marcossi, inspired in MDL Stepper, a more powerful one that implements the same thing on Material Design Lite framework.


| | Mutations |
| 27 |
|
1.1 Location : main Killed by : none removed call to se/lnu/http/HTTPServerConsole::runConsole → NO_COVERAGE
|
| 39 |
|
1.1 Location : runConsole Killed by : se.lnu.http.HTTPServerConsoleTest.testrunConsolePort80(se.lnu.http.HTTPServerConsoleTest) removed call to se/lnu/http/HTTPServer::start → KILLED
|
| 42 |
|
1.1 Location : runConsole Killed by : none negated conditional → TIMED_OUT
|
| 43 |
|
1.1 Location : runConsole Killed by : se.lnu.http.HTTPServerConsoleTest.testrunConsolePort80(se.lnu.http.HTTPServerConsoleTest) removed call to se/lnu/http/HTTPServer::stop → KILLED
|
| 49 |
|
1.1 Location : runConsole Killed by : se.lnu.http.HTTPServerConsoleTest.testrunConsoleNoPort(se.lnu.http.HTTPServerConsoleTest) removed call to se/lnu/http/view/ConsoleView::showhelp → KILLED
|
| 51 |
|
1.1 Location : runConsole Killed by : se.lnu.http.HTTPServerConsoleTest.runOnTakenPort(se.lnu.http.HTTPServerConsoleTest) removed call to se/lnu/http/view/ConsoleView::showPortTaken → KILLED
|


Anytime you learn something your time and energy are not wasted. We'll make some happy little bushes here. Just let these leaves jump off the brush pressure. Just relax and watch it happen.
Talent is a pursued interest. That is to say, anything you practice you can do. When things happen - enjoy them. They're little gifts. Mountains are so simple, they're hard. We don't have to be committed. We are just playing here. Just relax and let it flow. That easy.
Water's like me. It's laaazy ... Boy, it always looks for the easiest way to do things There we go. Put light against light - you have nothing. Put dark against dark - you have nothing. It's the contrast of light and dark that each give the other one meaning.
We tell people sometimes: we're like drug dealers, come into town and get everybody absolutely addicted to painting. It doesn't take much to get you addicted. Volunteering your time; it pays you and your whole community fantastic dividends. Let's have a little bit of fun today. The only prerequisite is that it makes you happy. If it makes you happy then it's good. Zip. That easy.


| Design and Implementation of a validating XML parser in Haskell: Master's thesis; University of Applied Sciences Wedel | ||
|---|---|---|
| Prev | Chapter 5. Conclusion | Next |
The developed XML parser shows that the functional approach accomplishes the task of parsing and validating XML by using fewer lines of code and producing a very short and compact program in contrast to imperative languages. The packages hdom, hparser and hvalidator contain only about 9.000 lines of code including lots of HDoc [WWW30] comments.
Although the program is compact, the code is understandable and maintainable, because the code is more succinct and it follows a clear and simple design. The Haskell XML Toolbox introduced the very general tree data type XmlTree for representing whole XML documents in Haskell. This general data model makes it possible to base all processings of XML documents on filters. The whole XML parser, presented in this thesis, bases on this uniform design.
Writing a validating XML parser is a quite complex task. It must cope with different encodings, correct processing of entities and of course validation. Functional programming helps master this complexity better than other methods.
In Haskell functions are just values and have no side effects. These qualities allow an easy use of higher-order functions that take functions as arguments, return functions as a result or do both. The filter combinators, which have been adopted from HaXml, form a powerful library for combining filter functions. Because all filters of the Haskell XML Toolbox share the same type, it is possible to combine them freely with the use of filter combinators. All details of manipulating the XmlTree data structure are hidden in these higher-order functions. In effect these filter combinators define problem specific control structures that make it possible to program on a very high abstraction level. Errors can be reduced, because programmers can use the filter combinators as standard functions for processing the XmlTree.
Because functions are just values in Haskell, they can be constructed at runtime. The XML parser introduced in this thesis makes an extensive use of creating parameterized filter functions during runtime. The whole validation process bases on this design.
It can be quite useful to use functional programming paradigms when writing programs in imperative languages. Functional paradigms like higher-order functions for abstractions can be done in Java by defining an interface that has only one function. This interface can be passed to other functions or returned by a function. In C function pointers can be used for this task. But imperative languages are not designed to support functional programming styles, so they cannot actively support its paradigms. The main focus of these languages lies on the fact how a problem is solved, e.g. the order in which computations are performed.
Unfortunately functional programming and functional programming languages are not very popular. Two standard examples for functional programming are using a spreadsheet program like Excel and querying a database with SQL. Another field where functional programming dominates is transformation of SGML and XML documents. The Document Style Semantics and Specification Language (DSSSL) [WWW09] bases on the functional programming language Scheme and is very popular in the world of SGML publishing. The Extensible Stylesheet Language (XSL) [WWW07] is its corresponding part for XML publishing. Functional programming languages are very well equipped for this task, because the transformation process is a functional mapping from a structural document as input to a formatted representation as output.
Sometimes it is said that functional programming languages lack of libraries. We do not know any validating XML Parser written in Haskell and hope that the framework of the Haskell XML Toolbox will be a useful tool for XML processing applications written in Haskell. The parser supports almost fully the XML 1.0 specification with the exception of namespaces.
The Haskell XML Toolbox introduces a powerful approach for processing XML in Haskell. It generalizes the ideas of HaXml and HXML. Whole XML documents are represented as a tree of different nodes. This tree can be processed in a uniform way by using filter functions and filter combinators.
Lots of great ideas of the projects HaXml and HXML have been taken into this project. We want to thank their members for their great work and emphasis that all three projects are enrichments for the Haskell community.
The Haskell XML Toolbox project will be maintained and enlarged at the University of Applied Sciences Wedel. One student already wrote an XSLT processor on the basis of this project. Another student is writing a program using the Haskell XML Toolbox for deriving Java classes from DTDs.


Music
18 APR, 2020
Fusce Varius Risus
Sample text, I don't know what I'm going to fill this in with yet. I am just putting in these words though temporarily in order to get a feel for how large the paragraph will look. Am I doing this properly? I dont know, probably not, but it seems the more I ramble on in this paragraph the more likely I am to get a better image of how this will look realistically
Sample text, I don't know what I'm going to fill this in with yet. I am just putting in these words though temporarily in order to get a feel for how large the paragraph will look. Am I doing this properly? I dont know, probably not, but it seems the more I ramble on in this paragraph the more likely I am to get a better image of how this will look realistically
Sample text, I don't know what I'm going to fill this in with yet. I am just putting in these words though temporarily in order to get a feel for how large the paragraph will look. Am I doing this properly? I dont know, probably not, but it seems the more I ramble on in this paragraph the more likely I am to get a better image of how this will look realistically
Sample text, I don't know what I'm going to fill this in with yet. I am just putting in these words though temporarily in order to get a feel for how large the paragraph will look. Am I doing this properly? I dont know, probably not, but it seems the more I ramble on in this paragraph the more likely I am to get a better image of how this will look realistically
Sample text, I don't know what I'm going to fill this in with yet. I am just putting in these words though temporarily in order to get a feel for how large the paragraph will look. Am I doing this properly? I dont know, probably not, but it seems the more I ramble on in this paragraph the more likely I am to get a better image of how this will look realistically
Sample text, I don't know what I'm going to fill this in with yet. I am just putting in these words though temporarily in order to get a feel for how large the paragraph will look. Am I doing this properly? I dont know, probably not, but it seems the more I ramble on in this paragraph the more likely I am to get a better image of how this will look realistically
Sample text, I don't know what I'm going to fill this in with yet. I am just putting in these words though temporarily in order to get a feel for how large the paragraph will look. Am I doing this properly? I dont know, probably not, but it seems the more I ramble on in this paragraph the more likely I am to get a better image of how this will look realistically
Sample text, I don't know what I'm going to fill this in with yet. I am just putting in these words though temporarily in order to get a feel for how large the paragraph will look. Am I doing this properly? I dont know, probably not, but it seems the more I ramble on in this paragraph the more likely I am to get a better image of how this will look realistically


active-network
Businessmodel of Active Network
Customer Segments
Active Network provides a range of software-as-a-service solutions to a range of commercial and institutional clients, primarily those involved in the organisation of physical recreation and sporting activities. The Company can organises its clients broadly into the following categories:
- Consumers, comprising general consumers who have an interest in sports and exercise;
- Sports and Recreation, comprising community centres, non-profits, government bodies, and commercial operators that organise and manage sporting activities and leagues and community events;
- Ski and Attraction operators, comprising commercial operators of skiing and other sporting attractions;
- Race Events, comprising non-profits, community organisations, and sporting bodies that organise and operate race events;
- Camps, comprising dedicated camp operators and community organisations; and
- Education, comprising music and arts education organisations and institutions to which the Company offers software to streamline class registrations. Active Network lists a number of its clients on its website, including Notre Dame Sport Camp, YMCA Metro Los Angeles, Granite School District, Vineman Ironman, Bayside Broncos Pop Warner, and Sedona Arts Centre.
Active Network serves an international client base across markets North America, Europe, Asia Pacific, and Africa.
Value Propositions
Active Network provides value to its clients in the following ways:
- Its industry standing and reputation, with the Company established as a leading provider of software solutions for sporting and recreational event operators, as well as offering some of the most popular fitness apps for mobile device users;
- Its varied portfolio of products and solutions, with the Company offering a broad range of management and administrative software solutions – including dedicated race management and event management products – as well as mobile apps, and digital media and advertising services;
- Its international reach, with the Company offering its products and services to customers across North America, Europe, Asia Pacific, and Africa, maintaining operations in Hong Kong, South Africa, Canada, the UK, and Singapore; and
- Its accessibility and flexibility, with the Company offering a range of flexible and scalable software solutions that are easily accessible to clients via the Company’s cloud-based platform. ### Channels
Active Network operates a website at www.activenetwork.com, through which it provides information on its various solutions, product offerings, and international operations. While the Company does not operate an online sales portal, its enables customers to register an interest in particular solutions through an online contact form.
Once software solutions have been purchased, customers can access them online through the Company’s cloud-based platform. Active Network also offers a number of mobile apps that can be downloaded by customers via the iOS App Store and the Google Play Store.
Active Network makes its sales primarily through its in-house direct sales force, which is organised geographically. The Company’s sales personnel operate out of the Company’s international network of sales and administrative offices across North America, Asia Pacific, Europe, and Africa, including locations in Singapore, Hong Kong, South Africa, Germany, Canada, the US, the UK, and Australia.
Active Network additionally markets its products and solutions through a network of affiliates. The Company, however, does not appear to utilise the services of third party resellers or distributors.
Customer Relationships
Active Network does not sell its software solutions to clients on a self-service basis. Once purchased, however, customers able to utilise the functionality of the Company’s products independently without further interaction with sales and service personnel. In contrast, the Company’s consumer-focused mobile applications can be downloaded on self-service basis through the iOS App Store and the Google Play Store.
Active Network offers a more personalised service to its commercial clients through its in-house sales force. These direct sales personnel consult closely with clients in order to ensure that they are offered the right solutions that are scaled specifically to fit their individual needs and circumstances, tailoring their solutions where possible. The Company seeks to establish longstanding relationships and recurring business from its clients.
Active Network offers ongoing support services, with clients able to contact the Company over the phone and online in order to receive personalised assistance. The Company also offers a range of online resources – including tutorials, user guides, case studies, and articles – which can be accessed independently.
Additionally, Active Network operates social media accounts with Twitter, YouTube, Google+, Facebook, and LinkedIn, through which it is able to publish company updates and interact directly with clients.
Key Activities
Active Network provides a range of cloud-based activity and participant management, and registration software solutions to a range of commercial and institutional clients, including non-profits, camps, government bodies, race event organisers, and commercial entities.
These products are designed to increase event management efficiency and connect activity and event organisers with participants worldwide. Active Network also offers a range of digital media and advertising solutions, and is engaged in the development and provision of fitness and exercise management apps, including the popular Couch to 5K, 5K to 10K, LivePass, and Meet Mobile.
Active Network serves an international client base, maintaining an operational presence across markets in North America, Asia Pacific, Europe, and Africa.
Key Partners
Active Network works in conjunction with a range of companies and organisations throughout the development and delivery of its products and solutions. These partners can be organised broadly into the following categories:
- Supplier and Vendor Partners, comprising suppliers of technologies, services, and equipment that support the Company’s development and implementation of software solutions, as well as vendors to which certain functions can be outsourced;
- Sports and Development Partners, comprising a range of sports and recreational organisations with which the Company collaborates on the development of effective management software solutions;
- Affiliate and Marketing Partners, comprising a range of websites and online businesses that promote the Company’s products and solutions and drive traffic to the Company’s website in return for commissions; and
- Strategic and Alliance Partners, comprising a range of market leading companies with which the Company works on joint marketing, branding, and development projects. Active Network has a number of partnerships in place. This includes a technology partnership with USA Triathlon, a delivery partnership with Red Frog Events, and a strategic partnership with RaceHQ.
Key Resources
Active Network’s key resources are its intellectual properties and proprietary technologies, its products and solutions, its IT and communications infrastructure, its sales and marketing channels, its partnerships, and its personnel.
Active Network utilises a range of proprietary technologies in its products and solutions. Searches of records published by the US Patent and Trademark Office identified a number of patent applications in which Active Network is named as applicant or assignee, including applications entitled ‘Enterprise wireless device usage reporting’, ‘Limiting data exposure in authenticated multi-system transactions’ and ‘Systems and methods for augmented reality’.
Active Network additionally owns and or leases a number of physical properties around the world that comprise the Company’s international network of offices.
Cost Structure
Active Network incurs costs in relation to the development of its technologies and solutions, the maintenance of its IT and communications infrastructure, the procurement of professional services, the operation of its sales and distribution channels, the implementation of marketing and advertising campaigns, and the retention of its personnel.
Revenue Streams
Active Network generates revenue through the development and provision of various management and registration software solutions targeted at companies and organisations active in the fitness, sports, and recreational fields. The Company also derives revenue through the provision of various digital media and advertising services.
Active Network is a privately-owned company and is not obliged to publish its financial results online. As such, the Company’s recent revenue figures are unclear. Reports from 2015 suggest that the Company generates annual revenue in the region of around $400 million.


US synagogue bomb plot | Macron and Xi meet: WATCH the top world news videos for today
Colorado man charged in synagogue bomb plot
Officials say a man who repeatedly espoused anti-Semitic views has been arrested in a plot to bomb a historic Colorado synagogue.
Macron and Xi meet in Shanghai
French president Emmanuel Macron arrives at the China International Import Expo in Shanghai, where he is greeted by his Chinese counterpart Xi Jinping.
Lebanon protests rage on as politicians stall
Demonstrators in Lebanon keep up the pressure on the government as they gather for a huge protest in the northern city of Tripoli.
Man bashed in police bathroom
Supplied footage obtained on November 5, 2019 of a detainee in a police watch house confronting and beating a man while he was in the shower. The video was posted to Facebook on November 4, 2019.
Riot police officer hit by molotov cocktail during Chile protests
A riot police officer is hit by a molotov cocktail during protests against the economic policies of the government of President Sebastian Pinera, in Chile's capital, Santiago.