pydem.
hdemi
(f, x, dx, bound, projection=False)¶Compute the Hyperdimensional error margin index. See “An Inductive Design Exploration Method for Robust Multiscale Materials Design” Choi, McDowell, Allen, Rosen, Mistree. Requires the distance computations from Boundary objects which may, or may not, be subject to significant errors if holes exist, etc. Distance computations are also relatively expensive, so recommend exploring mlv or vor alternatives.
- f : array_like
- Mapping functions (number of bounding functions with nominal value last, number of output variables)
- x : ndarray
- Nominal input to evaluate
- dx : ndarray
- Variation along each input dimension
- bound : Boundary
- Feasible region representation
- error_margin : float
- Return -1 if value is within the feasible region, otherwise compute the full hyperdimensional error margin index which is the minimum ratio of the output range distance to the distance to the boundary along that dimension. HD_{EMI} = egin{cases} min_{i} left[
rac{leftVert ar{y}-b_i ightVert}{Delta y_{i}} ight], & mbox{for } ar{y} in Omega -1, & mbox{for } ar{y} otin Omega end{cases}
pydem.
miv
(f, x, dx, bound)¶Maximum Independent Variation Possible replacement error margin for the Hyperdimensional error margin index. Evaluates the mid-points of the outer extents to see if all of the output region (expressed as a hyperrectangle) lies within the feasible space, and is thus a robust space. Could currently fail due to gaps in the feasible space which are contained within the extents of the output region. Can be addressed efficiently by means of KD-tree or similar.
pydem.
vor
(f, x, dx, bound)¶Valid Output Region Possible replacement error margin for the Hyperdimensional error margin index. Evaluates the outer extents to see if all of the output region (expressed as a hyperrectangle) lies within the feasible space, and is thus a robust space. Could currently fail due to gaps in the feasible space which are contained within the extents of the output region. Can be addressed efficiently by means of KD-tree or similar.


Defining Key Concepts¶
Glossary¶
In order to make the best use of this User Guide, it is important to have context for some high level concepts and terms. Here is a small glossary of some of the most important concepts in Bokeh.
- Application
- A Bokeh application is a recipe for generating Bokeh documents. Typically this is Python code run by a Bokeh server when new sessions are created.
- BokehJS
- The JavaScript client library that actually renders the visuals and handles the UI interactions for Bokeh plots and widgets in the browser. Typically, users will not have to think about this aspect of Bokeh much (“We write the JavaScript, so you don’t have to!”) but it is good to have basic knowledge of this dichotomy. For full details, see the BokehJS chapter of the Developer Guide.
- Documents
- An organizing data structure for Bokeh applications. Documents contain all the Bokeh Models and data needed to render an interactive visualization or application in the browser.
- Embedding
- Various methods of including Bokeh plots and widgets into web apps and pages, or the IPython notebook. See Embedding Plots and Apps for more details.
- Glyphs
- The basic visual building blocks of Bokeh plots, e.g. lines, rectangles,
squares, wedges, patches, etc. The
bokeh.plotting
interface provides a convenient way to create plots centered around glyphs. See Plotting with Basic Glyphs for more information. - Models
- The lowest-level objects that comprise Bokeh “scenegraphs”. These live
in the
bokeh.models
interface. Most users will not use this level of interface to assemble plots directly. However, ultimately all Bokeh plots consist of collections of models, so it is important to understand them enough to configure their attributes and properties. See Styling Visual Attributes for more information. - Server
- The Bokeh server is an optional component that can be used for sharing and publishing Bokeh plots and apps, for handling streaming of large data sets, or for enabling sophisticated user interactions based off of widgets and selections. See Running a Bokeh Server for more explanation.
- Widgets
- User interface elements outside of a Bokeh plot such as sliders, drop down menus, buttons, etc. Events and updates from widgets can inform additional computations, or cause Bokeh plots to update. Widgets can be used in both standalone applications or with the Bokeh server. For examples and information, see Adding Interactions.
Output Methods¶
As we will see demonstrated frequently throughout the User Guide, there are various ways to generate output for Bokeh documents. The most common for interactive usage are:
output_file
- For generating simple standalone HTML documents for Bokeh visualizations.
output_notebook
- For displaying Bokeh visualizations inline in Jupyter/Zeppelin notebook cells.
These functions are most often used together with the show
or save
functions. Scripts that output with these typically look something like:
from bokeh.plotting import figure, output_file, show
output_file("output.html")
p = figure()
p.line(x=[1, 2, 3], y=[4,6,2])
show(p)
If this script is called foo.py
then executing python foo.py
will
result in an HTML file output.html
being generated with the line plot.
These functions are often useful in interactive settings, or for creating
standalone Bokeh documents to serve from (Flask, Django, etc.) web
applications.
However, Bokeh also comes with a powerful command line tool bokeh
that
can also be used to generate various kinds of output:
bokeh html
- Create standalone HTML documents from any kind of Bokeh application source: e.g., python scripts, app directories, JSON files, and others.
bokeh json
- Generate a serialized JSON representation of a Bokeh document from any kind of Bokeh application source.
bokeh serve
- Publish Bokeh documents as interactive web applications.
An advantage of using the bokeh
command is that the code you write does not
have to specify any particular output method or format. You can write just the
visualization code once, and decide later to output in different ways. The
above example would be simplified to:
from bokeh.plotting import figure, curdoc
p = figure()
p.line(x=[1, 2, 3], y=[4,6,2])
curdoc().add_root(p)
Now, you can run bokeh html foo.py
to generate a standalone HTML file,
or bokeh serve foo.py
to start serving this document as a web application.
For more information on the command line tool see Using bokeh Commands.
Interfaces¶
Bokeh is intended to provide a quick and simple interface to data scientists and domain experts who do not want to be distracted by the details of the software, and also provide a richly detailed interface to application developers and software engineers who may want more control or access to more sophisticated features. Because of this, Bokeh takes a layered approach and offers different programming interfaces appropriate to different levels of use. This section provides an overview of the various interfaces that are available to Bokeh users, as well as more context about the most important concepts central to the library. If you’d like to jump right into basic plotting, go to Plotting with Basic Glyphs.
bokeh.models¶
Bokeh is actually composed of two library components.
The first component is a JavaScript library, BokehJS, that runs in the browser. This library is responsible for all of the rendering and user interaction. Its input is a collection of declarative JSON objects that comprise a “scenegraph”. The objects in this scenegraph describe everything that BokehJS should handle: what plots and widgets are present and in what arrangement, what tools and renderers and axes the plots will have, etc. These JSON objects are converted into BokehJS Models in the browser, and are rendered by corresponding BokehJS Views.
The second component is a library in Python (or other languages) that can
generate the JSON described above. In the Python Bokeh library, this is
accomplished at the lowest level by exposing a set of “model” classes
that exactly mirror the set of BokehJS Models that are created in the
browser. These python model classes know how to validate their content and
attributes, and also how to serialize themselves to JSON. All of
these low level models live in the low-level bokeh.models interface.
Most of the models are very simple, usually consisting of a few property
attributes and no methods. Model attributes can either be configured when
the model is created, or later by setting attribute values on the model
object. Here are some examples for a Rect
glyph object:
# properties can be configured when a model object is initialized
glyph = Rect(x="x", y="y2", w=10, h=20, line_color=None)
# or by assigning values to attributes on the model later
glyph.fill_alpha = 0.5
glyph.fill_color = "navy"
These methods of configuration work in general for all Bokeh models. Because of that, and because all Bokeh interfaces ultimately produce collections of Bokeh models, styling and configuring plots and widgets is accomplished in basically the same way, regardless of which interface is used.
Using the bokeh.models interface provides complete control over how Bokeh plots and Bokeh widgets are put together and configured. However, it provides no help with assembling the models in meaningful or correct ways. It is entirely up to developers to build the scenegraph “by hand”. For this reason, most users will probably want to use the bokeh.plotting interface described below, unless they have specialized requirements that necessitate finer control. For more information about the details of all Bokeh models, consult the Reference Guide.
bokeh.plotting¶
Bokeh provides a mid-level general purpose bokeh.plotting interface, which is similar in specificity to Matplotlib or Matlab style plotting interfaces. It is centered around having users relate the visual glyphs they would like to have displayed to their data, and otherwise taking care of putting together plots with sensible default axes, grids, and tools. All the hard work to assemble the appropriate Bokeh Models to form a scenegraph that BokehJS can render is handled automatically.
The main class in the bokeh.plotting interface is the figure()
function. This
creates a Figure
model, that includes methods for adding different kinds of
glyphs to a plot. Additionally it composes default axes, grids, and tools in
the proper way without any extra effort.
A prototypical example of the bokeh.plotting usage is show below, along with the resulting plot:
from bokeh.plotting import figure, output_file, show
# create a Figure object
p = figure(plot_width=300, plot_height=300, tools="pan,reset,save")
# add a Circle renderer to this figure
p.circle([1, 2.5, 3, 2], [2, 3, 1, 1.5], radius=0.3, alpha=0.5)
# specify how to output the plot(s)
output_file("foo.html")
# display the figure
show(p)
The main observation is that the typical usage involves creating plots objects
with the figure()
function, then using the glyph methods like Figure.circle
to add renderers for our data. We do not have to worry about configuring any
axes or grids (although we can configure them if we need to), and specifying
tools is done simply with the names of tools to add. Finally we use some output
functions to display our plot.
There are many other possibilities: saving our plot instead of showing it, styling or removing the axes or grids, adding additional renderers, and laying out multiple plots together. The Plotting with Basic Glyphs section of this User Guide will walk through many more examples and common use cases of using the bokeh.plotting interface.


