How we use symlinks¶
Read the Docs stays highly available by serving all documentation pages out of nginx. This means that they never hit our Python layer, meaning that they never hit our database. This reduces the total number of servers to serve a request to 1, each of which is redundant.
Nginx¶
We handle a couple of different types of requests in nginx:
- Requests to a readthedocs.org subdomain
- Requests to a CNAME
Subdomains¶
For subdomains this is a simple lookup. This doesn’t require symlinks, but it shows the basic logic that we need to replicate.
When a user navigates to http://pip.readthedocs.org/en/latest/
,
we know that they want the pip documentation.
So we simply serve them the documentation:
location ~ ^/en/(.+)/(.*) {
alias /home/docs/checkouts/readthedocs.org/user_builds/$domain/rtd-builds/$1/$2;
error_page 404 = @fallback;
error_page 500 = @fallback;
}
location @fallback {
proxy_pass http://<IP_ADDRESS>:8888;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
add_header X-Deity Asgard;
}
Note
The @fallback
directive is hit when we don’t find the proper file.
This will cause things to hit the Python backend,
so that proper action can be taken.
CNAMEs¶
CNAMEs add a bit of difficulty,
because at the nginx layer we don’t know what documentation to serve.
When someone requests http://docs.fabfile.org/en/latest/
,
we can’t look at the URL to know to serve the fabric
docs.
This is where symlinks come in.
When someone requests http://docs.fabfile.org/en/latest/
the first time,
it hits the Python layer.
In that Python layer we record that docs.fabfile.org
points at fabric
.
When we build the fabric
docs,
we create a symlink for all domains that have pointed at fabric
before.
So,
when we get a request for docs.fabfile.org
in the future,
we will be able to serve it directly from nginx.
In this example,
$host would be docs.fabfile.org
:
location ~ ^/en/(?P<doc_version>.+)/(?P<path>.*) {
alias /home/docs/checkouts/readthedocs.org/cnames/$host/$doc_version/$path;
error_page 404 = @fallback;
error_page 500 = @fallback;
}
Notice that nowhere in the above path is the project’s slug mentioned. It is simply there in the symlink in the cnames directory, and the docs are served from there.


Constructor
new BezierSpline(knots, weights)
Creates a new spline.
Parameters:
| Name | Type | Description |
|---|---|---|
knots |
Array.<Array.<number>> | A list of points of equal dimension that the spline will pass through. |
weights |
weightsCallback | Array.<number> | A callback that calculates weights for a given segment or precalculated weights in an array. The first element of the array will be ignored. |
Methods
getPoints(axis, value) → {Array.<Array.<number>>}
Gets all the points on the spline that match the query.
Parameters:
| Name | Type | Description |
|---|---|---|
axis |
number | The index of the axis along which to solve (i.e. if your vectors are [x, y, z], 0 means solve for when x = value). |
value |
number | The value to solve for (i.e. a Bezier cubic is on the left of an equation and this value is on the right). |
Returns:
A list of all points on the spline where the specified axis is equal to the specified value.
- Type
- Array.<Array.<number>>
Examples
spline.getPoints(0, 10) // Returns all points on the spline where x = 10
spline.getPoints(2, -2) // Returns all points on the spline where z = -2
recalculate()
Recalculates the control points of the spline. Runs on the order of O(n)
operations where n is the number of knots.
setKnots(newKnots)
The easiest way to change the spline's knots. Knots are kept as special
vector types, so setting an entire knot may break the program. Alternately,
you can read the documentation for vecn and manipulate the knots yourself.
Parameters:
| Name | Type | Description |
|---|---|---|
newKnots |
Array.<Array.<number>> | A list of points of equal dimension that the spline will pass through. |


import os
from datetime import datetime
from selenium import webdriver
import webdriver_test_tools
from webdriver_test_tools.common.files import create_directory, validate_filename
[docs]class WebDriverConfig:
"""Configurations for webdriver"""
# Root directory of webdriver_test_tools package
_PACKAGE_ROOT = os.path.dirname(os.path.abspath(webdriver_test_tools.__file__))
#: Path to the log directory. Defaults to the log subdirectory in the
#: ``webdriver_test_tools`` package root directory
LOG_PATH = os.path.join(_PACKAGE_ROOT, 'log')
#: Path to the screenshot directory. Defaults to the screenshot
#: subdirectory in the ``webdriver_test_tools`` package root directory
SCREENSHOT_PATH = os.path.join(_PACKAGE_ROOT, 'screenshot')
SCREENSHOT_FILENAME_FORMAT = '{date}/{time}-{test}-{browser}.png'
"""Format string used to determine filenames for screenshots (relative to
:attr:`WebDriverConfig.SCREENSHOT_PATH`). The format string can include the
following parameters:
* ``{date}``: Replaced with the date the screenshot was taken
(YYYY-MM-DD)
* ``{time}``: Replaced with the time the screenshot was taken
(HHMMSS)
* ``{test}``: Replaced with the test method running when screenshot
was taken
* ``{browser}``: Replaced with the browser used when screenshot was
taken
The format string can include '/' directory separators to save screenshots
in subdirectories of :attr:`WebDriverConfig.SCREENSHOT_PATH`.
"""
DEFAULT_ASSERTION_TIMEOUT=10
"""Default number of seconds for :ref:`WebDriverTestCase assertion methods
<assertion-methods>` to wait for expected conditions to occur before test
fails
"""
# Browser driver initialization arguments
#: Keyword args for ``webdriver.Firefox()``
FIREFOX_KWARGS = {}
#: Keyword args for ``webdriver.Chrome()``
CHROME_KWARGS = {}
#: Keyword args for ``webdriver.Safari()``
SAFARI_KWARGS = {}
#: Keyword args for ``webdriver.Ie()``
IE_KWARGS = {}
#: Keyword args for ``webdriver.Edge()``
EDGE_KWARGS = {}
# Mobile configurations
#: Dictionary with 'mobileEmulation' options for Chrome
CHROME_MOBILE_EMULATION = {"deviceName": "Pixel 2"}
# Headless browser configurations
#: Command line arguments to use in addition to the ``--headless`` flag
CHROME_HEADLESS_ARGS = ['--window-size=1920x1080']
#: Command line arguments to use in addition to the ``-headless`` flag
FIREFOX_HEADLESS_ARGS = []
# Methods
[docs] @classmethod
def get_firefox_driver(cls, headless=False):
"""Returns ``webdriver.Firefox`` object using :attr:`FIREFOX_KWARGS` and :attr:`LOG_PATH` to
initialize
:param headless: (Default = False) If True, configure driver to run a
headless browser
"""
log_path = os.path.join(cls.LOG_PATH, 'geckodriver.log')
options = cls._get_firefox_headless_options() if headless else None
return webdriver.Firefox(log_path=log_path, options=options,
**cls.FIREFOX_KWARGS)
[docs] @classmethod
def get_chrome_driver(cls, headless=False):
"""Returns ``webdriver.Chrome`` object using :attr:`CHROME_KWARGS` and :attr:`LOG_PATH` to
initialize
:param headless: (Default = False) If True, configure driver to run a
headless browser
"""
service_log_path = os.path.join(cls.LOG_PATH, 'chromedriver.log')
options = cls._get_chrome_headless_options() if headless else None
return webdriver.Chrome(service_log_path=service_log_path,
options=options, **cls.CHROME_KWARGS)
[docs] @classmethod
def get_safari_driver(cls):
"""Returns ``webdriver.Safari`` object using :attr:`SAFARI_KWARGS` to initialize"""
return webdriver.Safari(**cls.SAFARI_KWARGS)
[docs] @classmethod
def get_ie_driver(cls):
"""Returns ``webdriver.Ie`` object using :attr:`IE_KWARGS` and :attr:`LOG_PATH` to initialize"""
log_file = os.path.join(cls.LOG_PATH, 'iedriver.log')
return webdriver.Ie(log_file=log_file, **cls.IE_KWARGS)
[docs] @classmethod
def get_edge_driver(cls):
"""Returns ``webdriver.Edge`` object using :attr:`EDGE_KWARGS` and :attr:`LOG_PATH` to initialize"""
log_path = os.path.join(cls.LOG_PATH, 'edgedriver.log')
return webdriver.Edge(log_path=log_path, **cls.EDGE_KWARGS)
[docs] @classmethod
def get_chrome_mobile_driver(cls, headless=False):
"""Returns ``webdriver.Chrome`` object using :attr:`CHROME_KWARGS`, :attr:`LOG_PATH`, and
:attr:`CHROME_MOBILE_EMULATION` to initialize
:param headless: (Default = False) If True, configure driver to run a
headless browser
"""
service_log_path = os.path.join(cls.LOG_PATH, 'mobile_chromedriver.log')
options = webdriver.ChromeOptions()
options.add_experimental_option("mobileEmulation", cls.CHROME_MOBILE_EMULATION)
if headless:
options.add_argument('--headless')
return webdriver.Chrome(service_log_path=service_log_path,
options=options, **cls.CHROME_KWARGS)
# Driver Options
@classmethod
def _get_firefox_headless_options(cls):
"""Returns FirefoxOptions with -headless argument and arguments from
FIREFOX_HEADLESS_ARGS set
"""
options = webdriver.FirefoxOptions()
for arg in cls.FIREFOX_HEADLESS_ARGS:
options.add_argument(arg)
options.add_argument('-headless')
return options
@classmethod
def _get_chrome_headless_options(cls):
"""Returns ChromeOptions with --headless argument and arguments from
CHROME_HEADLESS_ARGS set
"""
options = webdriver.ChromeOptions()
for arg in cls.CHROME_HEADLESS_ARGS:
options.add_argument(arg)
options.add_argument('--headless')
return options
# Misc
[docs] @classmethod
def new_screenshot_file(cls, browser_name, test_name, makedirs=True):
"""Return the full path and filename for the screenshot
The filename is determined by the format set in
:attr:`WebDriverConfig.SCREENSHOT_FILENAME_FORMAT`. If the format doesn't
end with '.png', the extension will be appended to the resulting
filename
:param browser_name: Name of the browser (for screenshot filename)
:param test_name: Name of the current test (for screenshot filename)
:param makedirs: (Default = True) If True, create any subdirectories of
screenshot/ if they don't already exist
:return: Filename for the screenshot
"""
now = datetime.now()
path = cls.SCREENSHOT_FILENAME_FORMAT.format(
date=now.strftime('%Y-%m-%d'),
time=now.strftime('%H%M%S'),
test=test_name,
browser=browser_name
)
# Ensure .png extension is present
if not path.lower().endswith('.png'):
path += '.png'
# Validate string characters for file name
filename = validate_filename(os.path.basename(path))
# Get any subdirectory names
dirname = os.path.dirname(path)
# Create subdirectories if they don't already exist
if makedirs:
create_directory(cls.SCREENSHOT_PATH, dirname)
return os.path.join(cls.SCREENSHOT_PATH, dirname, filename)


Colour Magnitude Diagrams¶
Download all the Jupyter notebooks from: https://github.com/HeloiseS/hoki/tree/master/tutorials
Initial Imports¶
[1]:
import matplotlib.pyplot as plt
from hoki.cmd import CMD
from hoki.load import set_models_path, unpickle
import pickle
import numpy as np
%matplotlib inline
plt.style.use('tuto.mplstyle')
Getting the Stellar models and input files¶
Colour Magnitude Diagrams (CMDs) are created by reading in the BPASS stellar models listed in the model_input
files that can be found in the BPASS output folders (e.g. bpass_v2.2.1_imf135_300). These stellar models are in a separate directory (because it is absolutely massive), so you will have to download it separately if you want to run the following cells or make your own CMDs.
**NOTE: You will be able to run the cells in the section “Loading a pickled CMD file” even if you can’t download the full set of stellar models **
The stellar models and input files can be downloaded from the google drive (bpass-v2.2-newmodels for the models and e.g. bpass_v2.2.1_imf135_300 to get the required model_input
files). Then you will have to change the path to the models in the settings.yaml
file – this can be done using the set_models_path
function contained in the hoki.load
module:
[2]:
# The following path is valid on my machine - make sure you put the right ABSOLUTE path for your system
set_models_path(path='/home/fste075/BPASS_hoki_dev/bpass-v2.2-newmodels/')
Looks like everything went well! You can check the path was correctly updated by looking at this file:
/home/fste075/hoki/hoki/data/settings.yaml
NOTE: You’ll probably have to reload hoki or restart the kernel at this point if you’ve jsut updated the yaml file :)
CMD objects¶
Making the CMDs¶
To create a synthetic CMD, hoki
creates a grid in colour-magnitude space and then consults the entire set of stellar models to fill that grid. It is basically a histogram - the value of each cell/bin increases according to the proportion of the stellar population that falls into that bin. You could just plot this grid with a colour-map like an image, but we traditionally create contour plots for visualisation.
In hoki
you will be creating a CMD()
object instanciated with a model of your choosing (a particular IMF and metallicity)- for this you need to provide the location of a BPASS input file.
To know WHAT to do with this information, we also need to give the two broad-band filters we are interested in to make the plot filter2 Vs filter1-filter2 (e.g. V Vs B-V). This is given in the CMD.make()
method, which actually creates and fills the CMD grids.
NOTE: This step is the most time consuming because there are thousands and thousands of models to look at. For that reason it also take much longer for the binary stellar models than the single star models to make a CMD. In the next section we will show you how to avoid having to go repeat his step in the future
The good news is that once you have instanciated and ‘made’ the CMD object, plotting it is VERY fast and you have a CMD for each time bin, which are also trivial and quick to access.
[3]:
# ONLY RUN IF YOU HAVE THE MODELS IN YOUR MACHINE
# Update this path if you want to run this cell
input_file = '/home/fste075/BPASS_hoki_dev/bpass_v2.2.1_imf135_300/input_bpass_z020_bin_imf135_300'
mycmd = CMD(input_file)
# actually makes and fills the grids - this is the time and memory consuming step
mycmd.make(mag_filter='V', col_filters=['B', 'V'])
/home/fste075/hoki/hoki/cmd.py:191: RuntimeWarning: divide by zero encountered in log10
self._log_ages = np.concatenate((np.array([0]), np.log10(self._my_data[1,1:])))
/home/fste075/hoki/hoki/cmd.py:207: RuntimeWarning: divide by zero encountered in log10
self._log_ages = np.concatenate((np.array([0]), np.log10(self._my_data[1,1:])))
Below is a summary illustration of what the synthetic CMDs are and what a CMD()
instance is.

Changing the resolution of the CMD grids¶
As we can see we have 51 time bins, 240 magnitude intervals and 100 colour intervals.
The number of time bins is fixed by BPASS but you can chose the size of your colour-magnitude grid and its resolution when you instanciate a CMD
object.
[ ]:
blurry_cmd = CMD(input_file, col_lim=[-3, 7], mag_lim=[-14, 10], res_el=0.75)
blurry_cmd.make(mag_filter='V', col_filters=['B', 'V'])
Plotting the CMDs¶
Like I said above, once the grid is made and filled, plotting is quick and straight forward. As in other hoki
tools the plotting function returns the plot, which you can store in a variable to add your own labels and customize limits.
Similarly to the hoki.HRDiagrams
plots, the contours are on a log scale.
[ ]:
plt.figure(figsize=(8,6))
myplot = mycmd.plot(log_age=6.8) # Here you can chose the time bin you want to plot.
myplot.set_xlim([-1,2.0])
myplot.set_ylim([2,-10])
As with the HRDiagrams, you can also tell the plotting function where your want it to plot your data!
[ ]:
fig, ax = plt.subplots(1,2, figsize=(15,5))
mycmd.plot(log_age=6.8, loc=ax[0]) # Here you can chose the time bin you want to plot.
ax[0].set_xlim([-3,3.0])
ax[0].set_ylim([2,-10])
ax[0].set_title('High resolution')
blurry_cmd.plot(log_age=6.8, loc=ax[1]) # Here you can chose the time bin you want to plot.
ax[1].set_xlim([-3,3.0])
ax[1].set_ylim([2,-10])
ax[1].set_title('Low resolution')
Pickle CMDs - don’t make them twice!¶
Because it is a little time consuming to create the synthetic CMDs, we actually recommend you pickle your CMD objects. This will allow you to re-use them in the future and plot them virtually instantly, by-passing the CMD.make()
step.
Loading a pickled CMD file¶
We’ve provided a couple of pickled CMD files in the ./data/cmds/
directory for you to try even if you couldn’t download the full sets of stellar models.
[ ]:
pickled_cmd = unpickle(path='./data/cmds/cmd_bv_z020_bin_imf135_300')
[ ]:
plt.figure(figsize=(8,6))
myplot = pickled_cmd.plot(log_age=6.8)
myplot.set_xlim([-1,2.0])
myplot.set_ylim([2,-10])
Pickling a CMD file¶
Now let’s make your own pickle file! If you have the stellar models and made the CMD in the previous sections of this tutorial, you can now save your work!
All you need is the following code (feel free to change the output file name).
[ ]:
# First we open a file we can write into
outfile = open('./data/cmds/BV_CMD.pckl', 'wb')
# Then we call the 'dump' function from the pickle module to dump our cmd in our output file
pickle.dump(mycmd, outfile)
# And to avoid funny business we close our file.
outfile.close()
[ ]:
new_pickled_cmd = unpickle(path='./data/cmds/BV_CMD.pckl')
plt.figure(figsize=(8,6))
myplot = new_pickled_cmd.plot(log_age=6.8)
myplot.set_xlim([-1,2.0])
myplot.set_ylim([2,-10])
Creating a publication-ready figure¶
Just like with the HRDiagrams, the tool provided by hoki
will allow you to make publication ready figures in not time!
Let’s make a plot comparing the CMDs for Cygnus OB2 and Upper Sco in B-V and U-V plots.
First we need to load our data (which is provided in the ./data/cmds/ repository) - we also need to make sure our observational data is in absolute magnitude, because that’s what our synthetic CMDs provide. If extinction is important in your osbervational data, you also need to take that into account.
[ ]:
# Cygnus OB2 data
Av, cyg_U, cyg_B, cyg_V = np.genfromtxt('./data/cmds/cygnusob.dat', unpack=True, usecols=(7, 8, 9,10), skip_header=54)
# Assumes Milky Way extinction
Ab = (1.324*Av)
Au = (1.531*Av)
# Distance to Cyg OB2 and distance modulus
d_cygob2 = 1750 #pc
mu_cygob2 = 5*np.log10(d_cygob2)-5
# Taking away the extinction and turning our mags into absolute mags
# Note it was derived from single star models so extinction may be a tad off
# for your science, feel free to do a better job of it ;)
cyg_U, cyg_B, cyg_V = cyg_U-Au-mu_cygob2 , cyg_B-Ab-mu_cygob2 , cyg_V-Av-mu_cygob2
# Now calculating colours
cyg_UV = cyg_U-cyg_V
cyg_BV = cyg_B-cyg_V
[ ]:
# Upper Sco data
p, usco_U, usco_B, usco_V = np.genfromtxt('./data/cmds/usco.dat', unpack=True, usecols=(1,2,3,4), skip_header=1)
# Distance modulus - this time based on parallax.
# (Note I inverted parallax to make this tutorial quick - don't @ me.)
# Extinction is not a problem for this data set
mu = 5*np.log10(1/p)-5
usco_U, usco_B, usco_V = usco_U+mu, usco_B+mu, usco_V+mu
# Calculating colours
usco_UV = usco_U-usco_V
usco_BV = usco_B-usco_V
[ ]:
# Unpickling our BV and UV cmds!
BV_cmd = unpickle(path='./data/cmds/cmd_bv_z020_bin_imf135_300')
UV_cmd = unpickle(path='./data/cmds/cmd_uv_z020_bin_imf135_300')
Now let’s plot the data!
[ ]:
fig, ax = plt.subplots(2,2, figsize=(15,15))
# This is a bit off on the colour axis which is probs just because of my conversion from Av to Ab and Au
UV_cmd.plot(log_age=6.8, loc=ax[0,0])
ax[0,0].scatter(cyg_UV, cyg_V, s=70, marker='x')
BV_cmd.plot(log_age=6.8, loc=ax[0,1])
ax[0,1].scatter(cyg_BV, cyg_V, s=70, marker='x')
myplot.set_xlim([-1,2.0])
# this is not the same data as the paper
UV_cmd.plot(log_age=6.8, loc=ax[1,0])
ax[1,0].scatter(usco_UV, usco_V, s=100, marker='x')
BV_cmd.plot(log_age=6.8, loc=ax[1,1])
ax[1,1].scatter(usco_BV, usco_V, s=100, marker='x')
for axis in ax.reshape(4):
axis.set_ylabel('V', fontsize=14)
axis.set_ylim([2,-10])
for i in [0,1]:
ax[i,0].set_xlim([-2,4])
ax[i,1].set_xlim([-1,2])
ax[0,0].text(1,0, 'Cygnus OB2\nZ=0.020\nlog(age)=6.8 yrs', fontsize=16)
ax[0,1].text(0.5,0, 'Cygnus OB2\nZ=0.020\nlog(age)=6.8 yrs', fontsize=16)
ax[1,0].text(1,0, 'USco\nZ=0.020\nlog(age)=6.8 yrs', fontsize=16)
ax[1,1].text(0.5,0, 'USco\nZ=0.020\nlog(age)=6.8 yrs', fontsize=16)
YOU’RE ALL SET!
I hope you found this tutorial useful. If you encountered any problems, or would like to make a suggestion, feel free to open an issue on hoki
GitHub page here or on the hoki_tutorials
GitHub there.