DBC Fiddler Crabs 2016 Blog
January 11, 2016
Enumerable#group_by
The Enumerable module is a collection of methods. Most of them seem to have to do with arrays. Here is the documentation. The first paragraph at the top does a better job than me at explaining Enumerable. Enumerable has a lot of methods for sorting out arrays in various fashions. ".group_by" is the method of focus for this blog post. This method is called by an array, range, or any class that has a ".each" method. It sorts the collection into groups, and returns those groups as key/value pairs in a hash. That's it, in short. It runs each item in the collection through a block, and based on the outcome of that block, sorts each item into it's appropriate key/value pair. Here's two examples:
(1..10).group_by { |i| i.even? }
# => {false=>[1, 3, 5, 7, 9], true=>[2, 4, 6, 8, 10]}
In the above example, group_by goes through each item in the range, and determines whether it is even (because that's what the code block does). Since every item in the range, when evaluated by the block, is true or false, those are the only two keys in group_by's result hash.
grab_bag = ["hammer", 12, :yipee, 7, "Dick Van Dyke", :skippy]
grab_bag.group_by { |elem| elem.class }
# => {String=>["hammer", "Dick Van Dyke"], Fixnum=>[12, 7], Symbol=>[:yipee, :skippy]}
In the above example, group_by goes through each item in the array, runs it through the code block which spits out its class, and returns a hash with 3 keys, because there are only 3 different classes represented in grab_bag. The values for each key are the elements from grab_bag with a class type of the corresponding key.


How PyVVO Works¶
This section will provide an overview of how PyVVO works by walking through various flow charts. At times, specific Python modules or classes will be referenced. In addition to examining the source code itself, the API is documented in the PyVVO Code section.
PyVVO is highly configurable. To keep this documentation maintainable and avoid repeating information, the configurable fields will not be covered in detail here. Instead, check out this section in the repository’s top-level README file.
Additionally, PyVVO emits logs a significant amount of information as it runs. Many of PyVVO’s log messages are described in this section of the top-level README.
Flow Chart Conventions¶
The example flow chart below presents the conventions that will be used
throughout this documentation. Note that all flow charts are vector
images (specifically, .svg
), so you can zoom in on them without
making them blurry. While reading the documentation, it will probably
be most useful if you open up each flow chart in a second window and
position it side by side this documentation.
Technical Details¶
If the flow charts are rendering well for you and include text, no need to read this section.
If you cannot see any text on the flow charts or they don’t render
correctly, you’re likely using an archaic web browser. Please either
update your browser or switch to a modern one (e.g., Firefox). The
.svg
files have the fonts embedded in WOFF 2.0 format
(published as a W3C recommendation
in 2018) by dvisvgm.
High Level Summary¶
At the highest level, PyVVO contains two important components: data-driven predictive load modeling and a genetic algorithm. The load models are layered onto a GridLAB-D model, and resulting GridLAB-D simulation outputs are used in the genetic algorithm’s optimization process.
Main Loop¶
The following image depicts a flow chart of the operation of app.py
(pyvvo.app
). Boxes prefaced with INCOMPLETE indicate that
more work is needed to finalize the code related to the process
described in the box.
As noted in (a), when PyVVO is running inside the
GridAPPS-D platform, it’s started by run_pyvvo.py
(pyvvo.run_pyvvo
).
Initialization Phase¶
When PyVVO is started, it only receives two inputs from the platform: the simulation ID and the (simulation request) (b). The simulation request contains many useful details including, but not limited to, the feeder’s MRID, the time span of the simulation, etc.
PyVVO uses the information from (b) to initialize a
variety of classes whose role is to interface with the GridAPPS-D
platform (c). These classes can be found in
pyvvo.sparql
and pyvvo.gridappsd_platform
.
Since PyVVO is a volt-var optimization application, it primarily cares
about regulators and capacitors (future work should include control of
other devices). However, since PyVVO is model-based, it also needs to
know about other active devices in the system such as photovoltaic
inverters, distributed generators, and switches. PyVVO uses the
SPARQLManager
(initialized in (c)) to query
the GridAPPS-D platform’s Common Information Model
(CIM)
triplestore database to obtain nominal device information
(c). Additionally, information about the
measurement objects (e.g., their MRIDs, measurement types, etc.)
associated with the each device is pulled from the CIM triplestore.
With device and measurement information in hand, PyVVO can initialize
objects that represent all the equipment in the system that PyVVO cares
about (e). PyVVO has various classes related to the
management of devices (a.k.a. “equipment”) in pyvvo.equipment
.
These classes generally contain a small subset of what’s contained in
the (CIM).
Subscribing to simulation output
is like drinking from a fire hose, so PyVVO has the SimOutRouter
class
(pyvvo.gridappsd_platform.SimOutRouter
) which filters
simulation output and calls methods of the equipment classes that keep
their states up to date (f). All state
updates/subscriptions occur in their own threads, so object states are
immediately updated whenever new measurements come in.
PyVVO uses GridLAB-D (Wiki,
GitHub) as its power flow solver/simulator, and the
GridAPPS-D platform is capable of creating a GridLAB-D model from the
CIM triplestore for its own simulations. PyVVO leverages this fact and
requests a model of the
power system in GridLAB-D (.glm
) format (g),
representing the nominal state of the system.
Next, PyVVO initializes a GLMManager
(pyvvo.glm.GLMManager
) (h) using the
.glm
file pulled in (g). The GLMManager
creates an in-memory representation of the model using Python data
types, and is capable of modifying the model and writing out a new
.glm
file. The module pyvvo.glm
could come in handy for
other GridAPPS-D applications, or any application that needs to read,
modify, and write GridLAB-D models. The code isn’t perfect and has some
shortcomings, but also has a lot of features and functionality.
Next, PyVVO begins the process of load modeling by pulling historic meter data from the GridAPPS-D platform’s timeseries database (i). Specifically, historic data should come from the platform’s sensor service. As discussed in Outstanding Work, Known Issues, Future Work and noted in the flow chart, this portion of PyVVO is currently incomplete due to platform issues.
Weather data is incorporated in PyVVO’s load modeling process. This
data is obtained by
querying the platform
(j). Once obtained, the weather data must
be parsed and resampled so that it matches up 1:1 with the meter data
in (i). See
pyvvo.timeseries.parse_weather()
and
pyvvo.timeseries.resample_timeseries()
.
Optimization Phase¶
First of all, note there is some overlap in the “Initialization” and “Optimization” phases due to loop priming.
After all procedures described in Initialization Phase have been completed,
PyVVO enters its optimization loop. The first step in this process is
to update PyVVO’s internal .glm
model of the power system with the
current states of all equipment (l). Future
work might use predicted future states rather than current states.
Next, PyVVO initializes all the required objects for running the genetic
algorithm (m). The genetic algorithm components are fully
encapsulated in pyvvo.ga
. As noted in the flow chart, a
GAStopper
object is used for stopping the genetic algorithm
prematurely based on system events. At present, this only includes
switches changing state (though future work <todo> should include
other conditions). If the genetic algorithm were not halted due to a
topology change, it would continue optimizing, but its internal model
would no longer represent reality, making the result wrong/suboptimal
(and perhaps dangerous to the health of the system).
The internal workings of the genetic algorithm itself are rather complex, so discussion here will be limited to what’s already mentioned in (n). More details can be found in Genetic Algorithm.
After the genetic algorithm has run to completion, PyVVO has an idea of how controllable devices should be operated (e.g., regulators and capacitors). These proposed device settings are sent into the platform as commands (e.g. put regulator 1, phase A at tap 3) (o). PyVVO only sends in commands for proposed states that are different from the current state. In this way, if the proposed states are identical to the present states (indicating the system is already in an “optimal” configuration), no commands are sent into the system.
Note that (p) is flagged with INCOMPLETE. This is because at present, PyVVO simply runs the optimization loop indefinitely and only stops when its Docker container is killed. PyVVO doesn’t presently require any particular clean-up procedures, hence why (q) is so simple.
Load Modeling¶
Overview¶
PyVVO uses “smart” meter data to create time varying predictive load models. These models get layered onto a GridLAB-D model for use in the Genetic Algorithm.
While there are many, many types of load models, PyVVO attempts to keep things simple and uses the ZIP load model. The ZIP load model represents a load (or a collection of loads) as part constant impedance (Z), part constant current (I), and part constant power (P). PyVVO uses the ZIP load model for several reasons:
ZIP load models have a voltage dependency, which is important for model-based voltage control applications.
ZIP load models are included in as part of every distribution system simulator under the sun.
ZIP load models are physics-based, as opposed to “black box” models.
ZIP load models only have a handful of parameters, making curve-fitting less time consuming.
For more details, please see our HICSS paper.
Flow Chart and PyVVO Modules¶
The image below depicts a flow chart of the operation of PyVVO’s load modeling. The entire procedure spans several modules (presented here in alphabetical order):
pyvvo.cluster
for data clustering operationspyvvo.gridappsd_platform
for pulling data from the GridAPPS-D platformpyvvo.load_model
for pulling all the pieces together from the different modulespyvvo.timeseries
for parsing and resampling raw data from the platformpyvvo.zip
for curve-fitting data to create ZIP load models
The procedures described in the flow chart above can be kicked off by
instantiating a pyvvo.load_model.LoadModelManager
object
and then calling the fit_for_all
method. Note that the meta data
described in (c) are required inputs for
initializing a LoadModelManager
. Also note that the load_model
module and associated code are in need of some more work, testing,
documentation, and attention.
Generally speaking, the flow chart above speaks for itself. However, some items that are worth elaborating on:
As per usual, many of the parameters (e.g. \(M_{cs}\)) are configurable. If the parameters aren’t already in
pyvvo.json
, they can easily be added and documented.At the time of writing, the data standardization in (j) scale is unnecessarily done inside the clustering and fitting loop. With some moderate refactoring, this can be fixed.
K-means clustering in (k) is performed via Scikit-learn’s implementation.
Note that voltage (\(V\)) is not used in clustering, because clustering by voltage will lead to a poorly performing ZIP model. The ZIP load model takes voltage magnitude as input and outputs \(P\) and \(Q\). Therefore, it behooves us to have diverse voltage values in the data used for fitting, which would be undercut by including voltage as a clustering feature.
In (l), weather data is exclusively used as cluster selection features. This is a heuristic assumption based on the load/weather dependence that all power systems engineers are well aware of. This has not necessarily been proven to be the best approach in all scenarios, and in fact we’ve seen that at times a better fit can be obtained by including \(P\) and \(Q\) in the cluster selection.
Similarly, we do not have a guarantee that our “best” cluster necessarily leads to the “best” fit. However, it would be very computationally expensive to perform a ZIP fit on every cluster. On the other hand, maybe that approach would be worthwhile. There is a wealth of experimentation that can still be done.
The least squares optimization routine mentioned in (m) is moderately complex. It’s worth exploring this code in detail. Simply follow the rabbit hole starting with
pyvvo.zip.zip_fit()
.The final ZIP model that comes out of (m) uses GridLAB-D conventions. A thorough examination of the GridLAB-D source code was undertaken to ensure exact concurrence. There are tests to prove it in
tests/test_zip.py
.The reason for using a normalized MSE in (o) is that different clustering loop runs will have a different number of data points present in the “best” cluster, resulting in very different raw MSE values.
Note that equal weight is given to \(\text{MSE}_P\) and \(\text{MSE}_Q\) in the \(\text{MSE}_\text{norm}\) computation in (o). It may be valuable to experiment with different weighting schemes.
Outstanding Work and Possible Issues¶
The GridAPPS-D platform has struggled to put together a working sensor
service, and the timeseries database and its API have been plagued by
bugs. Additionally, memory leaks and other issues have prevented the
platform from running for a prolonged time to generate historic data
for the load modeling. As such, PyVVO’s load modeling procedures have
not been fully integrated into app.py
and load_model.py
has
several outstanding issues.
Fortunately, the underlying clustering and fitting code is complete (at least in a working and tested draft form), and most of the remaining work involves finalizing the touch points between PyVVO and the platform with respect to load modeling.
It would be prudent to walk through the entire clustering and fitting process with an eye toward performance optimization. There are many loads in the so called “9500 node” model (~1300) and getting the required data for each load requires 4 different measurement objects (as mentioned in (d) in the flow chart).
I (Brandon) suspect that the load modeling procedure is going to run into bottlenecks with respect to both I/O from the platform as well as computation.
With respect to I/O: queries to the timeseries database have to date been very slow, and message size and/or memory issues means that it may be necessary to perform a single query for each load (or maybe even for each measurement!) which comes with a lot of overhead. Additionally, due to the primitive filtering available through the GridAPPS-D API, there are two options for time filtering:
Pull all historic data at once (e.g., all data for a two week window) and filter it afterwards. Ultimately, PyVVO is only going to use something like < 1/10 of the pulled data, so this is clearly inefficient.
Perform lots of little queries for the the various time windows. E.g., perform ten queries to pull data from 9:00am-11:00am for two weeks worth of weekday data. This clearly comes with a lot of overhead.
While it may go against the API-only “principles” of GridAPPS-D, the best solution would be to query the timeseries database directly and create moderately complex custom time filters. This could be done through the API if a “custom query” route was created, similarly to the SPARQL API.
It’s also worth noting that if the historic data is ever generated at the correct averaging interval by the sensor service (e.g., 15 minutes), all the load data for a particular time window might fit into memory with a single query. Again, you’re likely going to run into maximum message size issues with the platform, although the database itself would be totally happy to hand you all that data at once.
Finally, some thoughts on parallelization: depending on how the platform API and database infrastructure are implemented, querying the database in parallel on the application side may not result in truly parallel queries on the platform side. E.g., if the database queries are multi-threaded instead of multi-processed, you won’t actually get true concurrency, just the “fake” concurrency that threading provides.
With respect to computation: The bottom line is there are a lot of loads, and for each load multiple clustering operations and sequential least squares optimization operations are run. That’s a lot of computation. The good news is that this is completely parallelizable. GridAPPS-D as a project is emphasizing distributed applications, so splitting out the load modeling into its own app could be a very valuable use case. This would also be useful for other applications that rely on load models, such as WSU’s VVO application.
There are also a lot of tweaks that can be made to potentially speed up the load modeling process. For example, increasing the minimum cluster size \(M_{cs}\) in (i) will decrease the number of clustering loops that are performed, at the cost of less exploration. Additionally, the least-squares optimization could potentially be sped up by using the previous fit parameters as a starting point for the next optimization run. There are likely lots of other little levers such as these that could help alleviate the computation bottleneck.
If you’re feeling lazy and have the computational resources, just throw more cores at the problem. However, depending on how you get the data, you might run into I/O bottlenecks (as discussed in the IO issues section.
If you are feeling really blasphemous and are okay flying in the face of all the load modeling work that’s been done for this application, you could do something as simple (and likely very, very suboptimal) as use state estimator \(P\) and \(Q\) output for each load and model them all as constant power (or constant current or constant impedance or with arbitrary ZIP parameters). Please don’t do this.
Yet another intriguing option would be to aggregate loads up to the distribution transformer level. In short, one would need to model the voltage drop and losses across the “triplex” lines, and then aggregate at the historic data at transformer level. This aggregated data could then go through the same ZIP fit procedure described here. However, you lose some important information: what’s the voltage at each meter? It’s feasible that downstream of one secondary transformer there’s one meter within the allowed voltage band and one outside the allowed voltage band. How often does this happen? Hard to say.
Genetic Algorithm¶
Brandon ran out of time to write about the genetic algorithm in detail, but fortunately there’s this nifty flow chart:
Note that many genetic algorithm parameters are controlled in
pyvvo_config.json
. Specifically, have a look at the ga
,
limits
, and costs
keys. Discussion of these parameters is
covered in the README.
It’s pretty easy to follow along in the code with the flow chart in
hand. If you’re using PyCharm, Ctrl + B
is going to be your best
friend for jumping into methods as you follow the rabbit hole. As
seen in (b) and (c), the algorithm is
kicked off in app.py
. From there, you can sift through ga.py
to find everything you need.
Note that right now, stopping the algorithm is ill-defined (q). It just runs for a fixed number of generations. Ideally, some sort of convergence criteria would be developed.


Policy has a Response variable named "response", this may lead to unexpected side effects.
Rename the Response variable.


Custom Tesla-Powered EV Sports Car Has Selectable FWD, RWD or AWD
by Andrei NedeleaBuying an electric car is prohibitively expensive for many, which is why making your own garage-built EV is becoming increasingly popular.
Not all builds are worth a look, but there are projects, such as this custom Factory Five 818, that certainly are. The 818 is a cool little kit car that would warrant a look on its own (it's a unique model, not a replica of something else), but this particular one is especially noteworthy.
Instead of the Subaru powertrain the car is supposed to come with, this one has been fitted with the powertrain of a Tesla Model S P85D (it previously ran just the rear motor), so it has around 700 horsepower, yet it weighs around 1,100 kg (2,400 pounds). The Tesla with this powertrain hits 100 km/h from standstill in 3.3 seconds, so you can imagine how much faster this lightweight sports car is with the same output.
It has been tested and it can consistently run the quarter mile in the low 9s (its record is 8.95 seconds), and its benchmark sprint time is surely under the 3-second mark. Its top speed was also measured at 220 km/h (137 mph).
Power to the two motors is not provided from a Tesla battery pack, as that would have been way too big for this car’s small frame. Its creator opted to have it draw juice from a pair of Chevrolet Volt battery packs with a total of 32 kWh - they apparently bestow this car with a real world range of around 200 km (120 miles).
Another cool peculiarity of this project is that because it runs a custom controller for the electric motors, the driver can actually switch power to each axle on or off. In other words, the car can be run in front-wheel drive, rear-wheel drive or all-wheel drive, all at the tap of a screen - this apparently helps with warming each set of tires up individually before an acceleration run, but we’re sure more fun uses can be found for this feature. 🏁


---
title: Contact
description: Send us a message to find out more!
map:
latitude: -45.8787605
longitude:<PHONE_NUMBER>
address: "1 George Street, Pretoria, New Zealand"
zoom: 13
image: /images/phonecall.jpg
---
For all your homeloan queries! Feel free to make contact with one of our consultants below. {{ person.role }}Get in touch today
{% for person in site.staff_members %}
{{ person.name }}


I started reading the first 10 pages of "Carl von Clausewitz’s On War. It is really really insightful and I wanted to share with you his first thoughts about what war really is. It is really powerful in the current situation.
We need to start by looking at war as a whole, before looking at the parts.
War is an act of aggression to force the enemy to fulfill your will. Physical force is the act while forcing your will on your enemy is the purpose. To achieve this purpose we need to make the enemy defenseless, which is the real goal.
I think this can very well be seen in what we currenty see happening in Afghanistan. The USA want bin laden, which is the will they have and for this purpose they try to convince the enemy and at the end are using force in the goal to make Afghanistan defenseless.
With dangerous things like war, the mistakes which come from good nature are the worst and most severe. In general each opponent will use force to try to overpower the enemy especially if that enemy does not use force which will lead to a situation where the enemy will be bound to reply with more force. This can lead to the most extreme.
The goal is to make the enemy defenseless. This can either be a real state of helplessness or defenselessness or a state where the likelyhood of this happening is high. We need this to happen to force our will onto our enemy. We need to put our enemy into a state where this state is worse then what we request from our enemy.
There we can see how important bin Laden is for them. The state that Afghanistan is currently in can be considered very bad but they still seem to feel that giving bin Laden up is a worse thing.
- The resistance by our enemy can be calculated by the product of the size of means and the power of his will.
Here the will is Afghanistans greatest asset. But this also shows why the US needs to be so clear of what they are saying and doing. They need to show this power of will.
- This needs to be modified a bit in reality as there are a lot of things playing into this so that we will most likely not reach the extreme in force, total defenselessness of our enemy or the over powerful resistance.
This is shown in the complicated picture we have at the moment in all of this. And our enemy will never be 100% gone.
- War is not an isolated act. As we are always far from achieving the absolute best and there will be several faults on both sides all this will lead to a moderation of the pinciple.
We cannot just do something and pretend it will not have an effect on something else.
This is not one hit without interruption.
War with its result is never something absolute. The loosing state mostly sees the result as a temporary evil.
The probability takes the place of the extremes and absolutes.
Here the political purpose comes back in. We lost this a bit out of sight due to the goal of making our enemy defenseless. The real purpose is political and it becomes important if we are dealing with probabilities. The smaller our political purpose, the smaller will be the value we place on it and the smaller will be our efforts. The political purpose is not a fixed measure though. There can be a very small political motiv but so much tension between two states that extreme things can happen.
see Israel - Palestinia conflict here.
Sometimes the political purpose will not be able to be the goal of the act of war and sometimes what drives the act of war needs to be a lot greater than the political purpose.
Our political purpose is ending terror if you want to put it like this and the act of war against Afghanistan is something else really. It also possibly needs a bigger driver such as wanting to get bin Laden to justice. Could be argued about but it makes you think.
12/13 There is only one thing which can halt the act of war which is waiting on a good point in time to act.
But this continuity might lead to extremes again but it should be seen as a number of seperate act which takes up not closely as much time as the standing still.
This brings in the polarity into the relationship.
Attack and Defense are different things of the same power but the polarity is in the decisions not in them as themselves.
If the defense is stronger than the attack then choosing to act later might not bring a movement into the war. In this case we will have a lot more standstills in the war.
You will never have ultimate knowledge of your enemy and therefor might make the choice not to move even though there is no point of doing so.
All this standstill makes the act of war even more something of probability.
Add to that coincidence and luck and you are very close to a game.
War moves within danger which requires courage and there comes luck and war becomes very similar to a card game.
There is a lot of uncertainty but people prefer uncertainty as they have a lot of choices and not just one. They can dive into these possibility with courage and the element of danger.
But with all this, the act of war remains a means to an end. It is still a political act.
The act of war is a simple extension of politics with other means.
The bigger and more powerful the motives of the war, the more they revolve about the life and living of a population, the more aggressive the tensions are that are before the war,… the more the act of war will take an abstract form and will be about putting the enemy to the ground, the more the act of war itself and the political purpose will fall together and the more martially and the less polical the war will seem to be.
This fits fairly well to the current situation. Sadly both to the US and the Taleban if you really think about it.
- War can be seen as a political act.
…


Iperf Checklist
Basic Information
OS:
IRIX
Linux
HP-UX
UNICOS on T3E
AIX
Solaris
FreeBSD
NetBSD
DEC OSF1
SPP-UX
Windows
Other...


From year:
{{year}}
To year:
{{year}}
Hosting city:
{{city}}
Discipline:
{{discipline}}
Event:
{{event}}
Country:
{{country}}
Color:
{{color}}
Gender:
{{gender}}
Clear
Search
Found {{resultsController.getResults().length}} results.
{{columnName}}
{{data}}


We invite fans of frameworks and especially authors or maintainers of frameworks to join us in expanding the coverage of this project by implementing tests and contributing to the GitHub repository. The following are specifications for each of the test types we have included to-date in this project. Do not be alarmed; the specifications read quite verbose, but that's because they are specifications. The implementations tend to be quite easy in practice.
This project is evolving and we will periodically add new test types. As new test types are added, we encourage but do not require contributors of previous implementations to implement tests for the new test types. Wholly new test implementations are also encouraged to include all test types but are not required to do so. If you have limited time, we recommend you start with the easiest test types (1, 2, 3, and 6) and then continue beyond those as time permits.
Requirements
General Requirements
The following requirements apply to all test types below.
-
All test implementations should be production-grade. The particulars of this will vary by framework and platform, but the general sentiment is that the code and configuration should be suitable for a production deployment. The word should is used here because production-grade is our goal, but we don't want this to be a roadblock. If you're submitting a new test and uncertain whether your code is production-grade, submit it anyway and then solicit input from other subject-matter experts.
-
All test implementations must disable all disk logging. For many reasons, we expect all tests will run without writing logs to disk. Most importantly, the volume of requests is sufficiently high to fill up disks even with only a single line written to disk per request. Please disable all forms of disk logging. We recommend but do not require disabling console logging as well.
-
Specific characters and character case matter. Assume the client consuming your service's JSON responses will be using a case-sensitive language such as JavaScript. In other words, if a test specifies that a map's key is id, use id. Do not use Id or ID. This strictness is required not only because it's sensible but also because our automated validation checks are picky.
Test Types & Specific Requirements
Each test type has their own requirements and specifications. Visit their pages for more details and complete requirements.
- JSON Serialization: Exercises the framework fundamentals including keep-alive support, request routing, request header parsing, object instantiation, JSON serialization, response header generation, and request count throughput.
- Single Database Query: Exercises the framework's object-relational mapper (ORM), random number generator, database driver, and database connection pool.
- Multiple Database Queries: A variation of Test #2 and also uses the World table. Multiple rows are fetched to more dramatically punish the database driver and connection pool. At the highest queries-per-request tested (20), this test demonstrates all frameworks' convergence toward zero requests-per-second as database activity increases.
- Fortunes: Exercises the ORM, database connectivity, dynamic-size collections, sorting, server-side templates, XSS countermeasures, and character encoding.
- Database Updates: A variation of Test #3 that exercises the ORM's persistence of objects and the database driver's performance at running
UPDATE
statements or similar. The spirit of this test is to exercise a variable number of read-then-write style database operations. - Plaintext: An exercise of the request-routing fundamentals only, designed to demonstrate the capacity of high-performance platforms in particular. Requests will be sent using HTTP pipelining. The response payload is still small, meaning good performance is still necessary in order to saturate the gigabit Ethernet of the test environment.


app
/
com.dhirajgupta.multicam.utils
/
CompareSizesByArea
/
<init>
<init>
CompareSizesByArea
(
)
Compares two
Size
s based on their areas.


Title
This is a Modal View App template main page.
This is Modal view for settings
Setting One
Setting Two


Perl 6 File Icons in Atom Editor
December 3, 2015
This morning, I decided to spend some time trying to get file icons for Perl 6 files. None of the font packages that file-icons includes have a Perl 6 icon so I would need to take the Camelia logo and turn it into a small icon.
Being a complete SVG noob (and without even trying to learn), I tried to edit the svg xml directly. I adjusted the size, changed some metadata, and then completely lost myself looking at all the paths. At this point I realized that I was doing something wrong as the image was not showing in the thumbnail of Gnome Files.
After fumbling my way through Inkscape for a bit, I was lucky enough to get pinged by Juerd on irc that he already had a mono svg of Camelia.
At this point, I began to look up how to turn that into a font as Atom Editor is just a glorified web browser which means I would need some kind of web font (specifically, woff
). I found a fantastic free site called icomoon that lets you turn custom svg files into icon fonts. So I converted that and dropped the folder into my .atom
folder under stylesheets
. At this point I struggled a bit to understand how to import icomoon's css into my styles.less
but after some help on Slack, I had it working!
Check out my tweet for a larger image. If you're interested in having these lovely file icons, here's how you do it:
apm install file-icons
cd ~/.atom/stylesheets
git clone https://github.com/MadcapJake/perl6-atom-file-icon camelia
sed -i "s|/home/jrusso|$HOME|" ~/.atom/stylesheets/camelia/style.css
atom ~/.atom/styles.less
Then add this:
@import "packages/file-icons/styles/colors";
@import "packages/file-icons/styles/items";
@import "packages/file-icons/styles/icons";
@import (less) "stylesheets/camelia/style.css";
.octicon-package {
content: "\f0c4"
}
@{pane-tab-selector}, .icon-file-text {
&[data-name="META6.json"]:before { .octicons; .octicon-package !important; }
}
@{pane-tab-selector}, .icon-file-text {
&[data-name="META.info"]:before { .octicons; .octicon-package !important; }
}
@{pane-tab-selector}, .icon-file-text {
&[data-name$=".pl6"]:before { .camelia; .im-camelia; .light-green; }
}
@{pane-tab-selector}, .icon-file-text {
&[data-name$=".pm6"]:before { .camelia; .im-camelia; .light-blue; }
}
@{pane-tab-selector}, .icon-file-text {
&[data-name$=".t"]:before { .camelia; .im-camelia; .light-yellow; }
}
That should do it! You can change the colors if you like, too. Of course, keep in mind that changing the .t
extension will overwrite any perl5 file icon (I think it's a camel).
Enjoy!


--- name: button url: /button ---
You can create buttons with this basic HTML
You can create buttons of various colors with these classes:
<!-- Color Classes -->
Primary Color
Secondary Color
Success Color
Alert Color
Warning Color
You can customize button sizing with these classes:
<!-- Size Classes -->
Tiny Button
Small Button
Default Button
Large Button
Expand Button
Adding a class of .disabled will disable the pointer & hover state, while also changing the color.
Buttons can be easily customized using our Sass variables.
$include-html-button-classes: $include-html-classes;
// We use these to build padding for buttons.
$button-med: rem-calc(12);
$button-tny: rem-calc(7);
$button-sml: rem-calc(9);
$button-lrg: rem-calc(16);
// We use this to control the display property.
$button-display: inline-block;
$button-margin-bottom: rem-calc(20);
// We use these to control button text styles.
$button-font-family: inherit;
$button-font-color: #fff;
$button-font-color-alt: #333;
$button-font-med: rem-calc(16);
$button-font-tny: rem-calc(11);
$button-font-sml: rem-calc(13);
$button-font-lrg: rem-calc(20);
$button-font-weight: bold;
$button-font-align: center;
// We use these to control various hover effects.
$button-function-factor: 10%;
// We use these to control button border styles.
$button-border-width: 1px;
$button-border-style: solid;
// We use this to set the default radius used throughout the core.
$button-radius: $global-radius;
$button-round: $global-rounded;
// We use this to set default opacity and cursor for disabled buttons.
$button-disabled-opacity: 0.6;
$button-disabled-cursor: $cursor-default-value;


Click the button above to display the abstract book information in a clean view.
Primary Submissions: {{trackedSubmissions(currentYearSubmissions)}}
Submissions stored: {{totalSubmissions(currentYearSubmissions)}}
Percentage of stored submissions that are primary submissions: {{precentageTracked(currentYearSubmissions)}}%
Number of submissions currently flagged for re-submission: {{resubmitFlags(currentYearSubmissions)}}
Total number of Primary Submissions: {{trackedSubmissions(submissions)}}
Total number of Submissions stored: {{totalSubmissions(submissions)}}
Total number of registered users: {{totalUsers()}}
Admins: {{totalAdmins()}}
Chairs: {{totalChairs()}}
Reviewers in Group 1: {{totalReviewers(1)}}
Reviewers in Group 2: {{totalReviewers(2)}}
Reviewers in Group 3: {{totalReviewers(3)}}
Reviewers in Group 4: {{totalReviewers(4)}}
Basic users (Advisers/Presenters): {{totalBasicUsers()}}
Note: If users from past years have not been removed from the system, their shirt sizes will still show here.
Small T-Shirts: {{totalShirts("Small")}}
Medium T-Shirts: {{totalShirts("Medium")}}
Large T-Shirts: {{totalShirts("Large")}}
XLarge T-Shirts: {{totalShirts("XLarge")}}
XXLarge T-Shirts: {{totalShirts("XXLarge")}}
XXXLarge T-Shirts: {{totalShirts("XXXLarge")}}


Soccer addiction for the last 20 years of my life, learning to turn my passion for sports into a passion for development. Played Soccer for Cal State Dominguez Hills, winning a national championship in 2008 and graduating in 2013 with a B.A in Kinesiology.
By utilizing elements and principles of Material Design, we were able to create a framework that incorporates components and animations that provide more feedback to users. Additionally, a single underlying responsive system across all platforms allow for a more unified user experience.
We have provided detailed documentation as well as specific code examples to help new users get started. We are also always open to feedback and can answer any questions a user may have about Materialize.
Please feel free to go to my contact page and shoot me an Email, let me know what you think of my page.


Provides a simple std::vector view of an AudioBufferList.
More...
#include <BufferFacet.hpp>
|
| | BufferFacet () |
| | Default constructor that does not hold a buffer list. More...
|
| |
| void | setBufferList (AudioBufferList *bufferList, AudioBufferList *inPlaceSource) |
| | Install an AudioBufferList to work with. More...
|
| |
| void | setFrameCount (AUAudioFrameCount frameCount) |
| | Set the number of frames that will be held in this buffer. More...
|
| |
| void | setOffset (AUAudioFrameCount offset) |
| | Set the unprocessed offset value. More...
|
| |
| void | release () |
| | Forget the buffer list and its buffer pointers. More...
|
| |
| void | copyInto (BufferFacet &destination, AUAudioFrameCount offset, AUAudioFrameCount frameCount) const |
| | Copy frames from this instance into another one. More...
|
| |
| size_t | channelCount () const |
| |
| AUValue * | channel (size_t index) const |
| |
| const std::vector< AUValue * > & | channels () const |
| |
Provides a simple std::vector view of an AudioBufferList.
◆ BufferFacet()
| SF2::Render::BufferFacet::BufferFacet |
( |
| ) |
|
|
inline |
Default constructor that does not hold a buffer list.
◆ channel()
| AUValue* SF2::Render::BufferFacet::channel |
( |
size_t |
index | ) |
const |
|
inline |
◆ channelCount()
| size_t SF2::Render::BufferFacet::channelCount |
( |
| ) |
const |
|
inline |
◆ channels()
| const std::vector<AUValue*>& SF2::Render::BufferFacet::channels |
( |
| ) |
const |
|
inline |
- Returns
- read-only reference to the collection of channel buffer pointers.
◆ copyInto()
| void SF2::Render::BufferFacet::copyInto |
( |
BufferFacet & |
destination, |
|
|
AUAudioFrameCount |
offset, |
|
|
AUAudioFrameCount |
frameCount |
|
) |
| const |
|
inline |
Copy frames from this instance into another one.
- Parameters
-
| destination | the BufferFacet to receive the frames |
| offset | the offset to apply to both instances before performing the copy operation |
| frameCount | the number of frames to process |
References channel().
◆ release()
| void SF2::Render::BufferFacet::release |
( |
| ) |
|
|
inline |
◆ setBufferList()
| void SF2::Render::BufferFacet::setBufferList |
( |
AudioBufferList * |
bufferList, |
|
|
AudioBufferList * |
inPlaceSource |
|
) |
| |
|
inline |
Install an AudioBufferList to work with.
NOTE: this is a borrow operation; there is no management of the lifetime of the bufferList
value.
- Parameters
-
| bufferList | the AudioBufferList to use |
| inPlaceSource | an AudioBufferList to use for in-place operations. If AudioUnit does not support in-place then this should be OK to be a nullptr. |
References channel().
Referenced by SF2::Render::InputBuffer::allocateBuffers().
◆ setFrameCount()
| void SF2::Render::BufferFacet::setFrameCount |
( |
AUAudioFrameCount |
frameCount | ) |
|
|
inline |
Set the number of frames that will be held in this buffer.
- Parameters
-
| frameCount | the number of frames |
References channel().
◆ setOffset()
| void SF2::Render::BufferFacet::setOffset |
( |
AUAudioFrameCount |
offset | ) |
|
|
inline |
Set the unprocessed offset value.
- Parameters
-
| offset | the index of the next frame to process. |
References channel().
The documentation for this class was generated from the following file:


This is my Tableau Dashboard
This chart shows that California is one of the highest in profitability.
This chart shows the profitability of California for the last two years of data.
This chart shows the profitability of each product category in California.
This chart shows forecasted sales for office supplies to Nov of 2015.


Ask fellow startuper, mentors or investors. Curated content and valuable advices.
Find out about events and meet people online and in-person! Global network of mentors, founders, hackers, developers, designers, angel investors, VCs and evangelists.
Accelerate you Business by get competitive advantage and growing your company faster. Get access to our community of like-minded entrepreneurs and cutting-edge tools.


A toolkit for Reliability Availability and Maintainability (RAM) modeling of industrial process systems.
| Version: | 0.0.14 |
| Depends: | tcltk |
| Imports: | Rcpp (≥ 0.11.1) |
| LinkingTo: | Rcpp |
| Published: | 2018-05-01 |
| Author: | David Silkworth [aut], Jacob Ormerod [cre], OpenReliability.org [cph] |
| Maintainer: | Jacob Ormerod <jake at openreliability.org> |
| License: | GPL (≥ 3) |
| Copyright: | copyright (c) OpenReliability.org 2011-2018 |
| NeedsCompilation: | yes |
| CRAN checks: | stosim results |
| Reference manual: | stosim.pdf |
| Package source: | stosim_0.0.14.tar.gz |
| Windows binaries: | r-devel: stosim_0.0.14.zip, r-release: stosim_0.0.14.zip, r-oldrel: stosim_0.0.14.zip |
| OS X binaries: | r-release: stosim_0.0.14.tgz, r-oldrel: stosim_0.0.14.tgz |
| Old sources: | stosim archive |
Please use the canonical form https://CRAN.R-project.org/package=stosim to link to this page.


unTill Base
HTML and React components library for developing Untill Air Shell plugins.
How to get started
Just add following code to your web page <head> section and use elements from library.
Check
Documentation
section for more information about components.
<link rel="stylesheet" href="
https://www.dev.untill.com/untill-air-shell/base/css/untill-base.css
" />
<script src="
https://www.dev.untill.com/untill-air-shell/base/src/js/untill-base.js
" type="text/javascript"></script>


Automatic differential count of leucocytes in microscopic images.
This project was the subject of my computer science graduation's final paper. Mainly, it was a work in computer vision and machine learning, but it also involved biomedicine, visual interface prototyping and a lot of scientific reading and writing.
My goal was to automate a biomedical process: the counting of leucocytes (white blood cells). This count is very important for the diagnosis of diseases, ranging from allergies to HIV. The project originated from the concrete need of a colleague, who was studying for a master’s in pharmacology. She strived daily with this process, which she did manually for her research: she literally sat at the microscope and counted the cells, one by one, on multiple slide positions to get a broader sample. This manual approach is slow, tiresome, prone to error and bias. For that reason, it ought for an alternative, and we applied tech to conceive one.
At first, for a few months, a deep research of the existing scientific literature on the topic was made. Turned out that there was a lot of existing work on automating cell counting processes, even by means of the processing of microscopic images, but they ranged through many types of cells, different types of samples (i.e. blood, tissue) or were simply too generic. No clean-cut recipe that fit our needs was available, and it was so that I had to adapt and experiment.
The general framework and methodology, though, could be drawn from the literature, as there was reasonable consensus: first, the image needs to be preprocessed for noise removal; then, it needs to be segmented, separating the regions of interest (potential cells) for further analysis; finally, for each segmented region, a set of descriptive features is extracted and fed to a classifier, which determines if it’s a cell or not (and which cell, being our count differential).
Defined the 4 steps shown above, they act as slots for a variety of algorithms. To choose which algorithms would compose the pipeline of my final proposed method, I first intuitively selected a few from the scientific literature. Then, I continued the selection empirically, so I could pick the options that best served my specific domain (the leucocytes at my colleague’s research).
For that, a set of 100+ microscopic images was first taken, at her laboratory. Then, I (with the help of the specialist) made multiple sorts of annotations, like number of cells in an image, ideal segmentation and correct class (classifier output) provided a region. Those acted as ground truth for the choosing and parametrization of the algorithms, alongside accuracy metrics drawn from the literature.
It was just then, half-way through the final year, that the coding started. But not before I learned Python from scratch. Because of its script-like structure, the language seemed adequate for the execution of the experiments. In fact, once I learned my way around, the simplicity and high level of abstraction were very welcome during the process of exploring the data. With matplotlib, I could both easily visualize my results and generate presentable graphs for the paper.
This graph shows the results for an exaustive test that I ran. Each line represents either a RGB color channel or the grayscale, and shows the average performance achieved by segmenting the image through a fixed threshold, using the Jaccard index as metric. It was because of this plot that I observed how the green RGB channel had more correlation with the problem at hand.
For manipulating the images, I used OpenCV, an open-source library with algorithms on computer vision. OpenCV was not just a facilitator, but rather necessary. Navigating through pixels in an interpreted language like Python, as I sadly discovered, showed to be quite computationally consuming. In contrast, OpenCV is written in C/C++ and can make use of the GPU.
That said, not all needed algorithms were available in OpenCV. This was the case of the limiarization by minimization of the fuzzy divergence, for example, an algorithm that I tested for the segmentation step. For this algorithm and others, I had to build them up from the OpenCV basic operations, which required me to get a good grasp of the library.
For the classification step, I ended up using a support vector machine (SVM). The scikit-learn library provided me not only with that algorithm’s implementation but also with implementation for k-fold crossed validation, linear discriminant analysis (LDA) for the selection of the most relevant features and the ROC curve to show the output of the SVM.
The results obtained can be seen on the ROC curve above, representing a binary SVM that individually recognize neutrophils, a type of leukocyte. Even though the accuracy rate was quite high (92 on average), the experiment that led to those results was executed over ideally segmented regions. Those, unfortunately, were not close to being automatically generated, having the segmentation step not faired so well as the classification.
As an aftermath, the whole proposed method (from image to final count) did not reach good enough results that would justify the proper creation of an application. Despite that, the project served not only to make me venture into many previously unknown fields (and thus learn new things), but also to raise some questions and ideas for further work on the subject, which were included in the paper.
Additionally, my human-machine interaction teacher prompted me to apply the UX concepts learned at his class on the prototyping of a graphic interface for this project. Or rather, a mobile application with objective to capture images through the microscope and display the cell counting results. For that, I used Pingendo, a graphical environment for design and development with HTML that uses Bootstrap.
Once the experiments were concluded and, with the results, the final method (algorithms and its optimal parameters) was determined, started a long period of writing. This process can be daunting, even more for a beginner. To help me keep track of the many references, technical terms, sections and chapters, I had to resort to LaTeX, which also helped me to comply with the writing standards required by my college (someone, to who I am very grateful, had built a template).
As instructed by my mentor, a scientific paper must be extensively revised so there are no errors left and the result is coherent, self-contained and non-redundant. For that to be accomplished, a lot of effort is necessary, but in turn one also conquers a sort of hard-won fluency on the subject.
I did that, and, when the final presentation day came, I could speak with ease about all the subjects touched by my work. I received an A, both for the presentation and for the paper.
Later, my project was invited to be presented at InovaFEI, a congress on innovation. There, it was judged on its social impact and relevance. Also, my ability to explain the project to people of other fields was taken into account. In the end, my project was awarded with first place in computer science.
All the code, images and annotations are available at a GitHub repository. The paper (which was written in portuguese) can also be download here.


These images may, or may not, have been built on Total Freedom but are made by/with at least one masterbuilder from Total Freedom.
Made by miwojedk - this project won the #1 place on PlanetMinecraft Contest (Press "Show More" to see more information)
Made by miwojedk - this project won the #1 place on PlanetMinecraft Contest (Press "Show More" to see more information)


Region: Australia
Industry: SIP, Global Development
Capabilities: CD,Cloud, Delivery
Live Below the Line is one of the fastest-growing anti-poverty campaigns in the world. An annual campaign run by The Oaktree Foundation (Australia) and The Global Poverty Project (United Kingdom, United States and New Zealand), challenges people to live below the extreme poverty line for five days to raise funds for projects aimed at helping the 1.4 billion people living in extreme poverty every day. ThoughtWorks took on the project that other consultancies said was impossible and launched the minimal site in 6 weeks using Contiunous Design and Continuous Delivery with short frequent releases.
The successful 2012 campaign had more participants (8000+) and raised more funds (over $2.1 million) globally than in the last 3 years combined. Through the support of ThoughtWorks Social Impact Program (SIP), the cost to develop the website was less than the ongoing comission they would have had to pay with the previous site.
New website wanted. Fundraising and social networking skills, and a desire for continual new challenges required.
The annual campaign website has been crucial to success, because in addition to letting people sign up, and accepting and processing donations, it provides resources and an online community space to aid participants in sticking with the challenge.
After three years of growth, the campaign needed to replace the website that had supported it so far as it no longer served participants or donors well, and the user experience was compromised due to a disconnect between the fundraising and community/resource aspects, that required multiple logins. New functionality necessary to the growth of the campaign was becoming increasingly difficult to add, and rising licensing fees, charged as a percentage of donations, were a concern.
Oaktree and Global Poverty Project jointly decided to invest in a custom built application: a cutting-edge integrated fundraising and community platform with social media integration. This would let them serve the growing base of donors and partners, take control of their intellectual property, provide the flexibility they needed for more projects and local features, and remove ongoing fees.
No one thinks it can be done? We say “Let us show you how.”
The organisation selected ThoughtWorks to develop the site—the only vendor willing to commit to the tight three-month deadline necessary to support the next campaign. Our team members were as motivated by the anti-poverty objective of the campaign, as by the technical and timing challenges of the project itself. Promotion of social and economic justice is one of the Three Pillars that underlie everything we do at ThoughtWorks.
A week-long inception was conducted at the outset, developing the product vision and creating a shared understanding of the campaign, website objectives, scope and priorities. Getting the site up and live with a minimal set of features was critical to kicking off the campaign as soon as possible, thus providing enough time to get the number of participants required to meet the fundraising goals for the upcoming annual campaign. The team decided to take a Continuous Design and Continuous Delivery approach and focused on the minimal viable product that could go live, including the appropriate amount of design to represent the brand.
Designing and Community Building
Designing a single solution presented a number of challenges due to the different ways the campaigns are run. The US and UK campaigns, for instance, run on a partnership model where not-for-profit organisations establish campaigns within the Live Below the Line website. Other regions do it differently. Another key consideration for the new site was that it must foster a strong sense of community among participants, as that is extremely important to a successful campaign. Live Below the Line wanted participants to share their experiences with friends, and make friends in their online community. This meant, among other requisite features, member profiles and pictures, creating and finding teams, posting photos, blogs and links to YouTube and the ability for participants to comment on everything. Leaderboards for individuals, teams, workplaces, and others were implemented on the website in order to create a sense of competition, to boost the overall outcome of the campaign.
Rails, the Cloud and Kanban accelerate development
Ruby on Rails was used as the base of the technical stack, as its built-in capabilities and plugins would accelerate coding. Heroku, a flexible cloud-based hosting platform for Ruby applications, was selected to host the new site. With those decisions in place, developers started establishing the development, QA and production environments in parallel, and setting up the continuous delivery infrastructure.
Development proceeded using agile and Continuous Design techniques. The user experience design was created on a just- in-time basis for each development iteration, with the business team then giving feedback during each showcase of the working software. Using automated deployments and testing, updates could be made very quickly.
Kanban was used to manage requirements. With this approach, the team maintained a prioritised backlog of features to be developed. Developers pulled features from the backlog in priority order so the highest priority features are always being coded and tested during any given iteration. When “enough” new features were ready, the team made a decision to do an internal or external release.
You need it in three months? How about six weeks.
The first external release of the website came just six weeks after the inception, with a sufficient set of features, organisation branding, and user experience elements. The team had been working to launch in time for University orientation week, but late in the game the client realised they had made a mistake with dates. Could we move the release up?
We were able to release on the new date, thanks to the level of test and deployment automation and the reliability of the continuous delivery processes. We launched the new website in time for the first orientation week campaign.
Over the next nine weeks, 26 more releases to production were performed, with each including extra functionality and design changes.


I help companies get “digital” right. I design digital products that your developers can actually implement, while I help you answer your most burning digital strategy questions, like:
“What do we create, for whom & why?” & “How can we optimize customer experience & business profit at the same time?”
SEE MY WORK


The Interview Game
The Interview Game is an improv comedy game designed to connect families, friends, and teams from afar for a few laughs. Create your own room utilizing websockets, and play using our premmade card deck. Custom cards coming soon!
Link to Deployed App:
Link to Github Repo:
Eat Da Burger!
This application (deployed on heroku) allows the user to communicate with a server in order to add eat and cook their favorite burgers.
Link to Deployed App:
Link to Github Repo:
Team Page Generator CLI
Quickly build an HTML page from your terminal by entering the details of your team into this CLI.
Link to Github Repo:
ReadMe Generator
Create a professional README.md for your project in seconds using my CLI.
Link to Github Repo:
Begin your Adventure
Fast and accurate National Park and weather data for every state!
Link to deployed site:
Link to Github Repo:
Weather Dashboard
Entire any city to get its current weather and 5 day forecast!
Link to deployed site:
Link to Github Repo:
Work Day Scheduler
Plan out your day saveable notes and time block indicator!
Link to deployed site:
Link to Github Repo:
Timed Javascript Quiz
Answer all 5 questions before time runs out! Saves highscores.
Link to deployed site:
Link to Github Repo:
Secure Password Generator
Set your own criteria and generate a secure password automatically!
Link to deployed site:
Link to Github Repo:


| Country | Result | Country | Group | Place A Bet | ||||
|---|---|---|---|---|---|---|---|---|
| Brazil | 1 - 3 | Mexico | A | Brazil | - | Mexico | ||
| Spain | 1 - 5 | Netherlands | B | Spain | - | Netherlands | ||
| Italy | 2 - 1 | England | C | Italy | - | England | ||
| Argentina | - | Bosnia and Herz | F | Argentina | - | Bosnia and Herz | ||
| Germany | - | Portugal | E | Germany | - | Portugal |


DocumentationAnalyzers Status
This page is reporting the current status of
DocumentationAnalyzers
Category
ID
Title
Severity
Status
Code Fix
Fix All Provider


people who ...
... of audio on the web
Michel Buffa, Attila Haraszti, Andrew MacPherson, me, and you!


CANopenNode is designed to run in different threads, as described in README.md. Threads are implemented differently in different systems. In microcontrollers threads are interrupts with different priorities, for example. It is necessary to protect sections, where different threads access to the same resource. In simple systems interrupts or scheduler may be temporary disabled between access to the shared resource. Otherwise mutexes or semaphores can be used. More...
Macros | |
| #define | CO_LOCK_CAN_SEND() |
| Lock critical section in CO_CANsend() | |
| #define | CO_UNLOCK_CAN_SEND() |
| Unlock critical section in CO_CANsend() | |
| #define | CO_LOCK_EMCY() |
| Lock critical section in CO_errorReport() or CO_errorReset() | |
| #define | CO_UNLOCK_EMCY() |
| Unlock critical section in CO_errorReport() or CO_errorReset() | |
| #define | CO_LOCK_OD() |
| Lock critical section when accessing Object Dictionary. | |
| #define | CO_UNLOCK_OD() |
| Unock critical section when accessing Object Dictionary. | |
| #define | CO_FLAG_READ(rxNew) ((rxNew) != NULL) |
| Check if new message has arrived. | |
| #define | CO_FLAG_SET(rxNew) { __sync_synchronize(); rxNew = (void *)1L; } |
| Set new message flag. | |
| #define | CO_FLAG_CLEAR(rxNew) { __sync_synchronize(); rxNew = NULL; } |
| Clear new message flag. | |
CANopenNode is designed to run in different threads, as described in README.md. Threads are implemented differently in different systems. In microcontrollers threads are interrupts with different priorities, for example. It is necessary to protect sections, where different threads access to the same resource. In simple systems interrupts or scheduler may be temporary disabled between access to the shared resource. Otherwise mutexes or semaphores can be used.
Functions CO_CANsend() from C_driver.h, CO_errorReport() from CO_Emergency.h and CO_errorReset() from CO_Emergency.h may be called from different threads. Critical sections must be protected. Either by disabling scheduler or interrupts or by mutexes or semaphores.
In general, there are two threads, which accesses OD variables: mainline and timer. CANopenNode initialization and SDO server runs in mainline. PDOs runs in faster timer thread. Processing of PDOs must not be interrupted by mainline. Mainline thread must protect sections, which accesses the same OD variables as timer thread. This care must also take the application. Note that not all variables are allowed to be mapped to PDOs, so they may not need to be protected. SDO server protects sections with access to OD variables.
After CAN message is received, it is pre-processed in CANrx_callback(), which copies some data into appropriate object and at the end sets new_message flag. This flag is then pooled in another thread, which further processes the message. The problem is, that compiler optimization may shuffle memory operations, so it is necessary to ensure, that new_message flag is surely set at the end. It is necessary to use Memory barrier.
If receive function runs inside IRQ, no further synchronization is needed. Otherwise, some kind of synchronization has to be included. The following example uses GCC builtin memory barrier __sync_synchronize()
. More information can be found here.


A name is required
A start date is required
A finish date is required
{{ sprint.date_start }} - {{ sprint.date_finish }}


aircrack-ng
Crack WEP and WPA/WPA2 keys from handshake in captured packets.
Part of Aircrack-ng network software suite.
More information: home page
- Crack key from capture file using [w]ordlist:
aircrack-ng -w path/to/wordlist.txt path/to/capture.cap
- Crack key from capture file using [w]ordlist and the access point's [e]ssid:
aircrack-ng -w path/to/wordlist.txt -e essid path/to/capture.cap
- Crack key from capture file using [w]ordlist and the access point's MAC address:
aircrack-ng -w path/to/wordlist.txt --bssid mac path/to/capture.cap


---
layout: post
title: Blog Migration
date: '2017-03-30'
author: geoff purdy
tags:
modified_time: '2017-03-30'
---
Welcome to geoffpurdy.net
It is a Jekyll site hosted on Github Pages using a custom domain. The theme is courtesy of Panos Sakkos.
Despite the goodness of Github Pages support for Jekyll, HTTPS is unsupported for custom domains. The workaround for that is putting the Github Pages site behind CloudFlare CDN. Sign up for an account, a few DNS changes and voila HTTPS.
Email for the domain is handled by Zoho
Possibly the best part, all of the above can be had for free.
The background image is a photograph I took at the Museum of Life and Science in Durham.
My old blog was exported from google blogger as xml. Then converted to jekyll with the jekyll-import ruby gem.


Learn how to look up sick and vacation time, enter your hours in Workday, set up direct deposit, and more.


Ontology highlight
ABSTRACT:
0" id="reanalisys_of"> REANALYSIS of: {{s['reanalysis'].accession}} 99">(first 100 items shown)
0" id="reanalisys_by"> REANALYSED by: {{s['reanalysis'].accession}} 99">(first 100 items shown)
0" id="relate_omics"> OTHER RELATED OMICS DATASETS IN: {{s['reanalysis'].accession}}
INSTRUMENT(S): {{d.instruments.join(", ")}}
ORGANISM(S): {{o.name}}
TISSUE(S): {{d.tissues.join(", ")}}
0" id="diseases"> DISEASE(S): {{d.diseases}}
SUBMITTER: {{o}} {{o}}
LAB HEAD: {{d.labHead}}
PROVIDER: {{d.id}} | {{repositoryName}} | {{d.publicationDate}}
SECONDARY ACCESSION(S): 1" href="{{o.substring(o.indexOf('~')+1)}}"> {{o.substring(0, o.indexOf('~'))}} {{o}}
REPOSITORIES: {{o}}{{isLast ? '' : ', '}}
Sorry, this is not working properly. The dataset couldn't be found.
We're working to fix this. In the meantime, here is what you can do:


Pathgl implements a scenegraph with svg semantics. Documented here is a list of discrepancies between the pathGL virtualDOM and the SVG 1.1 Specification. Expect this list to get shorter and eventually disappear completely.
defs are not yet implemented. descriptions and symbols are not yet implemented use, image, and switch elements are not yet implemented
styling is not currently supported except via
pathgl.applyCSSRules()
numeric attributes must have a value equal to or greater than zero. transform attributes are not yet implemented
curve, cubic bezier, quadratic bezier, and elliptical arc commands are not yet implemented.
polyline and polygon elements are not yet implemented
text is not yet implemented
marker symbols are not yet implemented rendering hints are not yet implemented
color profiles are not yet implemented
gradients and patterns are not yet implemented
clipping and masking are not yet implemented
filter effects are not yet implemented
pointer-events are not stylable yet cursor property is not yet implemented
linking is not yet implemented
eventlisteners must be added with the AddEventListener method. eventListeners cannot be defined as attributes such as "onclick"
animation attributes are not yet implemented
foreign namespaces and private data are not yet implemented
Metadata elements are not yet implemented


---
layout: base
title: Projects
css: "/css/projects.css"
---
Projects
REAL-TIME PORTRAIT SEGMENTATION
A CNN for real-time human portrait segmentation trained on a custom dataset of several thousands of images.
Variational 3d reconstruction
A global 3d reconstruction engine based on a variational framework aimed specifically to scenes with few texture details.
Multi-View Segmentation
A segmentation algorithm for multi-view datasets that separates foreground/background of all images given few strokes on a small subset of the dataset.
ILIOS 3D SUITE
End-user application for Ilios 3D printers that manages the entire printing process: input placement, automatic slicing, shell and supports creation.
RUJU 3D RECONSTRUCTION PLATFORM
A multi-user platform for 3D reconstruction from 3D scanner data and photographs, featuring data alignment, fusion, mesh generation and georeferentiation.
NAVIONICS CHARTS
A multiresolution 3D reconstruction engine fusing data coming from different sources like bathymetry lines or LiDAR scans.
Quipu Cardiovascular Suite
A multi-platform (Windows, Mac OS, Linux) application for real-time display and analysis of live video streams from stored media or external devices.
Emb3D - 3D Viewer
Emb3D is one of the most downloaded 3d viewers on both iOS and Android, it features several rendering options and an intuitive gesture interface.
Quick3D - Mobile 3D Reconstructor
A 3d reconstructor that runs directly on mobile devices with which you can easily acquire the shape and texture of (for now) small objects.
Planar Tracking for AR
A planar tracker for real-time Augmented Reality on mobile devices. Optimized with SIMD instructions, it runs fast even on modest hardware.
GPU Ambient Obscurance
A GPU approach for the computation of ambient obscurance in MeshLab.
GPU Shape Diameter Function
A GPU approach for the computation of the shape diamter function in MeshLab.


Simple, fast generation of RFC4122 UUIDS.
Features:
shell
npm install uuid
```javascript // Generate a v1 UUID (time-based) const uuidV1 = require(‘uuid/v1’); uuidV1(); // -> ‘6c84fb90-12c4-11e1-840d-7b25c5ee775a’
// Generate a v4 UUID (random) const uuidV4 = require(‘uuid/v4’); uuidV4(); // -> ‘110ec58a-a0f2-4ac4-8393-c866d813b8d1’ ```
Browser-ready versions of this module are available via wzrd.in.
```html
```
(Note: Do not do this in production. Just don’t. wzrd.in is a great service, but if you’re deploying a “real” service you should be using a packaging tool like browserify or webpack. If you do go this route you would be well advised to link to a specific version instead of uuid@latest
to avoid having your code break when we roll out breaking changes.)
Generate a V4 uuid. See uuid.v4 documentation below.
options
[, buffer
[, offset
]]])Generate and return a RFC4122 v1 (timestamp-based) UUID.
options
- (Object) Optional uuid state to apply. Properties may include:
node
- (Array) Node id as Array of 6 bytes (per 4.1.6). Default: Randomly generated ID. See note 1.clockseq
- (Number between 0 - 0x3fff) RFC clock sequence. Default: An internally maintained clockseq is used.msecs - (Number |
Date) Time in milliseconds since unix Epoch. Default: The current time is used. |
nsecs
- (Number between 0-9999) additional time, in 100-nanosecond units. Ignored if msecs
is unspecified. Default: internal uuid counter is used, as per <IP_ADDRESS>.buffer - (Array |
Buffer) Array or buffer where UUID bytes are to be written. |
offset
- (Number) Starting index in buffer
at which to begin writing.Returns buffer
, if specified, otherwise the string form of the UUID
Notes:
Example: Generate string UUID with fully-specified options
javascript
uuid.v1({
node: [0x01, 0x23, 0x45, 0x67, 0x89, 0xab],
clockseq: 0x1234,
msecs: new Date('2011-11-01').getTime(),
nsecs: 5678
}); // -> "710b962e-041c-11e1-9234-0123456789ab"
Example: In-place generation of two binary IDs
javascript
// Generate two ids in an array
const arr = new Array(32); // -> []
uuid.v1(null, arr, 0); // -> [02 a2 ce 90 14 32 11 e1 85 58 0b 48 8e 4f c1 15]
uuid.v1(null, arr, 16); // -> [02 a2 ce 90 14 32 11 e1 85 58 0b 48 8e 4f c1 15 02 a3 1c b0 14 32 11 e1 85 58 0b 48 8e 4f c1 15]
options
[, buffer
[, offset
]]])Generate and return a RFC4122 v4 UUID.
options
- (Object) Optional uuid state to apply. Properties may include:
random
- (Number[16]) Array of 16 numbers (0-255) to use in place of randomly generated valuesrng
- (Function) Random # generator to use. Set to one of the built-in generators - uuid.mathRNG
(all platforms), uuid.nodeRNG
(node.js only), uuid.whatwgRNG
(WebKit only) - or a custom function that returns an array[16] of byte values.buffer - (Array |
Buffer) Array or buffer where UUID bytes are to be written. |
offset
- (Number) Starting index in buffer
at which to begin writing.Returns buffer
, if specified, otherwise the string form of the UUID
Example: Generate string UUID with fully-specified options
javascript
uuid.v4({
random: [
0x10, 0x91, 0x56, 0xbe, 0xc4, 0xfb, 0xc1, 0xea,
0x71, 0xb4, 0xef, 0xe1, 0x67, 0x1c, 0x58, 0x36
]
});
// -> "109156be-c4fb-41ea-b1b4-efe1671c5836"
Example: Generate two IDs in a single buffer
javascript
const buffer = new Array(32); // (or 'new Buffer' in node.js)
uuid.v4(null, buffer, 0);
uuid.v4(null, buffer, 16);
npm test
The code for the legacy node-uuid package is available in the node-uuid
branch.