|
aws-crt-cpp
C++ wrapper around the aws-c-* libraries. Provides Cross-Platform Transport Protocols and SSL/TLS implementations for C++.
|
#include <JsonObject.h>
Public Member Functions | |
| JsonView () | |
| JsonView (const JsonObject &val) | |
| JsonView & | operator= (const JsonObject &val) |
| String | GetString (const String &key) const |
| String | GetString (const char *key) const |
| String | AsString () const |
| bool | GetBool (const String &key) const |
| bool | GetBool (const char *key) const |
| bool | AsBool () const |
| int | GetInteger (const String &key) const |
| int | GetInteger (const char *key) const |
| int | AsInteger () const |
| int64_t | GetInt64 (const String &key) const |
| int64_t | GetInt64 (const char *key) const |
| int64_t | AsInt64 () const |
| double | GetDouble (const String &key) const |
| double | GetDouble (const char *key) const |
| double | AsDouble () const |
| Vector< JsonView > | GetArray (const String &key) const |
| Vector< JsonView > | GetArray (const char *key) const |
| Vector< JsonView > | AsArray () const |
| JsonView | GetJsonObject (const String &key) const |
| JsonView | GetJsonObject (const char *key) const |
| JsonObject | GetJsonObjectCopy (const String &key) const |
| JsonObject | GetJsonObjectCopy (const char *key) const |
| JsonView | AsObject () const |
| Map< String, JsonView > | GetAllObjects () const |
| bool | ValueExists (const String &key) const |
| bool | ValueExists (const char *key) const |
| bool | KeyExists (const String &key) const |
| bool | KeyExists (const char *key) const |
| bool | IsObject () const |
| bool | IsBool () const |
| bool | IsString () const |
| bool | IsIntegerType () const |
| bool | IsFloatingPointType () const |
| bool | IsListType () const |
| bool | IsNull () const |
| String | WriteCompact (bool treatAsObject=true) const |
| String | WriteReadable (bool treatAsObject=true) const |
| JsonObject | Materialize () const |
Provides read-only view to an existing JsonObject. This allows lightweight copying without making deep copies of the JsonObject. Note: This class does not extend the lifetime of the given JsonObject. It's your responsibility to ensure the lifetime of the JsonObject is extended beyond the lifetime of its view.
| Aws::Crt::JsonView::JsonView | ( | ) |
| Aws::Crt::JsonView::JsonView | ( | const JsonObject & | val | ) |
Returns the value of this node as an array of JsonView objects.
| bool Aws::Crt::JsonView::AsBool | ( | ) | const |
Returns the value of this node as a boolean.
| double Aws::Crt::JsonView::AsDouble | ( | ) | const |
Returns the value of this node as a double precision floating-point.
| int64_t Aws::Crt::JsonView::AsInt64 | ( | ) | const |
Returns the value of this node as 64-bit integer.
| int Aws::Crt::JsonView::AsInteger | ( | ) | const |
Returns the value of this node as an int.
| JsonView Aws::Crt::JsonView::AsObject | ( | ) | const |
Returns the value of this node as a JsonView object.
| String Aws::Crt::JsonView::AsString | ( | ) | const |
Returns the value of this node as a string. The behavior is undefined if the node is not of type string.
Reads all json objects at the top level of this node (does not traverse the tree any further) along with their keys.
Gets an array of JsonView objects from this node by its key.
Gets an array of JsonView objects from this node by its key.
| bool Aws::Crt::JsonView::GetBool | ( | const char * | key | ) | const |
Gets a boolean value from this node by its key.
| bool Aws::Crt::JsonView::GetBool | ( | const String & | key | ) | const |
Gets a boolean value from this node by its key.
| double Aws::Crt::JsonView::GetDouble | ( | const char * | key | ) | const |
Gets a double precision floating-point value from this node by its key.
| double Aws::Crt::JsonView::GetDouble | ( | const String & | key | ) | const |
Gets a double precision floating-point value from this node by its key.
| int64_t Aws::Crt::JsonView::GetInt64 | ( | const char * | key | ) | const |
Gets a 64-bit integer value from this node by its key. The value is 64-bit regardless of the platform/machine.
| int64_t Aws::Crt::JsonView::GetInt64 | ( | const String & | key | ) | const |
Gets a 64-bit integer value from this node by its key. The value is 64-bit regardless of the platform/machine.
| int Aws::Crt::JsonView::GetInteger | ( | const char * | key | ) | const |
Gets an integer value from this node by its key. The integer is of the same size as an int on the machine.
| int Aws::Crt::JsonView::GetInteger | ( | const String & | key | ) | const |
Gets an integer value from this node by its key. The integer is of the same size as an int on the machine.
| JsonView Aws::Crt::JsonView::GetJsonObject | ( | const char * | key | ) | const |
Gets a JsonView object from this node by its key.
Gets a JsonView object from this node by its key.
| JsonObject Aws::Crt::JsonView::GetJsonObjectCopy | ( | const char * | key | ) | const |
| JsonObject Aws::Crt::JsonView::GetJsonObjectCopy | ( | const String & | key | ) | const |
| String Aws::Crt::JsonView::GetString | ( | const char * | key | ) | const |
Gets a string from this node by its key.
Gets a string from this node by its key.
| bool Aws::Crt::JsonView::IsBool | ( | ) | const |
Tests whether the current value is a boolean.
| bool Aws::Crt::JsonView::IsFloatingPointType | ( | ) | const |
Tests whether the current value is a floating-point.
| bool Aws::Crt::JsonView::IsIntegerType | ( | ) | const |
Tests whether the current value is an int or int64_t. Returns false if the value is floating-point.
| bool Aws::Crt::JsonView::IsListType | ( | ) | const |
Tests whether the current value is a JSON array.
| bool Aws::Crt::JsonView::IsNull | ( | ) | const |
Tests whether the current value is NULL.
| bool Aws::Crt::JsonView::IsObject | ( | ) | const |
Tests whether the current value is a JSON object.
| bool Aws::Crt::JsonView::IsString | ( | ) | const |
Tests whether the current value is a string.
| bool Aws::Crt::JsonView::KeyExists | ( | const char * | key | ) | const |
Tests whether a key exists at the current node level.
| bool Aws::Crt::JsonView::KeyExists | ( | const String & | key | ) | const |
Tests whether a key exists at the current node level.
| JsonObject Aws::Crt::JsonView::Materialize | ( | ) | const |
Creates a deep copy of the JSON value rooted in the current JSON view.
| JsonView & Aws::Crt::JsonView::operator= | ( | const JsonObject & | val | ) |
| bool Aws::Crt::JsonView::ValueExists | ( | const char * | key | ) | const |
Tests whether a value exists at the current node level for the given key. Returns true if a value has been found and its value is not null, false otherwise.
| bool Aws::Crt::JsonView::ValueExists | ( | const String & | key | ) | const |
Tests whether a value exists at the current node level for the given key. Returns true if a value has been found and its value is not null, false otherwise.
Writes the current JSON view without whitespace characters starting at the current level to a string.
| treatAsObject | if the current value is empty, writes out '{}' rather than an empty string. |
Writes the current JSON view to a string in a human friendly format.
| treatAsObject | if the current value is empty, writes out '{}' rather than an empty string. |


XXX Page title
What is Project Cloudly?
Project Cloudly is "The Easiest To Setup" software to Monitor and to control your servers.
It's totally free and open source and comes with sophisticated alerting.
Our Sponsors & Partners
Nice and short blah blah mwah mwah mwah....
Start!
Logout
{% include "google_analytics.html" %}


A couple of notes before we start.
I'll go through the slides with everyone, but if you think you can do it faster, please feel free to skip ahead. I'll make sure that everyone gets help, and in case it takes along time I've written this slides for consumption by reading in mind. (I'll not simply read the slides alout.)
If you need help during the presentation, use the help-queue functionality. My helpers will help you when they are available.
As we will work with files that are loaded asynchronously, I highly recommend disabling the cache of your browser:
Remember to have the Developer Tools/Toolbox open throughout the coding.
There are a couple of developer tools extensions available for Chrome that is effective to have if you should have need to debug your applications:


Running janus¶
To run janus, simply type the following in the command line: .. code-block:: python
janus input.json
Structure of an input file¶
Janus uses a JSON style input file, with separate dictionary definitions for six sections.
These are:
| Section title | Description |
|---|---|
| system | parameters for specifying what type of computation is desired |
| qmmm | QM/MM related parameters |
| aqmmm | adaptive QM/MM related parameters |
| md | parameters related to molecular dynamics simulations |
| hl | parameters for the high-level computation |
| ll | parameters for the low-level computation |
The following section details the possible keywords for each section.
System¶
Required keywords¶
- system_info
Description: Files for describing the positions and topology of the initial system DataType: List of strings Values: inpcrd and prmtop files needed for Amber files, gro and top files needed for Gromacs files
Optional keywords¶
- system_info_format
Description: Specifies the format of the files given in system_info DataType: String Default: pdb Values: pdb, Amber, Gromacs - run_md
Description: Whether to run a MD simulation DataType: Bool Default: False - run_qmmm
Description: Specifies whether to run QM/MM DataType: Bool Default: False - run_aqmmm
Description: Specifies whether to run adaptive QM/MM DataType: Bool Default: False - aqmmm_scheme
Description: Specifies what adaptive QM/MM approach to use DataType: String Values: ONIOM-XS, Hot-Spot, PAP, SAP, DAS Default: None - ll_program
Description: Specifies what program to use for the lower level computation DataType: String Values: OpenMM Default: OpenMM - hl_program
Description: Specifies what program to use for the high level computations DataType: String Values: OpenMM, Psi4 Default: Psi4 - md_simulation_program
Description: Specifies what program to use for MD simulation DataType: String Values: OpenMM Default: OpenMM - md_restart
Description: Whether to restart a simulation from saved checkpoints DataType: Bool Default: False - md_restart_checkpoint_filename
Description: Name of checkpoint file to read for restart DataType: String Default: checkpoint.chk - md_restart_forces_filename
Description: Name of force file to read for restart DataType: String Default: forces.pkl
QMMM¶
Required keywords¶
- qm_atoms
Description: Specifies what atoms to treat with QM (or other high level treatment) DataType: List Notes: If run_aqmmm is true, the qm_atoms is the same as the qm_center
Optional keywords¶
- embedding_method
Description: Specifies what QM/MM embedding method to use DataType: String Values: Electrostatic, Mechanical Default: Mechanical - qmmm_scheme
Description: Specifies what energy scheme to use for computing the QM/MM energy DataType: String Values: subtractive Default: subtractive - boundary_treatment
Description: Specifies the scheme to use for the treatment of dangling bonds DataType: String Values: link_atom, RC, RCD Default: link_atom - link_atom_element
Description: Specifies what atom to use for the link atom DataType: String Values: H Default: H
AQMMM¶
Required keywords¶
- qm_center
Description: Specifies what atoms to designate as the center for the high level treatment DataType: List
Optional keywords¶
- partition_scheme
Description: Specifies how to define the buffer zone atoms DataType: String Values: distance Default: distance - Rmin
Description: Specifies the radius from the qm center to the inner boundary of the buffer zone in distance partitioning in angstroms DataType: Float Default: 3.8 - Rmin
Description: Specifies the radius from the qm center to the outer boundary of the buffer zone in distance partitioning in angstroms DataType: Float Default: 4.5 - modified_variant
Description: Specifies whether to use the modified variant of either the PAP or SAP schemes DataType: Bool Default: False
Molecular Dynamics¶
Required keywords¶
- start_qmmm
Description: Specifies at which step to start the QM/MM or adaptive QM/MM approach DataType: Int Notes: QM/MM can be started after taking some MD steps so the system can equilibrate - end_qmmm
Description: Specifies how many DataType: Int Notes: end_qmmm - start_qmmm = total number of MD steps that will use QM/MM forces
Optional keywords¶
- step_size
Description: The step size of the MD simulation in femtoseconds DataType: Int Default: 1 - md_ensemble
Description: Ensemble of MD simulation DataType: String or List of Strings Values: NVT, NVE Default: NVE Notes: If more than one ensemble is desired (i.e., NVT run before NVE) a list can be created in the order of what is run - md_steps
Description: Specifies how many total steps to take for the MD simulation DataType: Int or List of Ints Default: end_qmmm Notes: If more than one md_ensemble is desired, the steps for each can be specified in a list where each element will correspond to the steps run in each ensemble specified in md_ensemble. The step number specified with start_qmmm will be taken as the step number of the last ensemble specified at which to start QM/MM - return_trajectory_interval
Description: Whether to return the trajectory of the MD simulation. Keyword value lists the frame interval to save. DataType: Int Default: 0 (trajectory not returned) - return_trajectory_filename
Description: name of trajectory file to return Datatype: String Default: output - trajectory_format
Description: The format of the trajectory file to return DataType: String Values: NetCDF, Default: NetCDF - return_system
Description: Whether to return the final position and topology of the system in a pdb file DataType: Bool Default: False - return_system_filename
Description: name of system file to return Datatype: String Default: final.pdb - return_info
Description: Whether to return system information such as energy and temperature DataType: List of strings with values to return, will be returned in file “info.dat” Values: potentialEnergy, kineticEnergy, totalEnergy, temperature, density Default: [] - return_info_interval
Description: The frame interval for saving energy, etc. information. DataType: Int Default: 0 (info not returned) - return_info_filename
Description: name of info file to return Datatype: String Default: info.dat - return_checkpoint_interval
Description: Interval for forces DataType: Int Default: 0 - return_checkpoint_filename
Description: Name of checkpoint file to return DataType: String Default: checkpoint.chk - return_forces_interval
Description: Interval to return forces at DataType: Int Default: same as return_checkpoint_interval - return_forces_filename
Description: Name of force file to return DataType: String Default: forces.pkl
High Level¶
Low Level¶
Examples¶
A input file might look like the following:
{
"system" : {
"system_info" : "water.pdb",
"run_aqmmm" : true,
"run_md" : true,
"aqmmm_scheme" : "ONIOM-XS",
"ll_program" : "OpenMM",
"hl_program" : "Psi4",
"md_simulation_program" : "OpenMM"
},
"aqmmm" : {
"qm_center" : [0,1,2]
},
"md" : {
"start_qmmm" : 10000,
"end_qmmm" : 12000,
"md_ensemble" : "NVE"
}
}
Supported codes¶
Janus only supports Psi4 for quantum mechanics computations and OpenMM for molecular mechanics and molecular dynamics.