ESPN Analyst Thanks Tom Herman For Not Taking The LSU Job
by Andrew HolleranLSU pursued then-Houston head coach Tom Herman back in 2016 after firing Les Miles. The Tigers expressed interest in Herman, though he said no to a potential meeting, as he was leaning toward the Texas job, which he ended up getting.
Three years later, LSU is being led toward the College Football Playoff by Ed Orgeron. Texas is 6-5, barely making a bowl game.
ESPN analyst Ryan Clark, an LSU alum, had a message for Herman following Saturday’s game. The message is a simple one: Thank you.
“As a LSU alum I would like to thank you Tom Herman. A few years back you made the decision I never knew I wanted you to make. You chose Texas & for that I am grateful,” he tweeted.
Welp, he’s not wrong.
Many questioned LSU’s decision to go with Coach O back in 2016, though he’s proven to be a massive success. Herman, meanwhile, was arguably the hottest name in coaching at Houston. He’s been at Texas for three seasons and has yet to elevate the Longhorns to an elite level.
LSU beat Texas earlier this season, 45-38. The Tigers will host the Longhorns in a rematch in Baton Rouge next September.


| 024:046 Khan | : |
We have indeed sent down (in this Qur'an) manifest Ayat (proofs, evidences, verses, lessons, signs, revelations, lawful and unlawful things, and the set boundries of Islamic religion, etc. that make things clear showing the Right Path of Allah). And Allah guides whom He wills to a Straight Path (i.e. to Allah's religion of Islamic Monotheism). |
| 024:046 Maulana | : |
We have indeed revealed clear messages. And Allah guides whom He pleases to the right way. |
| 024:046 Pickthal | : |
Verily We have sent down revelations and explained them. Allah guideth whom He will unto a straight path. |
| 024:046 Rashad | : |
We have sent down to you clarifying revelations, then GOD guides whoever wills (to be guided) in a straight path. |
| 024:046 Sarwar | : |
We have revealed illustrious revelations. God guides to the right path whomever He wants. |
| 024:046 Shakir | : |
Certainly We have revealed clear communications, and Allah guides whom He pleases to the right way. |
| 024:046 Sherali | : |
WE have indeed sent down manifest Signs. And ALLAH guides whom HE pleases to the right path. |
| 024:046 Yusufali | : |
We have indeed sent down signs that make things manifest: and Allah guides whom He wills to a way that is straight. |
Concepts/Themes Covered: أركان الإسلام > الدين > حقيقة الإسلام Pillars of Islam> Religion> The Reality of Islam الإيمان > الإيمان بالله > الهداية إلى الإيمان Faith> Belief In Allah> Guiding to Faith الإيمان > الله جلّ جلاله > فضله جلّ وعلا Faith> Allah, Glory to his Majesty> His Graciousness
This tool uses eight English parallel translations for the Holy Quran imported from Mr. Clay Smith. You can also visit Qurany Concepts for browsing the Quran themes or topics. If you want to search the Holy Quran for keywords, please visit Qurany Keywords.