Weather Trade Net develops and promotes the weather derivatives for energy providers, agricultural producers, retailers, transport companies, offshore cable-laying industry, shipment manufacturers, breweries, restaurant managers, tourism agencies and the leisure infrastructure. Our weather sensitivity calculator allows for risk assessment and pricing - soon online in free and easy access. Services for end-users: analytical and financial tools, objective and independent pricing methods, contract negotiation and trading.
Adverse weather affects not only your mood, your outdoor activities and your electricity bill at the end of month, but also the road traffic, construction works schedule, regional energy demand, performance of wind, photovoltaic and hydro-power plants, yield quality and timing, planning of retail stocks, consumption volumes, sales prices and profits.
Minimise the financial exposure induced by unfavourable weather. Construct meteorological indices and settle a balanced risk contract tailored to your business. In contrast to a classic insurance that covers only extreme and rare events, the weather derivative contracts require no proof of loss. Weather observations trigger automatic payements.
Negotiate, buy, sell the weather derivative contracts. We help you to find a partner : a (re-)insurer, investment bank, commodity hedge fund, pension fund, state government, or another company with an opposite (compared to yours) interest in the same weather-index. Weather Trade Net StartUp is an intermediate provider of unbiased solutions.
Energy deals represent about 50% of all traded weather derivatives. In France the variations in temperature account for 85% of the variance in winter energy demand and 63% in summer. The negative anomaly of the air temperature in winter triggers the additional volume demand of the natural gas and the electricity around 3% per 1 degree C. Few examples of financial risks related to the air temperature variations.
Depending on the weather anomaly and the power load, the planning of generators is re-adjusted. Cold anomaly of 1 degree C implies a greater demand (better sales), but also requires the additional boost of the coal, natural gas and oil power plants, which is costly at the last moment.
To fulfill the volume engagements, the wind farm energy provider has to buy the expensive wholesale electricity simply because the weak or unstable winds unable it's own production. Weather derivatives replenish the profit losses proportionally to the anomaly duration and intensity.
Persistent and repetitive bad weather conditions dictate the yield volumes and quality, the production costs and as a result the commodity prices. Moreover, an excessive soil moisture triggers a higher exposure of plants to diseases and insects, which increases the demand in fertilisers and chemicals, affecting their stocks and prices. The transport planning and as a result, the production cost, is also reconsidered following a regional failure in yield.
To support farmers when coping with the concequences of unfavorable non-extreme weather, the weather-derivatives contracts become useful. These formalise the frequency
and the intencity of unwelcomed events. For example, this could be the short repetitive droughts over the season, when no rainfall but high air temperatures.
In elevated and continental regions frost events are of concern. The anomalously long/cold winter is the most commonly traded event on agricultural commodity market.
Temperature-based HDD-index reflects well the unusually cold months and seasons. Another danger in the fields are the storm-force winds and heavy showers, excluded from a classic insuarance contract. Cattle and poultry producers suffer from droughts by means of the feed cost, forced to buy the grains elsewhere. The list of primary goods requiring the weather-based hedging is as long as the variety of agricultural spicies. The top 10 include the oilseeds, cocoa, corn, wheat, soya, sugar cane, rice, coffee, cotton, potatoes and fruits.
Weather Trade Net futures trigger the payoff when a tolerance threshold exceeds the climatological average. This might consider, for example, a number of days with precipitation and temperatures below zero. Weather Trade Net generates a risk contract for your particular case, the one that might be sold, where the interests of both sides are equilibrated and explicit.
Non-catastrophic weather events showed-up of being capable to immobilise the entire region in just a few hours. Heavy snow load and a number of frost days are the two major underlying components of a weather-indexed contract. The satellite, radar and the weather-station measurements are treated to quantify the anomalies for each region/location/road.
Storm-force winds, wind chill and icing, ocean waves and low visibility due to fog cannot be anticipated. These affect the delays, further planning, and there is no reason that the day cost reduces. When clearly identifying the risk to mitigate, at least one simple solution exists. You don't have to be a meteorologist or a trader to built your weather derivative contract.
Weather is responsible for about 40-50% of delays at the European airports. Heavy snow load, storm-force winds, strong vertical near-surface wind shear, airplane deicing, flight track deviation, all these adverse situations imply the additioal safety measures, important flight delays, which induce more expences.
Nowadays, risk hedging becomes a condition to raise project fundings. To hedge the risk, the supplier might acquire a CALL option with the underlying weather index, such as the number of days with the daily average wind speed above a threshold. Cable laying works, wind farm installation and maintenance companies, all purchase assets to stabilise the unpredictable extreme expences. Financial products can be defined based on 30-year satellite observations of wind, swell, temperatures, sea ice concentrations and the precipitation even in the sea.
Compensations might cover the events when the cold, windy or damp weather. These halt construction works.
We also work-out the suggestions for the best operation timing to help you minimise the risk exposure and to reduce the contract premium.
Storm-force winds, long-lasting fog, swells and freezing temperatures delay the projects that are already costly.
Consumer psychology studies confirm that the purchase intention and the number of online "to-purchase" clicks are higher when sunny and warmer. The willingness to spend money doubles or even triples when the good weather comes. The actual numbers depend on the product, the region and its climate, and the season. Beer sales volumes show-up to be highly correlated to the maximum daily air tempartures in Southern France. Consumption of soft drinks is 5% smaller during damp and fresh summer. Warm winters are dramatic for coat sales. Non-catastrophic, but just a bad weather affects the mood of consumers and the preferencial producs. Weather Trade Net offers the hedging contracts that take into account the revenue losses in the past - those affected by meteorological variations. The execution of the contract depends on the actual weather measurements and does not require any proof of loss.
Outdoor amusement parks, ski resorts, international football and tennis events are best attended on days with favourable weather. In turn, the cold, wet and windy weather encourages people to stay indoors. Rain and fog trigger an increased use of food delivery services, a greater demand of online games and the video streaming, and better tickets sales for the cinema.
Weather Trade Net creates the tailored weather coverage contracts for the leisure industry and searches for the counterparty to sell it.
Weather Trade Net creates the weather hedging financial coverage based on the probability estimates of non-extreme weather anomalies. Here is a brief overview of the major unfavorable weather events for each economic activity. Such events can be quantified with a measurable meteorological parameter, such as the air temperature, wind speed, amonut of rain, frequency of frost days, and intensity the solar radiation.
| Economic activity | Unfavorable weather event | Meteo parameter | Financial damage |
|---|---|---|---|
| Agriculture : corn, wheat, soya, sugar cane, rice, coffee, cocoa, cotton, oilseed, potatoes, fruits; Catering | droughts, frost without snow, long/cold winter, storm winds | air temperature precipitation, soil moisture | Water use, production cost, size of harvest, prices. Indirect effect on diseases and insects |
| Energy market : fuel, heating oil, natural gas | Warm winter, days warm up early in spring | Temperature, HDD and CDD, wind | Industrial and domestic consumption, sales strategy |
| Renewable energies: hydro-electric, wind, photovoltaic | Few snow in winter, few or too strong and unsteady winds, cloudy and gray weeks | Wind speed, river runoff, precipitation, solar radiation | Load, energy production deficit, sales volumes, profits |
| Transport : land, maritime, aviation Construction companies: roads, all outside works, offshore cable-laying | Frequent storms, persistent rain and fog, frost days | Wind speed/gusts, visibility, precipitation, ocean waves | Planning, construction delays, day cost of having a vessel |
| Commerce: breweries, mineral water, sodas, soft drinks, retail, outfit, tires | Cold and rainy summer, dry and too warm winter without snow, frozen roads | Air temperature, precipitation | Decrease in demand, stock management, profits |
| Tourism and Leisure, sporting events, concerts, ski resorts, restaurants, attractions, campings | Few snow in the mountains, rainy and cold summer | Air temperature, wind, snow precipitation, sunshine hours | Number of visitors, sales volumes, performance, planning |
The operational real-time weather forecasts reflect quite well the evolution in air temperature and wind over coming 3-4 days.
Yet, the complexity of meteorological events does not allow for a longer thermo-dynamic (physical) weather forecast. You might have heard about the seasonal
forecasts. These are built from historical 40-year weather records and the regional tendencies in the Sea Level Pressure. Indeed, the seasonal
forecasts reflect mostly some statistically based expectation rather than a real-time thermo-dynamic weather forecast.
So far, beyond one week ahead, the future financial losses due to unpredictable weather anomaly are unpredictable as well. As a result, from day-to-day,
from season-to-season the temperature anomaly increases the gap between the expected revenue and the actual one.
Air temperature is the most popular and a highly reliable meteorological parameter. Observations are available all over the Globe. For financial applications the daily average values are recalculated into indexes such as the cumulative Heating (HDD) and the cumulative Cooling Degree Days (CDD), the Heat Index (HI), the Cumulative Average Temperature. The cumulative term means that the daily air temperature anomaly is summed over a period, which can be a week, month or season. Around 80% of contracts are based on either temperature index. According to a swap-type contract, one counter party gets paid if the degree days over a specified period are greater than the strike level, and the other party gets paid if the degree days over that period are less than the strike.
Rain amount controls the fresh-water reserves, affects the hydro-electric energy production and represents a strong limiting factor for all agricultiral activities
along the growing season. Precipitation intensity is registered with the meteorological stations and the microwave Radars. These two deata sources together with the
satellite data and the numerical weather models are used to define:
the optimal and typical conditions for each region,
and
critical conditions for a given business activity.
Wind power production is literally absent when the wind speed falls below 12 m/s.
The outside construction
works and the offshore operations are restrained also if the wind speed exceeds 15 m/s.
Validated accurate 40-year records of the wind speed allow
for objective statistics to support the weather-derivative contracts.
Numerical weather models are feed in real-time by the continuous
satellite observations inland and offshore.
Weather Trade Net benefits its clients the unlimited access to all existing resources
in real-time and accompanies the decisions on the spot.
Numerical weather models and observations allow for daily estimates of the incoming solar radiation intensity.
This parameter determines the performance of the photovoltaic power plants, and explains well certain commercial activities and sales volumes.
Solar radiation can be represented in terms of the :
Sunshine duration [hours per day],
Solar illuminance index [% of maximum
available],
Anomaly of the solar radiation intensity [Watt/m2]
Additionally, many other meteorological parameters are available for any site worldwide. These are, for example,
the soil moisture (satellite data), the evaporation intensity, the air quality (measurements), ocean wave height (satellite data), the
presence of snow, the sea ice concentrations and ice drift velocity.
Please, contact us if you need a specific analysis. The preliminary analysis and the study set-up is free of charge.
Weather Trade Net is a French StartUp launched in August 2016 by Maksimovich Elena, scientist in Geophysics, PhD in Meteorology.
Weather Trade Net combines the expertise in mathematics, meteorology, computer science and finance.
We furnish the tools and relevant solutions for non-extreme Weather Risk Hedging.
The challenge is to introduce the weather derivatives to a small-profit business.
Step-by-step, we first focus on business performance analysis in respect to weather fluctuations in the past.
Further, when quantifying the weather-related excessive expences (that should be covered by weather derivatives), the "strike" is evaluated as a
threshold between "affordable" and "excessive" profit losses. The contract premium and the maximum payoff are proportional to losses of each individual
business and the risk level to hedge.
Weather Trade Net assists to select an appropriate weather derivatives type, with an optimal strike value and a realistic risk pricing.
As an independent partner, Weather Trade Net guaranties the objective and confidential data analytics services, transparent contract set-up,
as well as a timely and in-depth reporting. We seek for the best compromise between a risk-seller and a risk-buyer.
Your project requires an in-depth statistical analysis of weather-related issues? The preliminary reporting and the project set-up are free of charge.
Wishing to invest in weather derivatives?
Looking for scientists to answer simply the complex questions?
Let us know! Weather Trade Net will overcome your expectations! Become our collaborator!
+<IP_ADDRESS>.13.03 - France - NICE
contact@weathertrade.net