WolframAlpha is a computational knowledge engine with vast data stores of information and the ability to interpret complex queries and mathematical formulas.
BETAPlease note that this feature is currently in BETA and subject to change and my become temporarily unavailable.
Nimbits integrates into WolframAlpha, allowing you to configure a data points to trigger a computation whenever it receives a new value. The result is then stored in a target Point. The result is that you can add intelligence to your software and hardware projects, using Nimbits' ability to relay, share and store your data streams and WolframAlpha's ability to understand and compute it.
I have two data points called "foo" and "bar" and i'm feeding a temperature in fahrenheit into it. Whenever foo gets a new value, I want to run an equation to convert foo's value to celsius and store the result in "bar"
Logging into Nimbits, i can right click my data point named "foo" and select the "Intelligence" tab. Here, i enter the formula for converting fahrenheit to celsius, but for the value i put the point name.value in brackets: ([foo.value] -32) * (5/9)
Now whenever foo gets a new value recorded, the value will get converted and stored in bar. You can try your formula first on wolframalpha.com, or find more advanced formulas on http://www.wolframalpha.com/examples/ For example phi([foo.value]) will get the results of this number-theoretic functions
A Nimbits Data Point stores a history of Value Objects. Value objects can contain a number value, like the celsius value above. A GPS coordinate, an Annotation (text), and a raw data value (JSON Or XML) that can be any sort of data you like. In fact the Nimbits SDK allows you to directly store Programming Object directly into a Point.
In This example, whenever foo is written to, we're going to store the result as string data in the point, instead of a number. This example shows getting the current stock price for Google and storing it as data in another point.
Note the option selected to record the result as text data and the Pod Id to pull the Quote section from the response we get from WolframAlpha. Pod Id tells Nimbits what portion of the response you want to store in your point. You can learn more about it here http://products.wolframalpha.com/api/documentation.html
Finally, checking off that I want the result in plain text gives me:
[$561.37(GOOG | NASDAQ | Friday 12:59:58 pm EST | 2 days 7 hrs ago)]
Unchecking the "Result in plain text box" gives me the data in XML.