jcmd(1) jcmd(1) Name jcmd - Diagnostic Command jcmd is a utility to send diagnostic command requests to a running Java Virtual Machine. SYNOPSIS jcmd [ option ] jcmd <pid | main class> PerfCounter.print jcmd <pid | main class> command [arguments] jcmd <pid | main class> -f file DESCRIPTION jcmd is a utility to send diagnostic command requests to a Java Virtual Machine supporting this feature. Used without arguments or with the -l option, jcmd prints the list of running Java processes with their process id, their main class and their command line arguments. When a process id is specified on the command line, jcmd sends the diag‐ nostic command request to the process with this id. When a main class is specified on the command line, jcmd sends the diag‐ nostic command request to all Java processes for which the command line argument is a substring of the Java process' main class. With the PerfCounter.print argument, jcmd prints the performance counters available on the targeted Java process(es). With the -f option, jcmd sends to the targeted Java process(es) the diag‐ nostic commands stored in the file file. OPTIONS Options are mutually exclusive. Options, if used, should follow immedi‐ ately after the command name. -l Prints the list of running Java processes with their process id, their main class and their command line arguments. -h Prints a help message. -help Prints a help message. PARAMETERS pid Identifies the process that receives the diagnostic command requests. The process must be a Java process. To get a list of Java processes running on a machine, use jps(1) or jcmd(1). main class Main class of the process that receives the diagnostic command requests. When matching processes, any process whose main class name contains the specified string as a substring will be matched. If several running Java processes share this main class, the diag‐ nostic command request is sent to all these processes. To get a list of Java processes running on a machine, use jps(1) or jcmd(1). command [arguments] Invoke the diagnostic command called command on the targeted Java process(es). The list of available diagnostic commands for a given process can be obtained by invoking the help command on this process. Each diagnostic command has its own set of arguments, which can be obtained by invoking the the command name followed by help. PerfCounter.print Print the performance counters available on the targeted Java process(es). The list of performance counters may vary with the Java process. -f file Read commands from file and invoke them on the targeted Java process(es). In file, each command must be written on a single line. Lines starting with # are ignored. Processing of file ends when all lines have been invoked or when a line containing the stop keyword is read. SEE ALSO o jps(1) jps(1) 10 Jul 2012 jcmd(1)


Using the manual palette mode for low-color images
Pixen's default behavior is to add colors to the document palette as you use them, which is the most convenient for most kinds of work. But if you're trying to make, say, a sprite for a cell phone game where you have 32 very specific colors you can use, you need Pixen to be more strict. Fortunately, it's willing.
In the manual palette mode, Pixen will not automaticaly add any colors to your palette or touch it in any way. If you want to use a new color, you'll have to add it yourself. If you start drawing with a color that is not in the palette you've specified, Pixen will draw with the closest one.
To enable manual palette mode:
- Choose Switch to Manual Mode... from the Palette menu.
- Choose the palette you want to lock the document to and specify any parameters you'd like to customize.
- Click Restrict.
Alpha values are not supported in manual palette mode because they can result in adverse colors through blending. For the same reason, layer opacity cannot be adjusted in manual palette mode.
If you specify a number of colors fewer than the number in the document, Pixen will create a new palette with the specified number by quantizing the document. This can result in some loss of detail.


The ‘Rolls-Rice’ of Japanese food
Browse our online menu filled with mouth-watering japanese cuisine today and order straight to your front door within 90 minutes.
Order online nowBrowse our online menu filled with mouth-watering japanese cuisine today and order straight to your front door within 90 minutes.
Order online nowWhen it comes to sushi, it can sometimes be hard to find good quality on the go. Our aim is to make sushi a regular, healthy treat as opposed to an occasional luxury. We offer distinctive, unique and beautifully prepared foods at affordable prices.
Ordering food from Nudo couldn't be easier. Simply visit one of our growing number of stores to eat in, take away, or, order straight to your door through our website.
The Nudo story


{% extends "base.html" %} {% block content %}
Load all kanji: Load
Delete all kanji: Delete
Sort by level: 1 | 2 | 3 | 4 | 5 | All | Add new kanji
| # | Kanji | Meaning | Strokes | JLPT level | Delete | {% for kanji in kanjis %}
|---|---|---|---|---|---|
| {{forloop.counter}} | {{kanji.kanji}} | {{kanji.meaning}} | {{kanji.strokes}} | {{kanji.jlptLevel}} | X |


|
MOTS Finder
Find non-star-shaped MOTSs
|
Base class for discrete axisymmetric metrics. More...
Public Member Functions | |
| def | __init__ (self) |
| This base constructor initializes the properties. More... | |
| def | all_field_objects (self) |
| Abstract method supplying all defined field objects as a list. More... | |
| def | field (self) |
| Field attribute containing the actual field object. More... | |
| def | set_interpolation (self, interpolation) |
| Set the interpolation for all fields/components. More... | |
| def | set_fd_order (self, fd_order) |
| Set the finite difference derivative order of accuracy. More... | |
| def | temp_interpolation (self, interpolation, fd_order=None) |
| def | save_full_data (self) |
| Read/write property specifying whether the full grid data should be stored. More... | |
| def | save_full_data (self, value) |
| def | save (self, filename, full_data=False, overwrite=False, verbose=True) |
| Save the metric to disk. More... | |
| def | constraints (self, point, norm=False) |
| Compute the Hamiltonian and momentum constraints. More... | |
| def | load_data (self, which) |
| Load/generate the full numerical data. More... | |
| def | unload_data (self) |
| Free memory from all numerical field matrix data. More... | |
| def | release_file_handle (self) |
| Convenience method to signal child classes they should release any file handles. More... | |
| def | reset_cache (self) |
| Reset the cache of all fields. More... | |
| def | grid (self, xz_plane=True, ghost=0, full_output=False) |
| Convenience method delegating to .patch.DataPatch.grid(). More... | |
| def | snap_to_grid (self, point) |
| Convenience method delegating to .patch.DataPatch.snap_to_grid(). More... | |
| def | shape (self) |
| Shape of the domain, i.e. of individual component matrices. More... | |
| def | box (self) |
| Index bounding box of the full domain. More... | |
| def | component_matrix (self, i, j) |
| Return the DataPatch of a component of the metric. More... | |
| def | diff (self, point, inverse=False, diff=1) |
| Compute (derivatives of) the metric tensor at a given point. More... | |
| Public Member Functions inherited from _ThreeMetric | |
| def | get_curv (self) |
| Return the extrinsic curvature belonging to this 3-metric. More... | |
| def | get_lapse (self) |
| Return the lapse function on the slice. More... | |
| def | get_shift (self) |
| Return the shift vector field on the slice. More... | |
| def | get_dtlapse (self) |
| Return the time derivative of lapse. More... | |
| def | get_dtshift (self) |
| Return the time derivative of shift. More... | |
| Public Member Functions inherited from _GeneralMetric | |
| def | __call__ (self, point) |
| def | at (self, point) |
| Return the metric tensor at a given point. More... | |
| def | diff (self, point, inverse=False, diff=1) |
| Return derivatives of the metric at the given point. More... | |
| def | diff_lnsqrtg (self, point) |
| Return derivatives of ln(sqrt(det(g))). More... | |
| def | christoffel (self, point) |
| Compute the Christoffel symbols of this metric. More... | |
| def | christoffel_deriv (self, point) |
| Compute the derivatives of the Christoffel symbols. More... | |
| def | ricci_tensor (self, point) |
| Compute the components of the Ricci tensor. More... | |
| def | ricci_scalar (self, point) |
| Compute the scalar curvature (Ricci scalar). More... | |
Static Public Member Functions | |
| def | load (filename) |
| Static function to load a metric from disk. More... | |
Public Attributes | |
| save_full_data | |
Private Member Functions | |
| def | _get_metric (self) |
| Abstract method to create/load numerical metric data. More... | |
| def | _mat_at (self, point) |
Private Attributes | |
| _metric_field | |
| The metric discrete field object. More... | |
| _save_full_data | |
| Whether all matrices should be saved. More... | |
Base class for discrete axisymmetric metrics.
This subclass of ..base._ThreeMetric implements the memory management of numerical data for a metric and other fields defining the geometry and embedding of the slice into spacetime.
Subclasses should implement:
The reason to have the latter of the two is to allow metrics that don't supply a lapse and/or shift field but still have an easy way to keep track of all fields (for caching and memory management purposes).
Optionally, subclasses may implement:
If all of these are supplied, then the full 4-metric can be evaluated on the slice.
| def __init__ | ( | self | ) |
This base constructor initializes the properties.
|
private |
Abstract method to create/load numerical metric data.
This method should return a .tensors.DiscreteSym2TensorField built from the component matrices of the metric. It is called only once (lazily) and the object is not destroyed even when calling unload_data(). Instead, the field's unload_data() method is called.
This method is the hook for subclasses to implement their method of generating/loading the numerical data.
| def all_field_objects | ( | self | ) |
Abstract method supplying all defined field objects as a list.
See .discretize.DiscretizedMetric for a simple example.
| def box | ( | self | ) |
Index bounding box of the full domain.
| def component_matrix | ( | self, | |
| i, | |||
| j | |||
| ) |
Return the DataPatch of a component of the metric.
| def constraints | ( | self, | |
| point, | |||
norm = False |
|||
| ) |
Compute the Hamiltonian and momentum constraints.
If the constraints are satisfied exactly, the returned values will be zero. However, for numerical simulation data this will rarely ever be the case. The returned values can then be used to determine the accuracy of the simulation, e.g. by comparing them at different spatial resolutions (grid densities).
Note that this function is not optimized in any way and thus will perform poorly when evaluated on a large number of points.
(scal_constr, vec_constr)
, where scal_constr
is a float representing the Hamiltonian constraint and vec_constr
the momentum constraint . The latter is a (3-D) covector (indices downstairs). Here, D
is the Levi-Civita covariant derivative compatible with g
, the slice's Riemannian 3-metric, K
is the extrinsic curvature of the slice and R
the scalar curvature of the slice. If norm=True
, the second element is a float, the g
-norm of the momentum constraint.| point | The point at which to compute the constraints. |
| norm | If True , compute the g -norm of the momentum constraint instead of the covector. Default is False . |
| def diff | ( | self, | |
| point, | |||
inverse = False , |
|||
diff = 1 |
|||
| ) |
Compute (derivatives of) the metric tensor at a given point.
diff=0
, returns the 3x3 matrix representing the metric interpolated at point
, i.e. . If diff=1
, returns dg[i,j,k]
, where the indices mean and if diff=2
, returns ddg[i,j,k,l]
with indices . In each case, if inverse=True
the inverse metric is used with indices upstairs.| point | The point at which to compute. |
| inverse | Whether to compute (derivatives of) the inverse metric. Default is False . |
| diff | Derivative order to compute. Default is 1 . |
| def field | ( | self | ) |
Field attribute containing the actual field object.
The object is lazily loaded (i.e. on first access) and kept as instance attribute. Note that this access does not imply that data is loaded or generated. This is handled by the field object itself.
The result is a .tensors.DiscreteSym2TensorField.
| def grid | ( | self, | |
xz_plane = True , |
|||
ghost = 0 , |
|||
full_output = False |
|||
| ) |
Convenience method delegating to .patch.DataPatch.grid().
|
static |
Static function to load a metric from disk.
| def load_data | ( | self, | |
| which | |||
| ) |
Load/generate the full numerical data.
Without arguments, all fields are loaded to memory. If one or more arguments are given, only those fields are loaded. Possible arguments are metric, curv, lapse, shift, dtlapse, dtshift
.
| def release_file_handle | ( | self | ) |
Convenience method to signal child classes they should release any file handles.
This does nothing by default. Subclasses may implement this method to free access to any files currently opened by this class. It may be called by users of this class in case they deem file access to be finished (e.g. after loading all required data).
| def reset_cache | ( | self | ) |
Reset the cache of all fields.
| def save | ( | self, | |
| filename, | |||
full_data = False , |
|||
overwrite = False , |
|||
verbose = True |
|||
| ) |
Save the metric to disk.
| filename | The file to store the data in. The extension '.npy' will be added if not already there. |
| full_data | Whether to store all the matrix data (if True ) or regenerate it on-demand after loading (if False ). Default is False . |
| overwrite | Whether to overwrite an existing file with the same name. If False (default) and such a file exists, a RuntimeError is raised. |
| verbose | Whether to print a message upon success. Default is True . |
| def save_full_data | ( | self | ) |
Read/write property specifying whether the full grid data should be stored.
This is False
by default. If set to True
instead, saving this object (or more generally "pickling" it) will include the numerical data on the full grid. For large slice data, this will basically store the full slice.
| def set_fd_order | ( | self, | |
| fd_order | |||
| ) |
Set the finite difference derivative order of accuracy.
| def set_interpolation | ( | self, | |
| interpolation | |||
| ) |
Set the interpolation for all fields/components.
Refer to .patch.DataPatch.set_interpolation() for details.
| def shape | ( | self | ) |
Shape of the domain, i.e. of individual component matrices.
| def snap_to_grid | ( | self, | |
| point | |||
| ) |
Convenience method delegating to .patch.DataPatch.snap_to_grid().
| def unload_data | ( | self | ) |
Free memory from all numerical field matrix data.
|
private |
The metric discrete field object.
|
private |
Whether all matrices should be saved.


|
ArgyriaSnake oil salesmen have long been fans of colloidal silver, peddling it to unsuspecting rubes as a homeopathic cure-all for everything from shingles to psoriasis. The concoction is easily produced with a little high-school chemistry. Dip two silver wires in water and run an electrical current through them: electrolysis will create a suspension of silver in the water. The resulting bromide can be bottled and labeled with delicate filigree, hawked by a man in a stovepipe hat amid signs promising miracle cures. Slack-jawed suckers will buy it up and chug it down with a grenadine chaser, while the nimble carpetbagger quietly packs up shop and disappears down the corduroy road with but a cruel cluck for the huckleberries.Argyria is a dermatological condition in which the skin changes in pigment from its natural color to a greyish-blue. The condition occurs as a result of cumulative exposure to silver nitrates, which over time percolate into the dermis. Initially tinting it a pallid bluebell, continued treatment tarnishes the skin first to slate, then puce, then finally a dull confederate grey. After ingestion, silver salts are deposited in the skin and oxidized by sunlight, via the same process that develops photographs. Discoloration is first noticeable in the fingernails; gradually it spreads to the face and gums, and eventually the whole body. Face creams containing silver can even result in a bluish-brown discoloration of the eyeballs themselves. While Argyria has no real side effects aside from a slight itching, the condition is irreversible since silver becomes trapped in the deepest layers of skin. Some sufferers have tried "dermabrading", a painful-sounding surgical process which strips the top layers of skin from the face, though little success has been shown. Most people afflicted with Argyria -- or its sister disease, Chrysiasis (discoloration due to gold overdose) -- argue that the severe social stigma associated with the disease far diminishes the benefits of the placebo effect. Sufferers find it difficult to win jobs and blowjobs while sporting the Al Jolson equivalent of AIDS spots. One need only parade across the town square with a slight list and a drool-dripping grimace to convince women and children that your sleepy town has a zombie problem. A homeless Argyria sufferer asleep on a park bench might be awakened by paramedics trying CPR, afraid that the local wino has stopped breathing. A hundred years ago, syphilitic Argyria sufferers pranced about circus sideshows as the Incredible Blue Man; nowadays a few of these lazars find work as mimes doing the robot at tourist hotspots, but nobody's buying it. Starting in 1999, Montana native Stan Jones drank colloidal silver daily, believing it to be a natural antibiotic which would save him from the forecasted Y2K disaster, with its exploding toilets, scant antibiotics, and menacing clouds of anthrax. Jones would later emerge transformed from his sun-dappled home on the Gallatin River, entering the 2002 Montana senate race as the first blue Libertarian candidate. It's not like the election wasn't a circus to begin with.  The Dems seemed to have it cinched -- until the Blue Man from Bozeman strolled into the place. Soon Jones was making Oddly Enough... headlines across the country, as both a colloidal silver sufferer and a supporter of the practice. Citing his recent lack of colds and other maladies, he became the first high-profile pusher of the alternative medicine in decades, despite his complexion: "It's my fault that I overdosed, but I still believe it's the best antibiotic in the world," Jones said. At a press conference at the Days Inn in Bozeman, MT, he assured a rabid press that he wasn't a spoiler candidate running on a gimmick. "I'm just practicing for Halloween," he joked, trying to change the subject. Jones promises to end the war on drugs, stop campaign finance reform, and repeal the federal income tax -- which he hasn't paid in three years. Jones steadfastly weathered a storm of smurf jokes and crude flash animatronics before emerging at the bottom of the heap in the contentious Montana election. Jones received 3% of the vote, beating the envious Green party candidate by almost three-thousand votes. "It's not up to the government to tell any individual what he can put in his mouth or shoot in his arm," Jones said. "The war on drugs is unconstitutional."
|


Atom JavaScript Client Unit Tests
This document tests the serialization and deserialization of the Atom JavaScript client.
Model to XML Tests
Results


Could Tinkler’s good semifinals record continue?
Maritzburg United coach, Eric Tinkler is one of the coaches with a rare record of almost never losing a semifinals match, with every team he has coached going all the way once they get past the quarter-finals.
by Sibongiseni GumbiCoach Eric Tinkler (Photo by Lefty Shivambu/Gallo Images)
The only time he could get past the semifinals was when he was at Chippa United a few seasons ago. While at Pirates, he won all semifinals including in the Caf Confederations Cup.
But it was only at Cape Town City and SuperSport United where he managed to go on and win the final having lost out on three finals with Pirates.
“He had always been frustrated in finals which started when he was Roger De Sa’s assistant at bot (Bidvest) Wits and Pirates,” said Thobela FM commentator and statistician, Sechaba Motshwane.
“But since becoming a coach on his own, he has done well and hardly ever lost a semifinals match. I think the only time he lost in that stage was when he was at Chippa (United) if my memory serves me right,” explained Motshwane.
Tinkler will be hoping to continue his good record when he guides his Team of Choice against Kaizer Chiefs at Mbombela Stadium on Sunday afternoon. He has a good record against Chiefs having lost only three times against them in 14 meetings.
He is one of the coaches who never lost to Amakhosi during his times at the Buccaneers and has beaten the Naturena side six times with different teams.
In 14 matches he has played against Amakhosi, he has won six, drawn five and lost three. Speaking to the media earlier this week, he brushed aside any talk of his personal record as he said it was about the club and not him.


Daniel
Manager
- Email<EMAIL_ADDRESS>- Employee ID: 12352
- Office number:<PHONE_NUMBER>3
Joey
Engineer
- Email<EMAIL_ADDRESS>- Employee ID: 2193875
- Github account: HowYOUDoin
Katy
Intern
- Email<EMAIL_ADDRESS>- Employee ID: 598712
- Intern's School: School of Hard Knocks
Lacie
Engineer
- Email<EMAIL_ADDRESS>- Employee ID: 587123
- Github account: LadyLacie


Inspired by this reddit thread.
Please note, it takes a lot of computing power to make larger images; do so sparingly.
Made by EuanK. Souce code avaliable on github