A set of tools for displaying, modeling and analysing multivariate abundance data in community ecology. See 'mvabund-package.Rd' for details of overall package organization. The package is implemented with the Gnu Scientific Library (<http://www.gnu.org/software/gsl/>) and 'Rcpp' (<http://dirk.eddelbuettel.com/code/rcpp.html>) 'R' / 'C++' classes.
| Version: | 3.13.1 |
| Depends: | R (≥ 3.0.0) |
| Imports: | Rcpp, MASS, methods, stats, tweedie, statmod, parallel |
| LinkingTo: | Rcpp, RcppGSL |
| Published: | 2018-01-19 |
| Author: | Yi Wang [aut], Ulrike Naumann [aut], Dirk Eddelbuettel [aut], David Warton [aut, cre], Julian Byrnes [ctb], Ralph dos Santos Silva [ctb, cph], Jenni Niku [ctb], Ian Renner [ctb], Stephen Wright [ctb] |
| Maintainer: | David Warton <David.Warton at unsw.edu.au> |
| License: | LGPL-2.1 | LGPL-3 [expanded from: LGPL (≥ 2.1)] |
| NeedsCompilation: | yes |
| Materials: | README |
| CRAN checks: | mvabund results |
| Reference manual: | mvabund.pdf |
| Package source: | mvabund_3.13.1.tar.gz |
| Windows binaries: | r-devel: mvabund_3.13.1.zip, r-release: mvabund_3.13.1.zip, r-oldrel: mvabund_3.13.1.zip |
| OS X binaries: | r-release: mvabund_3.13.1.tgz, r-oldrel: mvabund_3.13.1.tgz |
| Old sources: | mvabund archive |
| Reverse depends: | gllvm, mglmn |
| Reverse imports: | optimus |
| Reverse suggests: | boral, PLSbiplot1 |
Please use the canonical form https://CRAN.R-project.org/package=mvabund to link to this page.


Toggle navigation
Genesis
1
A-
A+
Translation
2x
3x
4x
Save
×
Books
ALL
OT
NT
×
Chapters
×
Login
Enter the API Key to start using Autographer
×
×
Export Option
Choose Stage
Stage 1
Stage 2
Stage 3
Stage 4
Stage 5
×
Search Text:
Current Chapter
All Chapters
Find:
Replace With:
×
Information!!


public static class DataLine.Info extends Line.Info
DataLine.Info
provides additional information specific to data lines.
This information includes:
Line.Info
knows the class of the line its describes, a
DataLine.Info
object can describe DataLine
subinterfaces such as SourceDataLine
,
TargetDataLine
, and Clip
.
You can query a mixer for lines of any of these types, passing an appropriate
instance of DataLine.Info
as the argument to a method such as
Mixer.getLine(Line.Info)
.Line.Info
| Constructor and Description |
|---|
Info(Class<?> lineClass,
AudioFormat format)
Constructs a data line's info object from the specified information,
which includes a single audio format.
|
Info(Class<?> lineClass,
AudioFormat[] formats,
int minBufferSize,
int maxBufferSize)
Constructs a data line's info object from the specified information,
which includes a set of supported audio formats and a range for the buffer size.
|
Info(Class<?> lineClass,
AudioFormat format,
int bufferSize)
Constructs a data line's info object from the specified information,
which includes a single audio format and a desired buffer size.
|
| Modifier and Type | Method and Description |
|---|---|
AudioFormat[] |
getFormats()
Obtains a set of audio formats supported by the data line.
|
int |
getMaxBufferSize()
Obtains the maximum buffer size supported by the data line.
|
int |
getMinBufferSize()
Obtains the minimum buffer size supported by the data line.
|
boolean |
isFormatSupported(AudioFormat format)
Indicates whether this data line supports a particular audio format.
|
boolean |
matches(Line.Info info)
Determines whether the specified info object matches this one.
|
String |
toString()
Obtains a textual description of the data line info.
|
getLineClass
public Info(Class<?> lineClass, AudioFormat[] formats, int minBufferSize, int maxBufferSize)
lineClass
- the class of the data line described by the info objectformats
- set of formats supportedminBufferSize
- minimum buffer size supported by the data line, in bytesmaxBufferSize
- maximum buffer size supported by the data line, in bytespublic Info(Class<?> lineClass, AudioFormat format, int bufferSize)
lineClass
- the class of the data line described by the info objectformat
- desired formatbufferSize
- desired buffer size in bytespublic Info(Class<?> lineClass, AudioFormat format)
lineClass
- the class of the data line described by the info objectformat
- desired formatpublic AudioFormat[] getFormats()
isFormatSupported(AudioFormat)
might return
true
for certain additional formats that are missing from
the set returned by getFormats()
. The reverse is not
the case: isFormatSupported(AudioFormat)
is guaranteed to return
true
for all formats returned by getFormats()
.
Some fields in the AudioFormat instances can be set to
NOT_SPECIFIED
if that field does not apply to the format,
or if the format supports a wide range of values for that field.
For example, a multi-channel device supporting up to
64 channels, could set the channel field in the
AudioFormat
instances returned by this
method to NOT_SPECIFIED
.isFormatSupported(AudioFormat)
public boolean isFormatSupported(AudioFormat format)
true
if
the specified format matches any of the supported formats.format
- the audio format for which support is queried.true
if the format is supported, otherwise false
getFormats()
,
AudioFormat.matches(javax.sound.sampled.AudioFormat)
public int getMinBufferSize()
AudioSystem.NOT_SPECIFIED
public int getMaxBufferSize()
AudioSystem.NOT_SPECIFIED
public boolean matches(Line.Info info)
Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2015, Oracle and/or its affiliates. All rights reserved.