Copyright (c) 1950s Martin Gardner
This game is played on an empty 8x8 square board:
|
| An
opening example Two initial moves. Notice that the game can be played with just one color. |
Martin Gardner presented this game at the Scientific American magazine (#230, Feb. 1974, 106-108), showing a symmetric (of both axis) winning strategy for the 2nd player on boards with even dimensions. One can change the board size (both sizes should be odd) and/or add a PIE rule (stating that one player makes 3 drops and the other choose sides) in order to play the game with no known winning strategy.
There is a variant called Crosscram (or Domineering) where one player only drops vertically and the opponent horizontally. There is a ZRF to play Crosscram with Zillions.


TEAM offers students the possibility to meet business representatives from a range of companies during a private conversation about jobs and future possibilities. This is a great way to establish a connection with the company of your choice, but should by no means be considered a job interview. Applications for the individual meetings will open in advance, and the meetings themselves take place during the fair, the 26-27th of September. Keep an eye out for information regarding application deadlines and companies that offer interviews!


--- title: "Setup MySQL connection using R in GNU linux" date: 2014-12-21T19:52:39 lastmod: 2014-12-21T19:52:39 draft: false # Authors. Comma separated list, e.g. `["Bob Smith", "David Jones"]`. authors: - Ming Su tags: - R - mysql - rmysql - linux - database - install summary: "Setup MySQL connection using R in GNU linux" ---
To connect mysql database using R is very important if you want to do some data analysis, I have extreamly bad experience on setting up it in GNU/linux, as I know, it is not easy to setup in windows as well.
sudo apt-get install libmysqlclient-dev
wget http://cran.r-project.org/src/contrib/RMySQL_0.9-3.tar.gz
R CMD INSTALL --configure-args='--with-mysql-dir=/usr/lib' RMySQL_0.9-3.tar.gz


|
The magnification tools in the upper left allow you to zoom in and out of the catalog page
you're on. Use the page browser at the bottom of the screen to go to the other pages in this catalog.
|
|
|
Use the marker tool on the right to place a mark on the top left corner of an entry in the
catalog. Then fill out the form that comes up to help use identify the essential information.
|
Marker Legend |
|
|
|
Creating Mark
|
|
|
Pending Mark
|
|
|
Approved Mark
|
|
Selected Mark
|
|
|
|
Your Marks
|
Page Legend |
|
|
|
Active Users
|
|
|
Nothing to Mark
|
|
|
Approved Marks
|
|
|
Page Completed
|


Here are some examples of javascript literal variable declarations of different data types:
Function Declarationsvar length = 16; // Number assigned by a number literal var points = x * 10; // Number assigned by an expression literal var lastName = "Johnson"; // String assigned by a string literal var cars = ["Saab", "Volvo", "BMW"]; // Array assigned by an array literal var person = {firstName:John, lastName:Doe}; // Object assigned by an object literal
Here are some different ways to declare functions:
For Loopsfunction superFizzBuzz (array) { return array; }; var superFizzBuzz = function(array) { return array; }; var superFizzBuzz = new Function('array', 'return array') // No one uses this
Here are some exmples of for loops- the first type of for loop is non object specific; you can create a variable to iterate over (a specific amount of times). The For..In loop, however, will loop through properties in an object:
While / Do While LoopsRegular For Loop for (statement 1; statement 2; statement 3) { code block to be executed; } for (i = 0; i < 5; i++) { text += "The number is " + i + "
"; } For..In Loop for (var property_name in some_object) { //statements using some_object[property_name]; } var person = {fname:"John", lname:"Doe", age:25}; var text = ""; var x; for (x in person) { text += person[x]; }
Another type of loop are While, and Do While loops, which are the same, except whether it checks the condition at the beginning or the end:
If/Else StatementsWhile Loop: while (condition) { code block to be executed } while (i < 10) { text += "The number is " + i; i++; } Do While Loop: do { code block to be executed } while (condition); do { text += "The number is " + i; i++; } while (i < 10);
Here's how to do an if/else/else if statement, followed by an example
Defining Objectsif (condition1) { block of code to be executed if condition1 is true } else if (condition2) { block of code to be executed if the condition1 is false and condition2 is true } else { block of code to be executed if the condition1 is false and condition2 is false } if (time < 10) { greeting = "Good morning"; } else if (time<20) { greeting = "Good day"; } else { greeting = "Good evening"; }
Here are some different ways to define Object objects:
// Object literal: var objectA = {}; var objectB = {index1: 'value 1', index2: 'value 2'}; var myStructure = { name: { first: "Mel", last: "Smith" }, age: 33, hobbies: ["chess", "jogging"] }; // Constructor: var anObject = new Object(); // Adding/accessing properties: anObject['prop'] = 'value'; // assign property of an Object via bracket syntax


Cancer
Cancer : (June 22 – July 22)
Your life will again come on track. You will be given added responsibility at your workplace.  Financial position will be much better now. It is right time for higher studies and taking research field etc. There will be a positive change in life. People would give you good advice.


Software
Contents
Spim, pcspim, and xspim
Spim is a self-contained simulator that will run MIPS R2000/R3000 assembly language programs. It reads and immediately executes assembly language code for this processor (it does not execute binary programs). Spim provides a simple debugger and minimal set of operating system services.
Spim implements almost the entire MIPS assembler-extended instruction set for the R2000/R3000. It omits some complex floating point comparisons and rounding modes and details of the memory system page tables. The MIPS architecture has evolved considerably since then (in particular, from 32 to 64 bits), which means that spim will not run programs compiled for recent MIPS or SGI processors. MIPS compilers also generate a number of assembler directives that spim cannot process. These directives can be safely deleted.
Spim implements both a simple, terminal-style interface and a visual windowing interface. On Unix, the spim program provides the terminal interface and the xspim program provides the X window interface. On PCs, PCSpim provides the Windows interface. Macs are not explicitly supported, but the Unix/X window source will compile under Mac OS X.
You can download spim from the SPIM website.
This CD also contains SPIM tutorials.
MARS
MARS is a lightweight interactive development environment (IDE) for programming in MIPS assembly language, intended for educational-level use with Patterson and Hennessy's Computer Organization and Design. MARS features:
- GUI with point-and-click control and integrated editor
- Easy set/removal of breakpoints using check boxes
- Easily editable register and memory values, similar to a speadsheet
- Display values in hexadecimal or decimal
- Command line mode for instructors to test and evaluate many programs easily. Command-line arguments to specify registers and memory locations to be displayed after the program run, to examine for correct contents. Set up a "batch" to do many programs in succession.
- Floating point registers, coprocessor1 and coprocessor0
- Variable-speed execution
- "Tool" utility for MIPS control of simulated devices. A tool is a program running on a separate thread with access to MARS data. An assembly program can run in MARS and interact with the tool through memory-mapped IO. Any imaginable pseudo-device can be interfaced to MIPS assembly code, or extended to physical devices or hardware.
You can download MARS and find tutorial material at the MARS website.
MIPS SDE-Lite
MIPS® SDE (Software Development Environment) is a cross-development system for MIPS architecture processors. It produces loadable/rommable code for a variety of MIPS-based platforms and also simulator platforms. It is intended for building and debugging statically-linked applications to run in embedded environments on "bare-metal" CPUs or light-weight operating systems.
MIPS® SDE-Lite is a free version of MIPS® SDE; the difference is (a) you don't get re-usable source code for the proprietary libraries, and (b) you don't get user support from MIPS Technologies, Inc. You can get these extras by purchasing a full copy from MIPS Technologies.
You can download the software from the MIPS Technologies website. On the home page, choose Tools & Software from the Solutions drop-down list. Then choose MIPS® SDE Lite from the menu at the left. The MIPS® SDE Programmer’s Guide (available on the download page) contains detailed installation instructions.
Xilinx FPGA Design, Simulation and Synthesis Software
Xilinx offers a wide range of software tools to support design of Xilinx FGPAs. Tools include the Xilinx Integrated Software Enviroment (ISE), ChipScope Pro for real-time debug and verification, and the ModelSim Xilinx Edition III (MXE III) VHDL/Verilog simulator.
ISE and ChipScope Pro Evaluation versions are fully functioning versions of Xilinx design software with a 60-day time-limited license. ISE WebPACK offers free downloadable design tools with no time limit, limited to lower-density FPGA and CPLD design. All are ideal for the educational environment.
You can download the software tools from the Xilinx website.
On the home page, click on the Design Tools link under the Products and Services heading. On the Design Tools page, the left column contains links to ISE™ WebPACK™ Software and ModelSim Xilinx Edition-III (MXE-III). Follow these links to access the download pages.
To download the software, you will need a Xilinx account. If you have not previously registered, you can create an account from the Sign in page.
In order to use MXE III, you can either obtain a free Starter version license or purchase a full license. To obtain a free Starter license, you first need to install the software. Download and unpack the Zip file to a temporary folder, then launch Setup.exe in that folder. In the installer, select MXE III Starter as the version to install, then follow the instructions. Once the software is installed, see the License Request Instructions in the ModelSim XE III program group in the Start/All Programs menu on your computer.


Lean0n.me Policies and Documentation Values and Community Standards Terms of Service Commerce Terms Supporter Oath Privacy Policy Safety, Privacy, and Reporting Guidelines and Tips Articles of Incorporation 501(c)(3)


Paycheck Estimator
Select a Job:
{{job.title}}
Gross Pay
Salary
{{jobInfo.wage}}
Frequency
*
*
{{jobInfo.frequency}}
Pay Period Gross
{{payPeriodGross}}
Annual Gross
{{annualGross}}
* Hourly frequencies will be estimated weekly at 40 hour weeks
* Annual frequencies will be estimated using monthly pay periods
Filing Status and Witholdings
Filing Status
{{jobInfo.filing_status}}
Allowances
{{jobInfo.allowances}}
Income Adjustments
Retirement Percentage
{{jobInfo.retirement_percent}}
Other Pre-Tax Amount
{{jobInfo.pretax_static}}
Other Post-Tax Amount
{{jobInfo.posttax_static}}
Estimated Paycheck
Net Paycheck
{{afterTax}}
Taxable Income
{{taxableIncome}}


--- layout: newsstory title: NEW-LOOK SOLID YELTZ FOR 1999 match: Crawley 1 Yeltz 1 ---
The Yeltz earned a hard-fought point on Saturday with an excellent 1-1 draw at high-flying Crawley .
They're probably the only team who can get remotely close to Nuneaton if they win their games in hand, so it was never going to be easy. They had most of the play , but the defence - and Danny in particular - were well solid. We even took the lead through a Ralphy Crisp header just after half-time, but they equalised just after and piled on the pressure. However we held firm and came away with a welcome point .
Every other game was decisive and it's probably even closer now, with only 9 points covering 3rd to 18th in the table. We've slipped a couple of places to 13th .


{{extend 'layout.html'}}
{{=askemail}}
{{=A("Don't have a Five College email?", _href=URL(c='gamectrl',f='registerrequest'))}}


A declaration
:- volatile :PredSpec, ..., :PredSpec.
where each PredSpec is a predicate spec, causes the specified predicates to become volatile.
A predicate should be declared as volatile if it refers to
data that cannot or should not be saved in a saved-state. In most
cases a volatile predicate will be dynamic, and it
will be used to keep facts about streams or memory
references. When a program state is saved at run-time, the
clauses of all volatile predicates will be left
unsaved. The predicate definitions will be saved though, which
means that the predicates will keep all its properties such as
volatile
, dynamic
or multifile
when the
saved-state is restored.


{% extends 'base.html' %} {% block content %}
Showcasing amazing web applications in a developer's world.Feel free to rate any of the projects
Bringing out the best in someone
{{project.description}}


Asynxy is a "middleware" web application that performs remote code execution for a "master" node to a set of slaves. This is achieved through a periodic request for new commands from the slaves, a local execution using Python and lastly a post of the command's results back to the webapp for the master to see. The benefits that the webapp introduces is control over a large set of slaves either individually or as a group (botnet-like) and a connection mostly unbothered by firewalls or NAT since it is based on HTTP and is always initiated from the slaves.
This website was created to hone my skills using the holy web triad, HTML, CSS, Javascript. The website features a simple description of me and what I do, my projects, my skills, my CV (Curicculum Vitae) and some references or testimonials that I possess. In order to make the experience more fun I have given the option for the user to use multiple colorschemes (themes) to browse my webpage.
A simple web application that uses the combination of Node.js and the Redis key-value store in order to simulate a "game" and the actions that an RPG player would use. The user can search for other users ,register a new account, login with his password, and do certain game actions such as looting an enemy, finding treasures, buying from stores, selling to stores and viewing his account information and inventory. A live demo is coming soon.
Two simple auth web applications in Java Servlet structure in Apache Tomcat 8. The users are saved in a MariaDB database and the interface is implemented using JDBC in the first webapp, and Hibernate JPA in the second webapp. The live demo is not running right now, but it is coming soon.
This project was the final project for two courses: ECE417 and ECE514. For the ECE417 we created a Network Intrusion Detection System that classifies on the normality of the traffic, detecting possible cyber attacks happening. We experimented on Random Forest, Support Vector Machine and Multilayer Perceptron with the latter being the best-performing ML model on data taken from the Australian Center for Cyber Security (UNSW). For ECE514 we focused on creating a "pipeline" that collects data in real time, extracts features to create datasets and passes them to our MLP model for live predictions. The repository contains - apart from the code - the paper reports and presentations of the project.
LSTM (Long Short-Term Memory) neural network model performing timeseries analysis on number of citations achieved by scientific papers year by year. The model predicts the number of the citations the paper in question will have in the following year, and 5 years after.
Program written in C language, that reads reviews of movies and the ratings, parses the reviews and creates a score of each word based on the times of appearance and the rating of the reviews it appears in. Then, using these scores of arbitrary words, the program can deduce a rating given a random review.
tASE is a collaborative project with GRNET CERT. It is a framework that automates platform or application security testing through the use of various security tools using user defined scenarios written in Gherkin format. It can do both static and dynamic analysis using tools such as OWASP ZAP, Nmap, Bandit. The project has also well-defined ways to add new tools and write more complex scenarios, thus leveraging End User Development. The project is not Open Source.
Project done for the course Internet Protocol Design. The project delves into popular Network attacks on network protocols, specifically ARP and DNS Spoofing, MAC Table Overflow, TCP SYN Flooding, TCP RST attack, TCP Session Highjacking and Heartbleed. We set up test environments where we used tools and scripts to perform these attacks on test victims, and we created a report containing the theory behind the attacks, and the steps we followed to perform them.
For the Blockchain course, we studied Ethereum smart contracts written in Solidity, we tried to identify common Security Vulnerabilities that led to serious exploits (e.g. DAO Hack) and bad coding practices, and we presented a proof of concept live demo on some of them after first testing vulnerable code with Oyente (smart contract static analysis tool), then compiling it deploying it into the Ropsten test network and exploiting them within the online IDE Remix.
Coordinated a cybersecurity team of students in Volos, that participated as a part of GFOSS (ΕΕΛΛΑΚ) in the annual Cybersecurity Exercise Panoptis 2019, organised by the Department of Cyberdefense (ΔΙΚΥΒ) of the Hellenic National Defense General Staff (ΓΕΕΘΑ). The team successfully solved the episodes of Data Exfiltration and Social Network Communication Analysis, for which episode we also composed the GFOSS report.
Participated and reached the final round of this Cybersecurity challenge (after ranking 11th in preliminaries) that involved various problems including Web exploitation, cryptography, reverse engineering, network forensics, steganography and generally a big spectrum of the security field. Finished 20th out of 178 contestants.
A simple bash script using several tools to monitor system status like memory, networking or user information, presenting them in an easily readable way and refreshing the information every couple seconds.
A utility I designed for my work at "Friktoria.com Data Center Services" that enables the secondary nameservers to be synchronised with the addition of new zones in the primary nameservers, that BIND does not automatically do. The project is in production and closed source.
Using the python library of nmap I created a python script that searches in the subnet of the interface specified by the user, finds devices and prints the results in a nice and colorful - more human readable way.
For the course of Networks 2 (focusing on SDN), I implemented the VLAN structure shown in the image using Python and the Ryu SDN framework. The code is executed by controllers taking action whenever a new packet (with no set routing rule) passes from a switch or router.
Project done for the course Internet Protocol Design. The project delves into popular Network attacks on network protocols, specifically ARP and DNS Spoofing, MAC Table Overflow, TCP SYN Flooding, TCP RST attack, TCP Session Highjacking and Heartbleed. We set up test environments where we used tools and scripts to perform these attacks on test victims, and we created a report containing the theory behind the attacks, and the steps we followed to perform them.
This project was the final project for two courses: ECE417 and ECE514. For the ECE417 we created a Network Intrusion Detection System that classifies on the normality of the traffic, detecting possible cyber attacks happening. We experimented on Random Forest, Support Vector Machine and Multilayer Perceptron with the latter being the best-performing ML model on data taken from the Australian Center for Cyber Security (UNSW). For ECE514 we focused on creating a "pipeline" that collects data in real time, extracts features to create datasets and passes them to our MLP model for live predictions. The repository contains - apart from the code - the paper reports and presentations of the project.


--- layout: post status: publish published: true title: Debbie Downer says sorry, they're not going to make it. author: display_name: Kurt login: Kurt email<EMAIL_ADDRESS>url: '' author_login: Kurt author_email<EMAIL_ADDRESS>wordpress_id: 1462 wordpress_url: http://ivyenvy.com/?p=1462 date: '2009-09-17 11:05:49 +0000' date_gmt: '2009-09-17 17:05:49 +0000' categories: - The Cubs tags: - Alfonso Soriano - Playoffs - Rockies - Wildcard - Debbie Downer comments: - id: 818 author: Andy author_email<EMAIL_ADDRESS>author_url: http://ivyenvy.com date: '2009-09-17 13:43:26 +0000' date_gmt: '2009-09-17 19:43:26 +0000' content: "Man, I'm depressed now, Kurt. \r\n\r\nEven though I talked about watching the Cubs just to enjoy some baseball, my brain still has some tendrils clinging to the hope that they still could pull off a miracle and make it. The Rockies just had a three-game losing streak going, and that also gives me hope that they could perhaps play sub-.500 ball for the rest of the year. But they are 6-4 in their last ten games. I know Corey doesn't want them to pull it off because then they will have made it to the playoffs in an imperfect season." - id: 819 author: Kurt author_email<EMAIL_ADDRESS>author_url: http:// date: '2009-09-17 13:58:51 +0000' date_gmt: '2009-09-17 19:58:51 +0000' content: "I hope I, and Debbie, are wrong. I'll take the playoffs. \r\nThey actually lost 4 in a row between the Padres and Giants, but before that they had won 8 in a row. My scenario also neglects to acknowledge that there are three other teams between the Rockies and Cubs that also need to play poorly and hand over the wildcard. I'm such a jerk, but somebody has to play the Dr. Phil role and let everybody know when it's time to move on.  WAH WAH. :(" ---
It's been a long time since I've posted anything. In fact, my last post was July 20. This may hurt me in my yearly performance review with IvyEnvy president and CEO, Corey. In such tough economic times I'm hoping the 2010 budget allows me to stay on staff, but I would understand if Corey's iron fist were to downsize my position. Ad revenues are down and the great state of Illinois has upped the liquor tax making it the highest in the nation. These things don't help my cause.
And so I return to the blog world with the following upbeat and positive message from Debbie Downer and Captain Obvious. They're not going to make it. With a 7-3 record, the past ten games have given a little fuel to the "they're still in it" and "don't give up yet" debates. As a group we at ivyeny have pretty much written off the chances of a comeback. Then, with the loss of our beloved Soriano and roster expansion the Cubs go on a tear, winning 10 of 15 in September and now sit just 6.5 games back of the wildcard leading Rockies. Whoa! 6.5 games...that's doable, right? Not really. They'd have to play even better. The Rockies have continued to play well in September with little sign of a falloff. The Rockies have 15 games remaining. If they finish one game over .500 (not likely to happen) their record will be 91-71. Just to tie, the Cubs will need to finish their 18 games at 16-2. Not an easy task.
This isn't pessimism talking, it's realism. I have to admit I got caught up in the thought that if they continued their winning ways they might make it. Then I did the ridiculous math above and found out my hopes were not founded in reality. I think I need to take a page from Andy's book and just watch the games for the pure pleasure of watching baseball.


--- layout: post title: ! 'Paris on Rails: December 10th' categories: - horizon author: David published: true date: 2007-10-29 18:02:00.000000000 +00:00 ---
Paris on Rails is a French-speaking Rails conference that’s taking place in Paris on December 10th. They have a great program for the day with 10 speakers (yours truly included via a video chat). If you speak French, check it out. The one-day event is 100 euro (or 70 euros before November 15th).


--- layout: product.hbs title: "Cree LED Light Bar, LED Offroad Light, LED Search Light, LED Work Light, LED Automobile Lamp, Vehicle Replace Bulb, China LED Light Bar Suppliers Manufacturers, Cree LED Light Bar Wholesalers" description: "MICZE has a strong technical force of production Cree LED Light Bar Offroad, LED Truck Light, LED Work Light, and we are China LED Light Bar Suppliers Manufacturers, LED Light Bar Wholesalers" keywords: - Cree LED Light Bar Offroad - LED Light Bar USA/Dubai/Canada/Australia - LED Light Bar for trucks - "LLB-1-120W" - "LLB-3A-120W" - LED Offroad Light - LED Truck Light - Agriculture Light - China LED Light Bar Suppliers Manufacturers - Cree LED Light Bar Wholesalers - LED Work Light - LED Search Light ---
|
LED LIGHT BAR - 7 Series |
|||||||||||||||||||||||||||||||||||
|
LED LIGHT Bar |
|||||||||||||||||||||||||||||||||||
|
MODEL NO:
|
Feature: • Operation Voltage: 10-30VDC • Waterproof rate: IP67 • Color: Black • Color Temperature: 6000K • Material: Extrusion die aluminum housing • Lens material: PC • Mounting Bracket: Alu firm bracket • Beam: Combo(20+10degree) • 30000 hours above life time |
||||||||||||||||||||||||||||||||||
|
|||||||||||||||||||||||||||||||||||


{% extends 'global/base.html' %} {% load i18n rev static %} {% block extra_js %} {% endblock %} {% block content %}
{% blocktrans trimmed %} Django Girls is an initiative aimed at introducing women who have never coded before to the world of technology and increasing the diversity within the tech industry. We do that by organizing workshops and inviting women to join us to learn how to build the internet using HTML, CSS, Python and Django in a safe, friendly and inclusive environment. {% endblocktrans %}
{% trans "As a Django Girls Organizer, you make a commitement to foster and advance Django Girls values:" %}


Ellis Medicine Plan Track Quality Portfolio Reports User Actions Time In Process CURRENT TIP CORE (CUSTOM) CUSTOM HTML CORE (CUSTOM) CA Agile Central|About|Support|Legal SOURCE CODE: CUSTOM HTML