Ray Kurzweil - How to Create a Mind
Ray Kurzweil 2014. How to Create a Mind. The secret of human thought revealed. London: Duckworth Overlook. 336 pp.
The human cortex and human consciousness is a pattern matching device that can be modelled as a hierarchical hidden Markov model. Software implementations using the same model are increasingly successful in artificial intelligences - evidence that the model may accurately describe the workings of the human mind.
More to come…
Recently acquired in the same theme but not yet read, this book by another researcher in the same group:
Roberto Pieraccini 2012. The Voice in the Machine. Cambridge, Massachusetts: MIT Press Books. 325 pp.


Visit the official government website for more information Click Here
Incredible India (styled as Incredıble!ndıa) is the name of an international tourism campaign maintained by the Government of India since 2002, to promote tourism in India. The "Incredible India" title was officially branded and promoted since 2002. India represents “Unity in Diversity” . Our country is a mixture of cultures, regions, traditions, diversity in food, languages, etc. Our people of India are so polite, understanding and helping in nature. The national bird of India is Peacock and is very beautiful. India is so incredible and is full of colors and has the tiger as its national animal, hockey as its national game, etc. Indians are also so talented and have shown very high growth.India is the seventh-largest country by its geographical area and is located in South Asia. The beauty surrounds our country from each and every aspect. India is also known by two other names Bharat and Hindustan and the people of India are known as Indians.


{% extends "layout/base.html" %} {% block content %}
I used to enjoy bumping elbows with miners while building a dark matter detector.
Now I enjoy data science.


Lua module to control NETIO smart sockets over their M2M API's
Modules
| netio | lua-netio is a library to control outputs of NETIO 4x smart power sockets from NETIO products a.s. |
| netio.json | Implements the JSON API: Protocol version: JSON API Version 2.0(PDF) |
| netio.url | Implements the URL API: Protocol version: URL API Version 1.0(PDF) |
| web_core | Some methods which are used in URL and JSON API |
Manual
| dstructures.md | |
| errors.md |
Examples
| jsonapi-demo.lua | |
| urlapi-demo.lua |


lib/models/per-bundle-addon-cache/index.js:46
PerBundleAddonCache {
For large applications with many addons (and many instances of each, resulting in potentially many millions of addon instances during a build), the build can become very, very slow (tens of minutes) partially due to the sheer number of addon instances. The PerBundleAddonCache deals with this slowness by doing 3 things:
(1) Making only a single copy of each of certain addons and their dependent addons
(2) Replacing any other instances of those addons with Proxy copies to the single instance
(3) Having the Proxies return an empty array for their dependent addons, rather
than proxying to the contents of the single addon instance. This gives up the
ability of the Proxies to traverse downward into their child addons,
something that many addons do not do anyway, for the huge reduction in duplications
of those child addons. For applications that enable ember-engines
dedupe logic,
that logic is stateful, and having the Proxies allow access to the child addons array
just breaks everything, because that logic will try multiple times to remove items
it thinks are duplicated, messing up the single copy of the child addon array.
See the explanation of the dedupe logic in
{@link https://github.com/ember-engines/ember-engines/blob/master/packages/ember-engines/lib/utils/deeply-non-duplicated-addon.js}
What follows are the more technical details of how the PerBundleAddonCache implements the above 3 behaviors.
This class supports per-bundle-host (bundle host = project or lazy engine)
caching of addon instances. During addon initialization we cannot add a
cache to each bundle host object AFTER it is instantiated because running the
addon constructor ultimately causes Addon class setupRegistry
code to
run which instantiates child addons, which need the cache to already be
in place for the parent bundle host.
We handle this by providing a global cache that exists independent of the
bundle host objects. That is this object.
There are a number of "behaviors" being implemented by this object and its contents. They are: (1) Any addon that is a lazy engine has only a single real instance per project - all other references to the lazy engine are to be proxies. These lazy engines are compared by name, not by packageInfo.realPath. (2) Any addon that is not a lazy engine, there is only a single real instance of the addon per "bundle host" (i.e. lazy engine or project). (3) An optimization - any addon that is in a lazy engine but that is also in bundled by its LCA host - the single instance is the one bundled by this host. All other instances (in any lazy engine) are proxies.
NOTE: the optimization is only enabled if the environment variable that controls
ember-engines
transitive deduplication (process.env.EMBER_ENGINES_ADDON_DEDUPE)
is set to a truthy value. For more info, see:
https://github.com/ember-engines/ember-engines/blob/master/packages/ember-engines/lib/engine-addon.js#L396
Method Summary
| Public Methods | |
|---|---|
| public |
allowCachingPerBundle(addonEntryPointModule): Boolean
The default implementation here is to indicate if the original addon entry point has the |
| public |
bundleHostOwnsInstance((Object}, addonPkgInfo): Boolean
An optimization we support from lazy engines is the following: |
| public |
createAddonCacheEntry(addonInstance, addonRealPath): Object
Create a cache entry object for a given (non-bundle-host) addon to put into an addon cache. |
| public |
createBundleHostCacheEntry(bundleHostPkgInfo): Object
Creates a cache entry for the bundleHostCache. Because we want to use the same sort of proxy for both bundle hosts and for 'regular' addon instances (though their cache entries have slightly different structures) we'll use the Symbol from getAddonProxy. |
| public |
findBundleHost(addonParent, addonPkgInfo): Object
Given a parent object of a potential addon (another addon or the project), go up the 'parent' chain to find the potential addon's bundle host object (i.e. lazy engine or project.) Because Projects are always bundle hosts, this should always pass, but we'll throw if somehow it doesn't work. |
| public |
Called from PackageInfo.getAddonInstance(), return an instance of the requested addon or a Proxy, based on the type of addon and its bundle host. |
| public |
getAddonProxy(targetCacheEntry, parent):
Returns a proxy to a target with specific handling for the |
| public |
resolvePerBundleAddonCacheUtil(project): AllowCachingPerBundle: Function
Resolves the perBundleAddonCacheUtil; this prefers the custom provided version by the consuming application, and defaults to an internal implementation here. |
| public |
validateCacheKey(realAddonInstance, treeType, newCacheKey)
Validates that a new cache key for a given tree type matches the previous cache key for the same tree type. To opt-in to bundle addon caching for a given addon it's assumed that it returns stable cache keys; specifically this is because the interplay between bundle addon caching and |
Public Methods
lib/models/per-bundle-addon-cache/index.js:116
public allowCachingPerBundle(addonEntryPointModule): Boolean
The default implementation here is to indicate if the original addon entry point has
the allowCachingPerBundle
flag set either on itself or on its prototype.
If a consuming application specifies a relative path to a custom utility via the
ember-addon.perBundleAddonCacheUtil
configuration, we prefer the custom implementation
provided by the consumer.
Return:
true if the given constructor function or class supports caching per bundle, false otherwise
lib/models/per-bundle-addon-cache/index.js:197
public bundleHostOwnsInstance((Object}, addonPkgInfo): Boolean
An optimization we support from lazy engines is the following:
If an addon instance is supposed to be bundled with a particular lazy engine, and
same addon is also to be bundled by a common LCA host, prefer the one bundled by the
host (since it's ultimately going to be deduped later by ember-engines
).
NOTE: this only applies if this.engineAddonTransitiveDedupeEnabled is truthy. If it is not, the bundle host always "owns" the addon instance.
If deduping is enabled and the LCA host also depends on the same addon, the lazy-engine instances of the addon will all be proxies to the one in the LCA host. This function indicates whether the bundle host passed in (either the project or a lazy engine) is really the bundle host to "own" the new addon.
Parameters:
| Name | Type | Attribute | Description |
|---|---|---|---|
| (Object} | Object |
|
bundleHost the project or lazy engine that is trying to "own" the new addon instance specified by addonPkgInfo |
| addonPkgInfo | PackageInfo |
|
the PackageInfo of the potential new addon instance |
Return:
true if the bundle host is to "own" the instance, false otherwise.
lib/models/per-bundle-addon-cache/index.js:145
public createAddonCacheEntry(addonInstance, addonRealPath): Object
Create a cache entry object for a given (non-bundle-host) addon to put into an addon cache.
Parameters:
| Name | Type | Attribute | Description |
|---|---|---|---|
| addonInstance | Addon |
|
the addon instance to cache |
| addonRealPath | String |
|
the addon's pkgInfo.realPath |
Return:
an object in the form of an addon-cache entry
lib/models/per-bundle-addon-cache/index.js:132
public createBundleHostCacheEntry(bundleHostPkgInfo): Object
Creates a cache entry for the bundleHostCache. Because we want to use the same sort of proxy for both bundle hosts and for 'regular' addon instances (though their cache entries have slightly different structures) we'll use the Symbol from getAddonProxy.
Parameters:
| Name | Type | Attribute | Description |
|---|---|---|---|
| bundleHostPkgInfo | PackageInfo |
|
bundle host's pkgInfo.realPath |
Return:
an object in the form of a bundle-host cache entry
lib/models/per-bundle-addon-cache/index.js:158
public findBundleHost(addonParent, addonPkgInfo): Object
Given a parent object of a potential addon (another addon or the project), go up the 'parent' chain to find the potential addon's bundle host object (i.e. lazy engine or project.) Because Projects are always bundle hosts, this should always pass, but we'll throw if somehow it doesn't work.
Parameters:
| Name | Type | Attribute | Description |
|---|---|---|---|
| addonParent | Project | Addon |
|
the direct parent object of a (potential or real) addon. |
| addonPkgInfo | PackageInfo |
|
the PackageInfo for an addon being instantiated. This is only used for information if an error is going to be thrown. |
Return:
the object in the 'parent' chain that is a bundle host.
Throws:
if there is not bundle host
lib/models/per-bundle-addon-cache/index.js:248
public getAddonInstance(parent, addonPkgInfo): Addon | Proxy
Called from PackageInfo.getAddonInstance(), return an instance of the requested addon or a Proxy, based on the type of addon and its bundle host.
Parameters:
| Name | Type | Attribute | Description |
|---|---|---|---|
| parent | Addon | Project |
|
the parent Addon or Project this addon instance is a child of. |
| addonPkgInfo |
|
the PackageInfo for the addon being created. |
Return:
An addon instance (for the first copy of the addon) or a Proxy.
An addon that is a lazy engine will only ever have a single copy in the cache.
An addon that is not will have 1 copy per bundle host (Project or lazy engine),
except if it is an addon that's also owned by a given LCA host and transitive
dedupe is enabled (engineAddonTransitiveDedupeEnabled
), in which case it will
only have a single copy in the project's addon cache.
lib/models/per-bundle-addon-cache/addon-proxy.js:42
public getAddonProxy(targetCacheEntry, parent):
Returns a proxy to a target with specific handling for the
parent
property, as well has to handle the app
property;
that is, the proxy should maintain correct local state in
closure scope for the app
property if it happens to be set
by ember-cli
. Other than parent
& app
, this function also
proxies almost everything to target[TARGET_INSTANCE] with a few exceptions: we trap & return
[]for
addons, and we don't return the original
included(it's already called on the "real" addon by
ember-cli`).
Note: the target is NOT the per-bundle cacheable instance of the addon. Rather, it is a cache entry POJO from PerBundleAddonCache.
Parameters:
| Name | Type | Attribute | Description |
|---|---|---|---|
| targetCacheEntry | Object |
|
the PerBundleAddonCache cache entry we are to proxy. It has one interesting property, the real addon instance the proxy is forwarding calls to (that property is not globally exposed). |
| parent | Object |
|
the parent object of the proxy being created (the same as the 'parent' property of a normal addon instance) |
Return:
Proxy
lib/models/per-bundle-addon-cache/index.js:17
public resolvePerBundleAddonCacheUtil(project): AllowCachingPerBundle: Function
Resolves the perBundleAddonCacheUtil; this prefers the custom provided version by the consuming application, and defaults to an internal implementation here.
Parameters:
| Name | Type | Attribute | Description |
|---|---|---|---|
| project | Project |
|
Return:
}
lib/models/per-bundle-addon-cache/addon-proxy.js:7
public validateCacheKey(realAddonInstance, treeType, newCacheKey)
Validates that a new cache key for a given tree type matches the previous
cache key for the same tree type. To opt-in to bundle addon caching for
a given addon it's assumed that it returns stable cache keys; specifically
this is because the interplay between bundle addon caching and ember-engines
when transitive deduplication is enabled assumes stable cache keys, so we validate
for this case here.
Parameters:
| Name | Type | Attribute | Description |
|---|---|---|---|
| realAddonInstance | Addon |
|
The real addon instance |
| treeType | String |
|
|
| newCacheKey | String |
|
Throws:
If the new cache key doesn't match the previous cache key


Photography can capture some of life's best moments, put them in a little picture, and save them for you to enjoy later. Photography can play with our emotions, sometimes in a bad way, like a picture from the holocost, but usually in a good way, such as a family vacation you enjoyed or a fun night out with friends. Photography can bring past moments to a whole new life, capturing moments we thought were long lost and bringing them back, fresh in our minds. This is why we think photography is important.
 This mixed with a mid ranged aperature led to a very focused picture with good mixed lighting.
Pictured below is another picture of a fruit I did, same ISO, Shutterspeed, and Aperature, but with a darker background.
Back to Top


MENU
CONTACT
FIND US
The best way to get your coffee without leaving the comfort of your house
make your order


Describes the status of a window of a door/liftgate etc.
@since SDL 7.0.0
- (nonnull instancetype)initWithLocation:(nonnull SDLGrid *)location
state:(nonnull SDLWindowState *)state;
init(location: SDLGrid, state: SDLWindowState)
- location
- state
A SDLWindowStatus object
location
Mandatory
@property (nonatomic, strong) SDLGrid *_Nonnull location;
var location: SDLGrid { get set }
state
Mandatory
@property (nonatomic, strong) SDLWindowState *_Nonnull state;
var state: SDLWindowState { get set }


Array with object's children.
Custom depth material to be used when rendering to the depth map. Can only be used in context of meshes. When shadow-casting with a DirectionalLight or SpotLight, if you are (a) modifying vertex positions in the vertex shader, (b) using a displacement map, (c) using an alpha map with alphaTest, or (d) using a transparent texture with alphaTest, you must specify a customDepthMaterial for proper shadows.
Same as customDepthMaterial, but used with PointLight.
When this is set, it checks every frame if the object is in the frustum of the camera. Otherwise the object gets drawn every frame even if it isn't visible.
Unique number of this object instance.
Used to check whether this or derived classes are Object3Ds. Default is true. You should not change this, as it is used internally for optimisation.
Local transform.
When this is set, it calculates the matrix of position, (rotation or quaternion) and scale every frame and also recalculates the matrixWorld property.
The global transform of the object. If the Object3d has no parent, then it's identical to the local transform.
When this is set, it calculates the matrixWorld in that frame and resets this property to false.
Optional name of the object (doesn't need to be unique).
Calls after rendering object
Calls before rendering object
Object's parent in the scene graph.
Object's local position.
Global rotation.
Material gets baked in shadow receiving.
Overrides the default rendering order of scene graph objects, from lowest to highest renderOrder. Opaque and transparent objects remain sorted independently though. When this property is set for an instance of Group, all descendants objects will be sorted and rendered together.
Object's local rotation (Euler angles), in radians.
Object's local scale.
Up direction.
An object that can be used to store custom data about the Object3d. It should not hold references to functions as these will not be cloned.
Object gets rendered if true.
Adds object as child of this object.
Adds a listener to an event type.
The type of event to listen to.
The function that gets called when the event is fired.
This updates the position, rotation and scale with the matrix.
Adds object as a child of this, while maintaining the object's world transform.
Fire an event type.
Searches through the object's children and returns the first with a matching id.
Unique number of the object instance
Searches through the object's children and returns the first with a matching name.
String to match to the children's Object3d.name property.
Checks if listener is added to an event type.
The type of event to listen to.
The function that gets called when the event is fired.
Updates the vector from local space to world space.
A local vector.
Rotates object to face point in space.
A world vector to look at.
Removes object as child of this object.
Removes a listener from an event type.
The type of the listener that gets removed.
The listener function that gets removed.
Rotate an object along an axis in object space. The axis is assumed to be normalized.
A normalized vector in object space.
The angle in radians.
Rotate an object along an axis in world space. The axis is assumed to be normalized. Method Assumes no rotated parent.
A normalized vector in object space.
The angle in radians.
A normalized vector in object space.
The distance to translate.
Translates object along x axis by distance.
Distance.
Translates object along y axis by distance.
Distance.
Translates object along z axis by distance.
Distance.
Updates local transform.
Updates global transform of the object and its children.
Updates the vector from world space to local space.
A world vector.
Generated using TypeDoc
Gets rendered into shadow map.


{% load i18n %}
{% trans 'If you like the website, please consider donating. This will help us cover the costs of the servers and allow us to keep it running for free and without ads.' %}


{% extends "base.html" %} {% block title %} COMET Home{% endblock %} {% block content%}
The goal of COMET is to determine the effect of SNPs using protein-protein interactions (PPIs), specifically in the calculation of the ∆∆G value.
Single nucleotide polymorphisms (SNPs) are the most common type of genetic variation. SNPs are locations in the DNA where the base nucleotide (A, T, C or G) tend to vary between different people.
The genotype is the nucleotide(s) that the genetic test determined. Autosomal chromosomes (chromosomes 1-22) come in pairs so there are two nucleotides for the reported genotype. The genotype of the sex chromosomes depends on the sex of the person genotyped.
Clinical significance is obtained from dbSNP. Example outputs include benign, likely benign, uncertain significance, likely pathogenic, pathogenic, drug response, risk factor, etc. For more information please visit NCBI's ClinVar documentation (ClinVar documentation link).
Related conditions are obtained from ClinVar and related diseases are obtained from LitVar. The ClinVar conditions include the number of times the condition appears in the database whereas the LitVar diseases include the number of published literature about the disease and the given SNP.
For a given SNP, there can be multiple amino acid subsitutions and/or nucleotide subsitutions. Multiple substitutions may be due to the protein having multiple isomers (protein variants) as a result of alternative splicing.
The frequency of each SNP is compared to The 1000 Genomes Project and the HapMap Project when available.
The ∆∆G value is predicted using four programs (SAAMBE-3D, I-Mutant2.0 (sequence and structure), PANDA and UEP). The stability consensus is determined based on the number of programs that indicate an increase in stability verusus a decrease in stability.
Regarding the interpretation of ∆∆G values, the effect of the mutation is determined by the sign of the ∆∆G value. Positive ∆∆G values for I-Mutant2.0 and PANDA indicate an increase in stability whereas for SAAMBE-3D and UEP indicate a decrease in stability. Thus, negative ∆∆G values for I-Mutant2.0 and PANDA indicate a decrease in stability whereas for SAAMBE-3D and UEP indicate an increase in stability.
These programs accept the protein sequence (obtained from Uniprot) and/or the protein (PDB) structure (obtained from RCSB). Sometimes the programs may not produce an output. If there is no PDB structure, SAAMBE-3D, I-Mutant2.0 (structure) and UEP cannot calculate the ∆∆G value. If there is no sequence, I-Mutant2.0 (structure) and PANDA cannot calculate the ∆∆G value. Additionally, UEP only evaluates mutations located in highly-packed interface positions. UEP and and PANDA also rely on an explicitly stated secondary protein to calculate the ∆∆G value.
The protein viewer uses the NGL viewer to display the PDB structure used to calculate the ∆∆G value. The different interaction controls are outlined on the NGL viewer documentation (NGL Viewer Link).
If you do not have a raw genotype file or prefer to not use your own, you can use the browse SNP option. Alternatively, you can freely download raw genotype files from OpenSnp. (OpenSNP Link). All raw genotype data is automatically deleted when the End Session button is clicked. If you forget to click this button, the data will be automatically deleted after 24 hours.


100% OPTIONAL, However we strongly recommend to be the 1st to cmeet new members and sms instantly and anonymously
Sugar Baby
Sugar Daddy
Sugar Daddy


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 4
Heat the oil in a large lidded pan. Add the onion and carrot and fry over a medium heat for five minutes until soft.
Add the minced beef to the pan and fry for a few minutes to brown the mince all over.
Add the tomatoes, tomato purée, beef stock, bay leaf and thyme to the pan.
Simmer for 30 minutes. Season with salt and freshly ground black pepper.
In the meantime, for the mash topping, chop the potatoes into quarters and boil in a pan of boiling salted water for about 10-15 minutes, until tender.
When the potatoes are cooked, drain the water and mash the potatoes well.
Add cream, butter and salt and freshly ground black pepper to taste. Set aside. Preheat the oven to 190C/375F/Gas 5.
After 30 minutes cooking time, taste the meat, and add ketchup and Worcestershire sauce if desired. If the mixture is too wet, cook for a few more minutes to reduce the liquid.
In a separate pan, heat a little butter. Add the leeks and fry until softened, but not coloured.
Transfer the meat into an ovenproof dish and layer the leeks on top.
Arrange spoonfuls of the mash on top of the meat and leeks and use a wet spatula to smooth out the edges. Cook for about 30 minutes, until the potato is crisp and golden-brown around the edges. Serve hot.


An Example Markdown Post
A minimal example of using markdown with fastpages.
Example Markdown Post
Basic setup
Jekyll requires blog post files to be named according to the following format:
YEAR-MONTH-DAY-filename.md
Where YEAR
is a four-digit number, MONTH
and DAY
are both two-digit numbers, and filename
is whatever file name you choose, to remind yourself what this post is about. .md
is the file extension for markdown files.
The first line of the file should start with a single hash character, then a space, then your title. This is how you create a “level 1 heading” in markdown. Then you can create level 2, 3, etc headings as you wish but repeating the hash character, such as you see in the line ## File names
above.
Basic formatting
You can use italics, bold, code font text
, and create links. Here’s a footnote 1. Here’s a horizontal rule:
Lists
Here’s a list:
- item 1
- item 2
And a numbered list:
- item 1
- item 2
Boxes and stuff
This is a quotation
…and…
Images
Code
You can format text and code per usual
General preformatted text:
# Do a thing
do_thing()
Python code and output:
# Prints '2'
print(1+1)
2
Formatting text as shell commands:
echo "hello world"
./some_script.sh --option "value"
wget https://example.com/cat_photo1.png
Formatting text as YAML:
key: value
- another_key: "another value"
Tables
| Column 1 | Column 2 |
|---|---|
| A thing | Another thing |
Tweetcards
Altair 4.0 is released! https://t.co/PCyrIOTcvv
— Jake VanderPlas (@jakevdp) December 11, 2019
Try it with:
pip install -U altair
The full list of changes is at https://t.co/roXmzcsT58 ...read on for some highlights. pic.twitter.com/vWJ0ZveKbZ
Footnotes
-
This is the footnote. ↩


--- title: easyrelease keywords: fastai sidebar: home_sidebar summary: "Automate your GitHub, pypi and conda releases" description: "Automate your GitHub, pypi and conda releases" nb_path: "nbs/index.ipynb" ---
Via pip
pip install easyrelease
or via conda
conda install -c pablormira easyrelease
We conceptually differentiate between two kind of projects:
pip
or conda
After installation you need the fulfill the following prerequisites for the package to work:
You need to initialize a git project in your project root folder for this package to work, i.e. run in your command line
git init
You need to store your GitHub credentials (GitHub username and token) in your project root for automatic GitHub releases. The credentials should be stored in a file called .gh-credentials
with the following contents:
gh_user = Your GitHub username
gh_token = Your GitHub token
Only for python packages
For this package to work you need to comply to the following minimal project structure for python packages
package_name
|-- .git
|-- package_name
| |-- __init__.py
| |-- module1.py
| |-- module2.py
| |-- ...
|-- tests
| |-- test_module1.py
| |-- test_module2.py
| |-- ...
Only for python packages
To publish to Pypi you need to store your pypi credentials in a file with the name .pypi-credentials
in your user root or project root directory. The file should include the following contents
username = Your Pypi username
password = Your Pypi password
Only for python packages
To publish to Anaconda you need to store your anaconda credentials in a file with the name .anaconda-credentials
in your user root or project root directory. The file should include the following contents
username = Your Anaconda username
password = Your Anaconda password
Only for Linux users and only in case of problems
In case of problems concerning permission errors building your package via build-conda-package
you may need to add the following line to your ~/.bashrc
export CONDA_BLD_PATH=/tmp/conda-bld
Only once:
easyrelease-init application
settings.ini
.gh-release-config.yaml
.gh-release-config.yaml
sets the title and keyword that will be used to assign your commits to a certain section in your GitHub release notes and changelog. So if for example you want all commits to be in your release notes without keyword matching, you could modify .gh-release-config.yaml
as
gh_categories:
- title: "### Commits:"
keyword: ""
Each time you want to make a GitHub release:
gh-release
to make a GitHub releasemake-changelog
to generate / update your CHANGELOGOnly once:
easyrelease-init application
settings.ini
.gh-release-config.yaml
login-to-anaconda
Each time you want to release / publish your package:
publish-pypi-package
to publish to pypiupdate-meta-yaml
to generate / update your meta.yaml under conda-bldbuild-conda-package
to build your conda packageupload-conda-package
to publish your conda packagegh-release
to make a GitHub releasemake-changelog
to generate / update your CHANGELOGWe version our package via semantic versioning, i.e.,
New documentation, refactoring / maintenance of code and admin tasks do not change the versions.
You can follow the changes introduced by each version in our CHANGELOG
This package was inspired by the fastrelease package but it differs from it in the way it generates the release notes.
easyrelease
generates the release notes out of the commit messages whereas fastrelease
generates the release notes out of GitHub issues.
This package was also motivated by the fact that fastrelease
did not work for me out of the box in my first attempt and I really liked the idea of automating releases and package publishing.
This package was developed and is compatible with the nbdev framework but it also works for ordinary project development without notebooks.
In the case you want to develop your project with nbdev
you need to first initialize your project via nbdev
and afterwards run easyrelease-init
. This is because the settings.ini
we initialize for your project is a proper / strict subset of the settings.ini
from nbdev


WITNESS LIST Appropriations-S/C on Regulatory Committee February 9, 1999-8:00A Budget For: Boatright, Anne (Self) Carlton, Belinda (Coalition of Texans with Disabilities) Davis, Jennifer (Texas Cosmetology Assn) Hicks, Jim (San Jacinto Area Credit Union) Mallett, Cathey (Self) Mills, Cynthia (Self) Solis, Heather (Self) Tamez, Maria (Coalition of Texans with Disabilities) On: Almasov, Deborah (State Bd of Barber Examiners) Alspaugh, Delores (Texas Cosmetology Commission) Base, Gary (Community Credit Union) Brown, Will (State Bd of Barber Examiners) Canfield, Cynthia (State Bd of Architectural Examiners) Conaway, K. Michael (Texas Bd of Public Accountancy) Feeney, Harold (Credit Union Dept) Hendricks, Cathy (State Bd of Architectural Examiners) Hermanson, Alan (State Bd of Public Accountancy) Kuykendau, William (State Bd of Barber Examiners) Montemayor, Jose (Texas Dept of Insurance) Phillips, Karen (Texas Dept of Insurance) Roberts, Virginia (Texas Bd of Architectural Examiners) Sikes, Andrew (Texas Bd of Professional Land Surveying) Smith, Sandy (Texas Bd of Professional Land Surveying) Speed, John (Texas Bd of Professional Engineers) Taylor, Clare (Texas Cosmetology Commission) Treacy, William (State Bd of Public Accountancy) Treat, Herb (Texas Bd of Professional Engineers) Turner, Cleveland (Texas Bd of Architectural Examiners)


--- layout: page title: "Contact" description: "Have questions?" header-img: "img/contact-bg.jpg" ---
Want to get in touch with me? Fill out the form below to send me a private message
Please use Twitter first, I am way more active on it !!
I am using formingo.com to provide this form, you will be redirect to their website when you will click on the send button.


shakesphere
enter some text (or try a Shakespearean sonnet, helpfully provided). we'll generate a lot of haikus.
Mine eye hath played the painter and hath stelled, Thy beauty's form in table of my heart, My body is the frame wherein 'tis held, And perspective it is best painter's art. For through the painter must you see his skill, To find where your true image pictured lies, Which in my bosom's shop is hanging still, That hath his windows glazed with thine eyes: Now see what good turns eyes for eyes have done, Mine eyes have drawn thy shape, and thine for me Are windows to my breast, where-through the sun Delights to peep, to gaze therein on thee; Yet eyes this cunning want to grace their art, They draw but what they see, know not the heart.
SUBMIT


Apache™ FOP: Hyphenation
Hyphenation Support
Introduction
Apache™ FOP uses Liang's hyphenation algorithm, well known from TeX. It needs language specific pattern and other data for operation.
Because of licensing issues (and for convenience), all hyphenation patterns for FOP are made available through the Objects For Formatting Objects project.
License Issues
Many of the hyphenation files distributed with TeX and its offspring are licenced under the LaTeX Project Public License (LPPL), which prevents them from being distributed with Apache software. The LPPL puts restrictions on file names in redistributed derived works which we feel can't guarantee. Some hyphenation pattern files have other or additional restrictions, for example against use for commercial purposes.
Although Apache FOP cannot redistribute hyphenation pattern files that do not conform with its license scheme, that does not necessarily prevent users from using such hyphenation patterns with FOP. However, it does place on the user the responsibility for determining whether the user can rightly use such hyphenation patterns under the hyphenation pattern license.
Sources of Custom Hyphenation Pattern Files
The most important source of hyphenation pattern files is the CTAN TeX Archive.
Installing Custom Hyphenation Patterns
To install a custom hyphenation pattern for use with FOP:
- Convert the TeX hyphenation pattern file to the FOP format. The FOP format is an xml file conforming to the DTD found at {fop-dir}/hyph/hyphenation.dtd.
- Name this new file following this schema:
languageCode_countryCode.xml. The country code is
optional, and should be used only if needed. For example:
- en_US.xml would be the file name for American English hyphenation patterns.
- it.xml would be the file name for Italian hyphenation patterns.
- There are basically three ways to make the FOP-compatible hyphenation pattern
file(s) accessible to FOP:
- Download the precompiled JAR from OFFO and place it either in the {fop-dir}/lib directory, or in a directory of your choice (and append the full path to the JAR to the environment variable FOP_HYPHENATION_PATH).
- Download the desired FOP-compatible hyphenation pattern file(s) from
OFFO,
and/or take your self created hyphenation pattern file(s),
- place them in the directory {fop-dir}/hyph,
- or place them in a directory of your choice and set the Ant variable user.hyph.dir to point to that directory (in build-local.properties),
- Put the pattern source file(s) into a directory of your choice and configure FOP to look for custom patterns in this directory, by setting the <hyphenation-base> configuration option.
Hyphenation Patterns
If you would like to build your own hyphenation pattern files, or modify existing ones, this section will help you understand how to do so. Even when creating a pattern file from scratch, it may be beneficial to start with an existing file and modify it. See OFFO's Hyphenation page for examples. Here is a brief explanation of the contents of FOP's hyphenation patterns:
- The root of the pattern file is the <hyphenation-info> element.
- <hyphen-char>: its attribute "value" contains the character signalling a hyphen in the <exceptions> section. It has nothing to do with the hyphenation character used in FOP, use the XSLFO hyphenation-character property for defining the hyphenation character there. At some points a dash U+002D is hardwired in the code, so you'd better use this too (patches to rectify the situation are welcome). There is no default, if you declare exceptions with hyphenations, you must declare the hyphen-char too.
- <hyphen-min> contains two attributes:
- before: the minimum number of characters in a word allowed to exist on a line immediately preceding a hyphenated word-break.
- after: the minimum number of characters in a word allowed to exist on a line immediately after a hyphenated word-break.
- <classes> contains whitespace-separated character sets. The members of each set should be treated as equivalent for purposes of hyphenation, usually upper and lower case of the same character. The first character of the set is the canonical character, the patterns and exceptions should only contain these canonical representation characters (except digits for weight, the period (.) as word delimiter in the patterns and the hyphen char in exceptions, of course).
- <exceptions> contains whitespace-separated words, each of which has either explicit hyphen characters to denote acceptable breakage points, or no hyphen characters, to indicate that this word should never be hyphenated, or contain explicit <hyp> elements for specifying changes of spelling due to hyphenation (like backen -> bak-ken or Stoffarbe -> Stoff-farbe in the old german spelling). Exceptions override the patterns described below. Explicit <hyp> declarations don't work yet (patches welcome). Exceptions are generally a bit brittle, test carefully.
- <patterns> includes whitespace-separated patterns, which are what
drive most hyphenation decisions. The characters in these patterns are
explained as follows:
- non-numeric characters represent characters in a sub-word to be evaluated
- the period character (.) represents a word boundary, i.e. either the beginning or ending of a word
- numeric characters represent a scoring system for indicating the acceptability of a hyphen in this location. Odd numbers represent an acceptable location for a hyphen, with higher values overriding lower inhibiting values. Even numbers indicate an unacceptable location, with higher values overriding lower values indicating an acceptable position. A value of zero (inhibiting) is implied when there is no number present. Generally patterns are constructed so that valuse greater than 4 are rare. Due to a bug currently patterns with values of 8 and greater don't have an effect, so don't wonder.
- Knuth (The TeXBook, Appendix H) uses the example hach4, which indicates that it is extremely undesirable to place a hyphen after the substring "hach", for example in the word "toothach-es".
- .leg5e indicates that "leg-e", when it occurs at the beginning of a word, is a very good place to place a hyphen, if one is needed. Words like "leg-end" and "leg-er-de-main" fit this pattern.
If you want to convert a TeX hyphenation pattern file, you have to undo the TeX encoding for non-ASCII text. FOP uses Unicode, and the patterns must be proper Unicode too. You should be aware of the XML encoding issues, preferably use a good Unicode editor.
Note that FOP does not do Unicode character normalization. If you use combining chars for accents and other character decorations, you must declare character classes for them, and use the same sequence of base character and combining marks in the XSLFO source, otherwise the pattern wouldn't match. Fortunately, Unicode provides precomposed characters for all important cases in common languages, until now nobody run seriously into this issue. Some dead languages and dialects, especially ancient ones, may pose a real problem though.
If you want to generate your own patterns, an open-source utility called patgen can be used to assist in creating pattern files from dictionaries. It is available in many Unix/Linux distributions and every TeX distribution. Pattern creation for languages like english or german is an art. Read Frank Liang's original paper "Word Hy-phen-a-tion by Com-pu-ter" (yes, with hyphens) for details. The original patgen.web source, included in the TeX source distributions, contains valuable comments, unfortunately technical details often obscure the high level issues. Another important source of information is The TeX Book, appendix H (either read the TeX source, or run it through TeX to typeset it). Secondary articles, for example the works by Petr Sojka, may also give some much needed insight into problems arising in automated hyphenation.


--- layout: archive title: Zulip Chat Archive permalink: /stream/113488-general/topic/lean's.20type.20theory.html ---
Okay, I'm a bit embarrassed to release this in this very early form, but there's enough meat in it that it can be useful to others even before it's done. This will probably become a major part of my master's thesis. What you will find:
https://github.com/digama0/lean-type-theory/releases/download/v0.1/main.pdf
Oh many thanks for this -- as you saw, I made some sort of effort to engage with this kind of material without reading the source code (i.e. restricting to the docs) and it was tough. I am relieved to see that iota reduction applies to things defined by recursion rather than just cases!
I spent some time yesterday trying to get to the bottom of this accrec
example and it would have been a darn sight easier if I'd had access to this paper then.
I think it's great that we finally have a written description of the type theory implemented in Lean. Ideally it should also be included in the reference manual, and/or published somewhere.
section 2.3: I don't think it is a good idea to require full whnf in the algorithmic equivalence since we don't do it any of the implementations. We do lazy delta-reduction, that is, do full beta/iota/quotient/zeta and only unfold the constant with the larger definitional height, once. I think you should just replace ↓ by ⇝* here.
section 2.4: "Lean takes a simpler approach and simply zeta expands these binders when necessary for checking.": I don't think you've defined "Lean" anywhere. Not all of the implementations follow this approach. The C++ type_checker
, the Haskell tc
, and trepplein
all eagerly unfold lets. However, the type_context
doesn't. I believe the term ζ-reduction typically refers to x ⇝ e'.
There are a few white lies in algorithmic equivalence, and I'd be happy to give a more honest account but I'm not quite sure how. (One thing I have noticed is that sometimes pure congruence proofs don't check, because one side is eagerly iota reduced to something that is not recognizably equivalent anymore.)
section 2.6.2: "Here we have K-like elimination": do you mean large elimination? K-like reduction for acc would not be strongly normalizing, right?
I don't use the term "subsingleton elimination" anywhere in the paper, I may have mixed up my terms. I use K-like elimination to refer to large eliminating props
When I talk about "lean does X", I am usually referring to lean.exe's kernel. I didn't want to get into checking expressions with lets in the context, like type_context
does, which is why I omitted that approach.
but there is a second reduction rule used for K-like eliminators. It can be thought of as a combination of proof irrelevance to change the major
premise into a constructor followed by the iota rule.
Yes, you might want to clean up the definitions (and actually define them). ^^
which part?
Also: I just finished the proof of soundness. Celebrate! Lean can't prove false
K-like elimination refers to K-like reduction here, and subsingleton elimination on the page before, afaict.
That's not using algorithmic defeq, right?
Soundness for both algorithmic and ideal typechecking
I proved it for the ideal version, and the algorithmic check implies ideal check
algorithmic check implies ideal check
That's not proven yet, right?
It's pretty trivial
the algorithmic rules are a subset of the ideal ones
the ideal check is basically what lean would do if it was nondeterministic and tried all the tricks at once
Except that the ideal ones have extra side conditions that require the well-typedness of all terms that occur. The implication requires at the very least subject reduction for ⇝, which is not completely obvious to me.
Ok, I see subjection reduction is Lemma 3.10.
Note that ->_kappa is a bit different from ->, it has slightly different rules for iota stuff
I never explicitly stated subject reduction for -> (using the ideal check), but maybe I should be more precise about it
I think the general approach for the algorithmic defeq is good. It's better to have an over-approximation than to precisely model the actual (current implementation of the) type-checker. If you can show this defeq proof system to be sound, then all "reasonable" type-checkers should be correct.
section 2.3: you're also missing η-expansion, see https://github.com/leanprover/lean/blob/07bb7d809b6be49f38ce4e427c54a82708ae281f/src/kernel/type_checker.cpp#L517-L529
Would it suffice to replace the eta rule with extensionality "e x <-> e' x => e <-> e'"?
or is this only used when solving lam x:a. e <-> e'
Yes, you can then recover η via the conversion rule.
Yes, in practice it is only used when one side is a lambda.
I know some typecheckers prefer extensionality over eta, since it's pretty easy to figure out when to use it
but there is a second reduction rule used for K-like eliminators. It can be thought of as a combination of proof irrelevance to change the major
premise into a constructor followed by the iota rule.Yes, you might want to clean up the definitions (and actually define them). ^^
I don't follow. That passage looks alright, is something missing?
K-like elimination refers to multiple concepts in the paper: 1) subsingleton elimination, and 2) K-like reduction. For example, and
has 1) but not 2).
I use it essentially only for (1), (2) is more of a remark that comes up once as a sort of historical note "why K?"
You use it for 2) in section 2.6.4. Although it is not clear how you obtain the b
there.
I need a name for inductive types that eliminate to Type but live in Prop. "Large elimination" seems to also suggest when the type itself is large, so it's not a great name. Will subsingleton elimination cover exactly this usage?
the b is obtained from the LHS as described in the paragraph after
and it only applies if you can obtain all of b that way
I've only seen "subsingleton elimination" in this usage.
cool, I'll stop saying K-like then
Ah, next page, ok.
Huh, I've been telling myself that defeq is only undecidable in inconsistent contexts, but this is not true, almost trivially: if x : 0 |- A = B
is some undecidable defeq problem, then |- \lam x : 0. A = \lam x : 0. B
is also an undecidable defeq problem
I swear one day I'll have time to actually read this paper (or maybe a version with a bit higher word/symbol ratio). In the mean time I'm surprised by the source code. It' funny to see Lean consistently use unicode to be more readable than Coq but you still write \Gamma\vdash \alpha:\U_\ell\quad \Gamma\vdash e:\beta
in your LaTeX source like it's still 1990.
You even use $$
!
And a non-semantic use of \frac
Ok, I go back to work
Yeah LaTeX is pretty horrible. Nothing seems to measure up though. And people have tried a lot
Mario's LaTeX is horrible
Nothing keeps him in 1990
He could use xeLaTeX
(or LuaLaTeX
) and unicode-math
Maybe that and underwater basket weaving are the things he doesn't rock at. But seriously, what does 2018 LaTeX look like?
At least https://gitlab.com/PatrickMassot/h-principle/blob/master/src/hol_approx.tex
(some unicode is not used in this example because this source code is also meant for MathJax consumption)
I have not actually tried those. You actually enter your formulas with unicode and don't need spacing commands?
You still need spacing commands
but no \Gamma
That is pretty nice
I'm never sure if unicode is going to get mangled somewhere
I've been trying org-mode for my dissertation. Maybe I should add one of those too
I remember Floris sent in a tex file with lean snippets, and the journal typesetter complained about the unicode
Oh yes, you could have trouble with the journal
Today you still need to fight arXiv if you want to use 21th century LaTeX
can you use those tools as preprocessors?
That's the reason why you see more and more papers on arxiv where only the pdf is available and not the TeX source
No one has ever convincingly explained to me why $$
is worse than \[
(or something else?)
section 3.4: why do you consider η-reduction? I don't think any Lean typechecker has that.
$$ has spacing issues (beyond being harder to parsers)
https://tex.stackexchange.com/questions/503/why-is-preferable-to/69854 probably contains useful links
How else are you going to get eta reduction unless you put it in? Also: the constraints on the kappa reduction relation are very tight. I went through no less than 10 variations on it before I was able to get the church rosser theorem to go through
That's the reason why you see more and more papers on arxiv where only the pdf is available and not the TeX source
Do you mean that it is not used as a preprocessor and therefore people only submit pdfs?
Not at all? None of the typecheckers uses it, AFAIK. Trepplein definitely doesn't. We only do η for defeq.
I just got the feeling that η is a serious complication here, and the main reason you need a new and different reduction relation and defeq relation.
the whole point of the kappa reduction is so that the statement of Theorem 3.15 holds
The alternative would be to try to put eta or extensionality in the =p relation
I thought it is included in the ... in the definition of =p.
the ... only includes compatibility rules
I don't think it says that anywhere. (at least not above and below the definition)
It's a very spartan relation, it's just replacing proofs and nothing else (except for that lambda thing)
I will investigate whether it suffices to have one-sided extensionality e =p e' x => lam x:a. e =p e' and remove eta from the kappa reduction. If so that would allow me to remove the context from ->k, which would be nice
I think the biggest departure from the usual reduction relation is the K reduction (which I have renamed K+), because it is super aggressive unfolding of a proof, which guarantees nontermination when it sees an acc.rec
so is this paper about what Lean does, or what it should do in your opinion :-)
And do the devs have any comments about whether Lean 4 will do the same thing when it comes to definitional equality?
Not sure if I count as a dev anymore, but I seriously doubt there will be any foundational changes in Lean 4.
That's good to know -- I guess there were foundational changes from Lean 2 to Lean 3 so I suppose it wasn't something one could definitely assume...
There were exactly two foundational changes from Lean 2 to Lean 3: 1) let-expressions in the kernel (completely harmless), 2) mutually inductive types are no longer supported by the kernel (these are now simulated). Also the axioms for choice and quotients got some mostly cosmetic changes.
Oh I thought there was some change to the underlying type theory -- HoTT in Lean 2?
Oh yes, HoTT got removed from the kernel (you had to pass an extra command-line flag to use it, and there was a separate library). Completely forgot about that. But we now have a reasonably way to do it without kernel changes: https://github.com/gebner/hott3
so is this paper about what Lean does, or what it should do in your opinion :-)
The motivation is of course what lean does, but this is badly behaved in a number of ways which make it completely unsuitable for theoretical treatment, so I replace it with a better version, show soundness of the original version with respect to that, and then forget about the original thing
As Gabriel mentions, there are multiple "leans", and they don't all agree on the foundational stuff. This is in part what I wanted to address with this paper, to get down a single system that we can talk about as the ideal lean, and look at how close we can get to that. One thing which should be true, however, is that all existing lean kernels are underestimates of the typing judgment in this paper. That means that anything you can't prove with the ideal judgment can't be verified in these kernels either, which is the soundness result I want
AFAICT all existing kernels even fit within the algorithmic definitional equality check.
NB: I think the algorithmic definitional equality is not just an ugly approximation of the ideal one, but also important as a practical optimization: using the algorithmic definitional equality, we can elide almost all type-inference calls during type-checking.
Compare also the various variants of the typing rules proved equivalent in [1].
[1] A.Bauer, P. Haselwarter, T. Wintertaler, A modular formalization of type theory in Coq, TYPES (2017). http://math.andrej.com/2017/05/29/a-modular-formalization-of-type-theory-in-coq/
I'm also having difficulty with stating strong normalization because of my struggles here, I think. What is the reduction relation of interest here? Is it just head reduction? I think it is supposed to include reduction under binders, but then once we decide "arbitrarily" not to reduce some things that should be reducible, in what sense are we talking about the "right" relation? I.e. what does strong normalization have to do with consistency?
Weak head reduction is enough for consistency. But strong normalization for the full reduction relation is definitely interesting as well.
Since we've talked about η today, I think I've found a novel way to break transitivity with just K-like reduction for eq
:
def foo : 0 = 0 → ℕ := @eq.rec ℕ 0 (λ _, ℕ) 42 0 def bar : 0 = 0 → ℕ := @eq.rec ℕ 0 (λ n, if n = 0 then ℕ else empty) (42 : ℕ) 0 example : foo = (λ _, 42) := rfl example : bar = (λ _, 42) := rfl example : foo = bar := rfl -- fails
I found an interesting potential computational rule for quot.sound
:
variables (α : Sort*) (r : α → α → Prop) (a : α) (f : α → Sort*) (H : ∀ (a b : α), r a b → f a = f b) (e : f a) (b : α) (h : r a b) example : @eq.rec (quot r) (quot.mk r a) (quot.lift f H) e (quot.mk r b) (quot.sound h) = cast (H a b h) e := by change H a b h with (congr_arg (quot.lift f H) (quot.sound h):_); induction quot.sound h; refl
@Gabriel Ebner That was a big pain during the proof of church rosser. It's actually not a theoretical problem, but rather a side effect of K reductions without accounting for eta reduction
I fixed it by making sure that all recursors have the right number of arguments at all times
Alternatively, any K-like inductive should be eta expanded before normalization
The problem is that unapplied K recursors are stuck terms when they shouldn't be
variables (α : Sort*) (a : α) (C : α → Sort*) (e : C a) #reduce λ h, @eq.rec α a C e a h -- λ (h : a = a), e <- good #reduce @eq.rec α a C e a -- eq.rec e <- bad
I originally had the recursors evaluating to lambdas like this, but it was a notational nightmare since the number of unapplications depends on how many variables there are (the only one you have "control" over is the major premise, once that one is allowed to be a variable you have to deal with the parameters and such, and any of those could be variables or things equivalent to variables...), so I opted instead for an up-front eta expansion, since during reduction a recursor never loses its major premise
{% endraw %}Last updated: Apr 24 2020 at 19:02 UTC


Computes a 2-D convolution given 4-D input
and filter
tensors.
tf.compat.v1.nn.conv2d( input, filter=None, strides=None, padding=None, use_cudnn_on_gpu=True, data_format='NHWC', dilations=[1, 1, 1, 1], name=None, filters=None )
Given an input tensor of shape [batch, in_height, in_width, in_channels]
and a filter / kernel tensor of shape
[filter_height, filter_width, in_channels, out_channels]
, this op
performs the following:
[filter_height * filter_width * in_channels, output_channels]
.[batch, out_height, out_width,
filter_height * filter_width * in_channels]
.In detail, with the default NHWC format,
output[b, i, j, k] = sum_{di, dj, q} input[b, strides[1] * i + di, strides[2] * j + dj, q] * filter[di, dj, q, k]
Must have strides[0] = strides[3] = 1
. For the most common case of the same
horizontal and vertices strides, strides = [1, stride, stride, 1]
.
input
: A Tensor
. Must be one of the following types:
half
, bfloat16
, float32
, float64
.
A 4-D tensor. The dimension order is interpreted according to the value
of data_format
, see below for details.filter
: A Tensor
. Must have the same type as input
.
A 4-D tensor of shape
[filter_height, filter_width, in_channels, out_channels]
strides
: An int or list of ints
that has length 1
, 2
or 4
. The
stride of the sliding window for each dimension of input
. If a single
value is given it is replicated in the H
and W
dimension. By default
the N
and C
dimensions are set to 1. The dimension order is determined
by the value of data_format
, see below for details.padding
: Either the string
"SAME"
or "VALID"
indicating the type of
padding algorithm to use, or a list indicating the explicit paddings at
the start and end of each dimension. When explicit padding is used and
data_format is "NHWC"
, this should be in the form [[0, 0], [pad_top,
pad_bottom], [pad_left, pad_right], [0, 0]]
. When explicit padding used
and data_format is "NCHW"
, this should be in the form [[0, 0], [0, 0],
[pad_top, pad_bottom], [pad_left, pad_right]]
.use_cudnn_on_gpu
: An optional bool
. Defaults to True
.data_format
: An optional string
from: "NHWC", "NCHW"
.
Defaults to "NHWC"
.
Specify the data format of the input and output data. With the
default format "NHWC", the data is stored in the order of:
[batch, height, width, channels].
Alternatively, the format could be "NCHW", the data storage order of:
[batch, channels, height, width].dilations
: An int or list of ints
that has length 1
, 2
or 4
,
defaults to 1. The dilation factor for each dimension ofinput
. If a
single value is given it is replicated in the H
and W
dimension. By
default the N
and C
dimensions are set to 1. If set to k > 1, there
will be k-1 skipped cells between each filter element on that dimension.
The dimension order is determined by the value of data_format
, see above
for details. Dilations in the batch and depth dimensions if a 4-d tensor
must be 1.name
: A name for the operation (optional).filters
: Alias for filter.A Tensor
. Has the same type as input
.


This page provides a demo of a javascript implementation of a spectral graph layout algorithm based on those described Drawing graphs by eigenvectors: Theory and practice by Yehuda Koren, (2005).
The idea behind this layout algorithm is to closely group nodes which have a higher degree of interconnectedness, while spreading un-connected nodes further apart. This is achieved using an algorithm similar to spectral clustering, which I implemented using a power iteration method to perform the eigen decomposition.
The example of this provided below shows how a connection matrix can be converted into a set of coordinates for plotting, and also highlights the limitation of this technique.
ConnectednessThe matrix to the right shows the connectedness of the nodes. Each row represents a single node, with the column values representing what it is connected to. A non-zero number indicates a connection. |
|
CoordinatesThis matrix shows the first two principal components identified by the spectral layout algorithm. These are used as coordinates. You may notice that the coordinates for nodes 5 and 9 are almost the same; this is because they have the same connectedness pattern. This is the key weakness of the algorithm. |
|
GraphThe graph to the right shows the nodes plotted as per their identified coordinates. Nodes 5 and 9 are overlapping. It may be possible to use a fudge factor to avoid this, however a post processing step which would ensure a minimum separation between nodes could be applied and may be preferable. |
Created by Alan Meeson, 2014-2015


next time we are going to do a navigation menu with divs
and after that a top menu and a background image


@(auditDef: lib.AuditDef, orgSnapshot: lib.OrgSnapshot)(implicit req: Request[AnyContent]) @import lib.Implicits._ @main {
The audit found @orgSnapshot.usersWithProblemsCount users in @auditDef.org.displayName's organisation that don't meet requirements - this is such a large proportion of your organisation that no action will be taken by gu:who - it's possible the GitHub API is currently broken.
There are currently @orgSnapshot.usersWithProblemsCount users in @auditDef.org.displayName's organisation that don't meet requirements.
You can re-run this process, and update the associated issues, by calling our endpoint directly:
curl -X POST -H "Csrf-Token: nocheck" -H "Authorization: token {{ YOUR_GITHUB_API_KEY }}" http://<EMAIL_ADDRESS>...or use this POST endpoint for a GitHub organisation webhook (set to fire on 'Membership' events):
http://@req.host/audit/@auditDef.org.getLogin?access_token={{ YOUR_GITHUB_API_KEY }}
Your GitHub API
key needs to have the scopes repo
and write:org
.


Project goal is to drive enterprise adoption of Microsoft Office 365 Suite, and OneDrive. My team and I developed a short compilation video of O365 commentary. Also, piloting in Morristown I worked with Valerie Palermo, Rob Jukic, Nick Mitricka, Sharon Young, Kunal Patel, and Serena Badro to create ‘Hackathon’ style events where interested parties may come and enjoy pizza, and learn about an interesting and relevant topic (O365 Adoption as of 08/03).
BenefitsAdoption solutions will provide greater corporate utilization and integration. The Hackathons & Awareness video helps maximize ROI for the enterprise on the Microsoft Office suite. Also, the suite will provide numerous technological benefits, such as: Online secure file storage, and upgraded versions of the Microsoft suite.
Microsoft Online allows for collaboration on OneNote, OneDrive, and the entire Office 365 suite.
OneDrive users may use the service to store an unlimited amount of their data on secure online servers. OneDrive provides reliable storage with no additional hardware to manage.
Online & Sync functionality allow for users to work from any device, anywhere, anytime.


How ForwardDiff Works¶
ForwardDiff is an implementation of forward mode automatic differentiation (AD) in
Julia. There are two key components of this implementation: the Dual
type, and the API.
Dual Number Implementation¶
Partial derivatives are stored in the Partials{N,T}
type:
immutable Partials{N,T}
values::NTuple{N,T}
end
Overtop of this container type, ForwardDiff implements the Dual{N,T}
type:
immutable Dual{N,T<:Real} <: Real
value::T
partials::Partials{N,T}
end
This type represents an N
-dimensional dual number with the following mathematical
behavior:
where the \(a\) component is stored in the value
field and the \(b\)
components are stored in the partials
field. This property of dual numbers is the
central feature that allows ForwardDiff to take derivatives.
In order to implement the above property, elementary numerical functions on a Dual
number are overloaded to evaluate both the original function, and evaluate the derivative
of the function, propogating the derivative via multiplication. For example, Base.sin
can be overloaded on Dual
like so:
Base.sin(d::Dual) = Dual(sin(value(d)), cos(value(d)) * partials(d))
If we assume that a general function f
is composed of entirely of these elementary
functions, then the chain rule enables our derivatives to compose as well. Thus, by
overloading a plethora of elementary functions, we can differentiate generic functions
composed of them by passing in a Dual
number and looking at the output.
We won’t dicuss higher-order differentiation in detail, but the reader is encouraged to
learn about hyper-dual numbers, which extend dual numbers to higher orders by introducing
extra \(\epsilon\) terms that can cross-multiply. ForwardDiff’s Dual
number
implementation naturally supports hyper-dual numbers without additional code by allowing
instances of the Dual
type to nest within each other. For example, a second-order
hyper-dual number has the type Dual{N,Dual{N,T}}
, a third-order hyper-dual number has
the type Dual{N,Dual{N,Dual{N,T}}}
, and so on.
ForwardDiff’s API¶
The second component provided by this package is the API, which abstracts away the number
types and makes it easy to execute familiar calculations like gradients and Hessians. This
way, users don’t have to understand Dual
numbers in order to make use of the package.
The job of the API functions is to performantly seed input values with Dual
numbers,
pass the seeded value into the target function, and extract the derivative information from
the result. For example, to calculate the partial derivatives for the gradient of a function
\(f\) at an input vector \(\vec{x}\), we would do the following:
In reality, ForwardDiff does this calculation in chunks of the input vector. To provide a simple example of this, let’s examine the case where the input vector size is 4 and the chunk size is 2. It then takes two calls to \(f\) to evaluate the gradient:
This seeding process is similar for Jacobians, so we won’t rehash it here.


Welcome!
You seem to have stumbled upon my website.
 This website hasn't seen a lot of activity lately, but I am still searching for projects that are intriguing and rewarding. To get an idea of what this website is about, see the apps page, which contains lots of interesting web projects I worked on when I was in high school.
I'm hoping to be involved in more large-scale work, so I set up the projects page for when that does happen. Right now, it contains a multi-user quiz app that I created for my friends to use.
Python has always been a special interest of mine - check out my GitHub page to see my Python work, which includes a command-line TV guide, a pseudo-code interpreter and a very special program for translating GIFs into XLS files.


Defined in generated file: python/ops/gen_linalg_ops.py
Solves systems of linear equations with upper or lower triangular matrices by backsubstitution.
tf.compat.v1.linalg.triangular_solve
tf.compat.v1.matrix_triangular_solve
tf.compat.v2.linalg.triangular_solve
tf.linalg.triangular_solve( matrix, rhs, lower=True, adjoint=False, name=None )
matrix
is a tensor of shape [..., M, M]
whose inner-most 2 dimensions form
square matrices. If lower
is True
then the strictly upper triangular part
of each inner-most matrix is assumed to be zero and not accessed.
If lower
is False then the strictly lower triangular part of each inner-most
matrix is assumed to be zero and not accessed.
rhs
is a tensor of shape [..., M, K]
.
The output is a tensor of shape [..., M, K]
. If adjoint
is
True
then the innermost matrices in output
satisfy matrix equations
matrix[..., :, :] * output[..., :, :] = rhs[..., :, :]
.
If adjoint
is False
then the strictly then the innermost matrices in
output
satisfy matrix equations
adjoint(matrix[..., i, k]) * output[..., k, j] = rhs[..., i, j]
.
a = tf.constant([[3, 0, 0, 0], [2, 1, 0, 0], [1, 0, 1, 0], [1, 1, 1, 1]], dtype=tf.float32) b = tf.constant([[4], [2], [4], [2]], dtype=tf.float32) x = tf.linalg.triangular_solve(a, b, lower=True) x # <tf.Tensor: id=257, shape=(4, 1), dtype=float32, numpy= # array([[ 1.3333334 ], # [-0.66666675], # [ 2.6666665 ], # [-1.3333331 ]], dtype=float32)> # in python3 one can use `a@x` tf.matmul(a, x) # <tf.Tensor: id=263, shape=(4, 1), dtype=float32, numpy= # array([[4. ], # [2. ], # [4. ], # [1.9999999]], dtype=float32)>
matrix
: A Tensor
. Must be one of the following types: float64
, float32
, half
, complex64
, complex128
.
Shape is [..., M, M]
.rhs
: A Tensor
. Must have the same type as matrix
.
Shape is [..., M, K]
.lower
: An optional bool
. Defaults to True
.
Boolean indicating whether the innermost matrices in matrix
are
lower or upper triangular.adjoint
: An optional bool
. Defaults to False
.
Boolean indicating whether to solve with matrix
or its (block-wise)
adjoint.
name
: A name for the operation (optional).
A Tensor
. Has the same type as matrix
.
Equivalent to scipy.linalg.solve_triangular


Name of Event:
Date:
Time:
Speaker:
Title of Event:
Description:
Speaker Bio:
Sponsored by the English Department?
Yes
No:
To whom should this be circulated?
Faculty
Graduate Students
Everyone
Submit


Reports
Scrollable
components, except for
JTextField
, that are not placed in
JScrollPane
. The quick-fix surrounds the problematic component with a scroll pane.


PATCH ADAMS ****1/2 (out of five stars) A review by Jamey Hughton
Starring-Robin Williams, Monica Potter, Phillip Seymour Hoffman and Bob Gunton Director-Tom Shadyac Rated-PG
More MOVIE VIEWS by Jamey Hughton: http://welcome.to/movieviews
To think that the two people behind the Ace Ventura movies would combine to make a movie like this. It is true, Tom Shadyac (director of Ace Ventura) is behind the camera, and Steve Oederkerk (director of Ace Ventura: When Nature Calls) has written the screenplay in one of the year's most touching films.
Robin Williams brings all his hilarious baggage and his dramatic side with him playing the title character, Patch Adams, a med student who believes that laughter is the best medicine to help his patients. Discovering his talent to help people while admitted to a mental institution, Patch sets his goal of becoming a doctor. Toting a fake white overcoat to disguise himself (actually, it's a meat packing jacket), Patch weaves in and out of hospital rooms making people laugh. If at least a smile doesn't form across your face while watching Williams make hospitalized children laugh, then you must be closely related to the Grinch.
I'm not at all surprised to say this is an excellent movie. At the same time, it is a long distance from being a perfect movie.  Despite the obviously serious premise of Williams helping those in need, there is still plenty to laugh about here. One scene, in particular, will have to go on the record shelves for one of the funniest moments in movie history. And yet, the filmmakers never stray too far and fail to make the point that they're attempting.
Robin Williams is again wonderful - heck give the man another Academy Award. He's the heart and soul of Patch Adams, balancing the movie on his shoulders like a scale about to tip at any moment. Amazingly, he never lets it drop, or even budge, for that matter. He gets and excellent supporting turn from Philip Seymour Hoffman, playing another doctor who at times questions Patch's methods of viewing death, as something humorous. Monica Potter is also memorable as his self-conscious love interest, who's studying medicine herself.
There's lots of emotions to feel in this movie. Whether they are good or bad, the entire project is so heartwarming you may have the urge to hug the people sitting next to you. Patch Adams is a movie each and every human being should see.
More MOVIE VIEWS by Jamey Hughton http://welcome.to/movieviews
Jamey Hughton was a 1999 Writing Finalist in the YTV Achievement Awards and writes a Published Column in The StarPhoenix (Saskatoon Sk. Canada).
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Hong Kong police detain people | Trump worse than Nixon - Pelosi: WATCH the top world news videos for today
Hong Kong riot police detain people near campus protest siege
Riot police detain people as tensions remain high the morning after intense weekend clashes near Hong Kong's Polytechnic University.
Pelosi says Trump's actions 'so much worse' than Richard Nixon
US House Speaker Nancy Pelosi is amplifying her unfavorable comparison of President Donald Trump to fellow Republican Richard Nixon, saying that disgraced president at least cared enough about the country to leave office before his impeachment.
Brazil's ex-president Lula holds rally after being released from jail
Brazil's left-wing leader Luiz Inacio Lula da Silva holds rally in Recife, after being released from jail a week ago.
US, South Korea postpone military drills in bid to bolster North Korea peace effort
The United States and South Korea announced on Sunday they would postpone upcoming military drills in an effort to bolster a stalled peace push with North Korea, even as Washington denied the move amounted to another concession to Pyongyang.
Folau blames bushfires on marriage equality
Sacked Wallabies star Israel Folau claims the bushfires that have devastated the nation and left six Australians dead are God's punishment for legalising abortion and same-sex marriage.


IBM Cloud Push Notifications Cordova SDK
The IBM Cloud Push Notifications service provides a unified push service to send real-time notifications to mobile and web applications. The Push Notifications Cordova Plugin Push SDK enables Cordova apps to receive notifications sent from the service.
Ensure that you go through IBM Cloud Push Notifications service documentation before you start.
Contents
- Prerequisites
- Installation
- Initialize SDK
- Register for notifications
- Push Notification service tags
- Notification Options
- Methods usage
- Samples and Videos
Prerequisites
- Android Studio
- Xcode
- Cordova CLI)
- Node.js/npm)
Installation
You need to create a Cordova project and add platforms before adding the IBM Cloud Push Notifications Cordova Plugin Push SDK. Complete the following steps:
-
Create a Cordova application:
- Run the following commands to create a new Cordova application. Alternatively, you can use an existing application as well.
cordova create {your_app_name} cd {your_app_name}
- Edit
config.xml
file and set the desired application name in the<name>
element instead of a defaultHelloCordova
. - In the
config.xml
file, update the<platform name="ios">
element with a deployment target declaration. See the code snippet.<platform name="ios"> <preference name="deployment-target" value="8.0" /> <!-- add deployment target declaration --> </platform>
- In the
config.xml
file update the<platform name="android">
element with a minimum and target SDK versions as shown in the code snippet below.
<platform name="android"> <preference name="android-minSdkVersion" value="15" /> <preference name="android-targetSdkVersion" value="26" /> <!-- add minimum and target Android API level declaration --> </platform> ``` >**Note**: The minSdkVersion should be above 15 and the targetSdkVersion should always reflect the latest Android SDK available from Google.
- Run the following commands to create a new Cordova application. Alternatively, you can use an existing application as well.
-
Add the Cordova platforms. Run either of the following commands, based on your platform:
- For iOS:
cordova platform add ios
- For Android:
cordova platform add android
Ensure that you use the iOS version specified through this command for the Cordova platform. It is required to build the Cordova app.
- For iOS:
-
Add the Cordova IBM Cloud Push plugin. From your Cordova application root directory, enter the following command to install the Cordova Push plugin.
cordova plugin add bms-push
This also installs the
Cordova Core plug-in
, which initializes your connection to IBM Cloud. -
From your app root folder, verify that the Cordova
Core plugin
andPush plugin
were installed successfully, using the command:cordova plugin list
Note: Existing vendor-acquired Push Notification plugins (e.g., phonegap) may interfere with bms-push. Remove these plugins to ensure proper functionality.
Initialize SDK
Choose either of the following steps, based on your platform:
-
For iOS:
- In the Capabilities, enable
push notifications
andBackground modes
. UnderBackground modes
enable theRemote notification
andbackground fetch
. - Add signing certificates
- In the Capabilities, enable
-
For Android App
- Download your Firebase google-services.json for android, and place them in the root folder of your cordova project -
[your-app-name]/platforms/android
.
- Download your Firebase google-services.json for android, and place them in the root folder of your cordova project -
For Android Studion 3.+
users, update the build.gradle file with the folowing -
Change the,
debugCompile project(path: 'CordovaLib', configuration: 'debug')
releaseCompile project(path: 'CordovaLib', configuration: 'release')
to
compile project(':CordovaLib')
Initialize the core plugin
Initialize the bms-core
plugin. Run the following snippet:
onDeviceReady: function() {
app.receivedEvent('deviceready');
BMSClient.initialize("YOUR APP REGION");
}
For the region, pass any of the following:
REGION_US_SOUTH
// ".ng.bluemix.net";REGION_UK
//".eu-gb.bluemix.net";REGION_SYDNEY
// ".au-syd.bluemix.net";REGION_GERMANY
// ".eu-de.bluemix.net"REGION_TOKYO
// ".jp-tok.bluemix.net"REGION_US_EAST
// ".us-east.bluemix.net"
For example:
BMSClient.initialize(BMSClient.REGION_US_SOUTH);
Initialize the Push plugin
Initialize the BMSPush
. Run the following snippet:
-
Initialize without options
// Initialize for normal push notifications var options = {}; BMSPush.initialize(appGUID,clientSecret,options);
-
Initialize with options
// Initialize for iOS actionable push notifications, custom deviceId and varibales for Parameterize Push Notifications var options = {"categories":{ "Category_Name1":[ { "IdentifierName":"IdentifierName_1", "actionName":"actionName_1", "IconName":"IconName_1" }, { "IdentifierName":"IdentifierName_2", "actionName":"actionName_2", "IconName":"IconName_2" } ]}, "deviceId":"mydeviceId", "variables":{"username":"UserName","accountNumber":"536475869765475869"} }; BMSPush.initialize(appGUID, clientSecret, options);
Where appGUID
is the Push service instance Id value, clientSecretis the Push service instance client secret value and
options`can be notification options such as interactive notifiaction and custom deviceId.
Register for notifications
Use the BMSPush.registerDevice()
API to register the device with Push Notifications service.
The following options are supported:
-
Register without UserId
To register without userId, use the following pattern:
var success = function(response) { console.log("Success: " + response); }; var failure = function(response) { console.log("Error: " + response); }; var options = {}; BMSPush.registerDevice(options, success, failure);
-
Register with UserId
The
userId
can be specified while registering the device with Push Notifications service. The register method will accept one more parameter -userId
var success = function(response) { console.log("Success: " + response); }; var failure = function(response) { console.log("Error: " + response); }; var options = {"userId": "Your User Id value"}; BMSPush.registerDevice(options, success, failure);
Where UserId is the user identifier value you want to register the device in the push service instance.
Note: If userId is provided, the client secret value must be provided.
-
Unregister from notifications
Use the following code snippet to unregister the device from push notification service instance:
var success = function(response) { console.log("Success: " + response); }; var failure = function(response) { console.log("Error: " + response); }; BMSPush.unregisterDevice(options, success, failure);
-
Unregister the device from UserId
To unregister from the
UserId
based registration you have to call the registration method - without userId.
Receiving notifications
To receive push notification call back, add the following code snippet:
var handleNotificationCallback = function(notification) {
// notification is a JSON object
alert(notification.message);
}
BMSPush.registerNotificationsCallback(handleNotificationCallback);
Push Notification service tags
Retrieve available tags
The retrieveAvailableTags()
API returns the list of tags to which the device
can subscribe. After the device is subscribes to a particular tag, the device can receive notifications that are sent for that tag.
Add the following code snippets to your Swift mobile application to get a list of tags to which the device can subscribe:
var failure = function(response) { console.log("Error: " + response); };
BMSPush.retrieveAvailableTags(function(tags) {
alert(tags);
}, failure);
Subscribe to tags
The subscribe()
API will subscribe the iOS device for the list of given tags. After the device is subscribed to a particular tag, the device can receive push notifications that are sent for that tag.
Add the following code snippets to your Swift mobile application to subscribe to a list of tags:
var success = function(response) { console.log("Success: " + response); };
var failure = function(response) { console.log("Error: " + response); };
var tag = "YourTag";
BMSPush.subscribe(tag, success, failure);
Retrieve subscribed tags
The retrieveSubscriptions()
API will return the list of tags to which the device is subscribed.
Add the following code snippets to your Swift mobile application to get the subscription list:
var failure = function(response) { console.log("Error: " + response); };
BMSPush.retrieveSubscriptions(function(tags) {
alert(tags);
}, failure);
Unsubscribing from tags
The unsubscribe()
API will remove the device subscription from the list tags.
Use the following code snippets to unsubsribe from tags:
var success = function(response) { console.log("Success: " + response); };
var failure = function(response) { console.log("Error: " + response); };
var tag = "YourTag";
BMSPush.unsubscribe(tag, success, failure);
Notification options
The following notification options are supported.
Interactive notifications
To enable interactive push notifications, the notification action parameters must be passed in as part of the notification object. For example:
var options ={"categories":{
"Category_Name1":[
{
"IdentifierName":"IdentifierName_1",
"actionName":"actionName_1",
"IconName":"IconName_1"
},
{
"IdentifierName":"IdentifierName_2",
"actionName":"actionName_2",
"IconName":"IconName_2"
}
]};
BMSPush.initialize(appGUID, clientSecret, options);
Handling interactive notifications click
To identify which action clicked use the following,
var showNotification = function(notif) {
var identifierName = notif["identifierName"];
alert(identifierName);
};
Adding custom DeviceId for registration
To send DeviceId
, use the options
parameter in initialize method
of BMSPush
class. For example:
var options = {
"devieID":"mydeviceId"
};
BMSPush.initialize(appGUID, clientSecret, options);
Usage
The following BMSPush Javascript functions are available:
| Javascript Function | Description |
|---|---|
| initialize(pushAppGUID, clientSecret,category) | Initialize the Push SDK. |
| registerDevice(options, success, failure) | Registers the device with the Push Notifications Service. |
| unregisterDevice(success, failure) | Unregisters the device from the Push Notifications Service |
| retrieveSubscriptions(success, failure) | Retrieves the tags device is currently subscribed to |
| retrieveAvailableTags(success, failure) | Retrieves all the tags available in a push notification service instance. |
| subscribe(tag, success, failure) | Subscribes to a particular tag. |
| unsubscribe(tag, success, failure) | Unsubscribes from a particular tag. |
| registerNotificationsCallback(callback) | Registers a callback for when a notification arrives on the device. |
Android (Native) The following native Android function is available.
| Android function | Description |
|---|---|
| CDVBMSPush. setIgnoreIncomingNotifications(boolean ignore) | By default, push notifications plugin handles all incoming Push Notification by tunnelling them to JavaScript callback. Use this method to override the plugin's default behavior in case you want to manually handle incoming push notifications in native code. |
Samples and Videos
-
For samples, visit - Github Sample
-
For video tutorials, visit - IBM Cloud Push Notifications
=======================
Copyright 2020-21 IBM Corp.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


DependencyManager Class
Class manager for one or more requests
Constructor
DependencyManager
()
Example:
// create and object setting the class
var objDependencyManager = new yOSON.DependencyManager();
// example of setting the static host
objdependencymanager.setStaticHost("http://static.host/");
// example of setting the static host
objdependencymanager.setVersionUrl("?v=0.1");
// request the url
objDependency.ready(['url1'], function(){
// execute here when ready
});
Item Index
Methods
addScript
-
url
Receives a url from the manager
Parameters:
-
url
Stringthe url self to request in the manager
alreadyInCollection
-
id
Queries if its appended in the collection of the manager
Parameters:
-
id
Stringthe id generated by the url
Returns:
the object Dependency created by the url
alreadyLoaded
-
id
Queries if the dependency is loaded in the manager
Parameters:
-
id
Stringthe id generated by the url
Returns:
the object Dependency created by the url
generateId
-
url
Generates the id for the manager from the url
Parameters:
-
url
Stringthe url self to generate your id
getDependency
-
url
Returns saved dependency in the manager
Parameters:
-
url
Stringthe url to get in the manager
Returns:
the object Dependency created by the url
getStaticHost
()
String
Gets saved host
Returns:
Get the saved host with the method setStaticHost
Example:
//returns "http://cdnjs.com" if set
objDependencyManager.getStaticHost();
getVersionUrl
()
String
Get saved suffix
Returns:
Get saved suffix with the setVersionUrl method
Example:
//if setting "?v=0.1" return that
objDependencyManager.getVersionUrl();
ready
-
urlList
-
onReady
method that receives a list of urls to be requested and callbacks when the requests are ready
Parameters:
-
urlList
ArrayList of urls to request
-
onReady
FunctionCallback to execute when the all requests are ready
SanitizeDoubleslashes
-
url
Sanitize double slashes in url
Parameters:
-
url
Stringthe url self to sanitize
Returns:
the url cleaned
setStaticHost
-
hostName
Sets the host of static elements
Parameters:
-
hostName
Stringthe host of the static elements, like a CDN url
Example:
objDependencyManager.setStaticHost("http://cdnjs.com");
setVersionUrl
-
versionNumber
Sets the suffix for the url, ideally when working with versioned elements
Parameters:
-
versionNumber
Stringthe suffix or number for concatenating in the url
Example:
objDependencyManager.setVersionUrl("?v=0.1");
transformUrl
-
url
Transforms the url to a request
Parameters:
-
url
Stringthe url itself to be transformed and ready for request
Returns:
the url transformed


|
|
float32_t | down |
| |
|
float32_t | front |
| |
|
float32_t | right |
| |
|
float32_t | back |
| |
|
float32_t | left |
| |
|
float32_t | up |
| |
|
uint8_t | downHealth: 1 |
| |
|
uint8_t | frontHealth: 1 |
| |
|
uint8_t | rightHealth: 1 |
| |
|
uint8_t | backHealth: 1 |
| |
|
uint8_t | leftHealth: 1 |
| |
|
uint8_t | upHealth: 1 |
| |
|
uint8_t | reserved: 2 |
| |
The documentation for this struct was generated from the following file:


This web portfolio includes examples of my work in Web Design Class.
About Me
This section will be completed soon.
My Portfolio
This section will be completed soon.
My Resources
This section will be completed soon.
Coding
This section will be completed soon.
My other stuff
This section will be completed soon.


Take your first step into the world of DSLR photography with the new Nikon D3400 with SnapBridge - the latest feature that automatically connects your pictures with the world. The D3400 captures every memory in stunning detail with ISO 100-25600, 24.2 megapixels, an 11-point autofocus system and features the ability to shoot Full HD 1080/60p videos.


Configure > Using Mruby
mruby is a lightweight implementation of the Ruby programming language. With H2O, users can implement their own request handling logic using mruby, either to generate responses or to fix-up the request / response.
Rack-based Programming Interface
The interface between the mruby program and the H2O server is based on Rack interface specification. Below is a simple configuration that returns hello world.
paths:
"/":
mruby.handler: |
Proc.new do |env|
[200, {'content-type' => 'text/plain'}, ["Hello world\n"]]
end
It should be noted that as of H2O version 1.7.0, there are limitations when compared to ordinary web application server with support for Rack such as Unicorn:
- no libraries provided as part of Rack is available (only the interface is compatible)
In addition to the Rack interface specification, H2O recognizes status code 399
which can be used to delegate request to the next handler.
The feature can be used to implement access control and response header modifiers.
Access Control
By using the 399
status code, it is possible to implement access control using mruby.
The example below restricts access to requests from 192.168.
private address.
paths:
"/":
mruby.handler: |
lambda do |env|
if /\A192\.168\./.match(env["REMOTE_ADDR"])
return [399, {}, []]
end
[403, {'content-type' => 'text/plain'}, ["access forbidden\n"]]
end
Support for Basic Authentication is also provided by an mruby script.
Delegating the Request
When enabled using the reproxy
directive, it is possible to delegate the request from the mruby handler to any other handler.
paths:
"/":
mruby.handler: |
lambda do |env|
if /\/user\/([^\/]+)/.match(env["PATH_INFO"])
return [307, {"x-reproxy-url" => "/user.php?user=#{$1}"}, []]
end
return [399, {}, []]
end
Modifying the Response
When the mruby handler returns status code 399
, H2O delegates the request to the next handler while preserving the headers emitted by the handler.
The feature can be used to add extra headers to the response.
For example, the following example sets cache-control
header for requests against .css
and .js
files.
paths:
"/":
mruby.handler: |
Proc.new do |env|
headers = {}
if /\.(css|js)\z/.match(env["PATH_INFO"])
headers["cache-control"] = "max-age=86400"
end
[399, headers, []]
end
file.dir: /path/to/doc-root
Or in the example below, the handler triggers HTTP/2 server push with the use of Link: rel=preload
headers, and then requests a FastCGI application to process the request.
paths:
"/":
mruby.handler: |
Proc.new do |env|
push_paths = []
# push css and js when request is to dir root or HTML
if /(\/|\.html)\z/.match(env["PATH_INFO"])
push_paths << ["/css/style.css", "style"]
push_paths << ["/js/app.js", "script"]
end
[399, push_paths.empty? ? {} : {"link" => push_paths.map{|p| "<#{p[0]}>; rel=preload; as=#{p[1]}"}.join("\n")}, []]
end
fastcgi.connect: ...
Using the HTTP Client
Starting from version 1.7, a HTTP client API is provided. HTTP requests issued through the API will be handled asynchronously; the client does not block the event loop of the HTTP server.
paths:
"/":
mruby.handler: |
Proc.new do |env|
req = http_request("http://example.com")
status, headers, body = req.join
[status, headers, body]
end
http_request
is the method that issues a HTTP request.
The method takes two arguments.
First argument is the target URI.
Second argument is an optional hash; method
(defaults to GET
), header
, body
attributes are recognized.
The method returns a promise object.
When #join
method of the promise is invoked, a three-argument array containing the status code, response headers, and the body is returned.
The response body is also a promise.
Applications can choose from three ways when dealing with the body: a) call #each
method to receive the contents, b) call #join
to retrieve the body as a string, c) return the object as the response body of the mruby handler.
The header and the body object passed to http_request
should conform to the requirements laid out by the Rack specification for request header and request body.
The response header and the response body object returned by the #join
method of the promise returned by http_request
conforms to the requirements of the Rack specification.
Since the API provides an asynchronous HTTP client, it is possible to effectively issue multiple HTTP requests concurrently and merge them into a single response.
When HTTPS is used, servers are verified using the properties of proxy.ssl.cafile
and proxy.ssl.verify-peer
specified at the global level.
Timeouts defined for the proxy handler (proxy.timeout.*
) are applied to the requests that are issued by the http_request
method.
Logging Arbitrary Variable
In version 2.3, it is possible from mruby to set and log an arbitrary-named variable that is associated to a HTTP request.
A HTTP response header that starts with x-fallthru-set-
is handled specially by the H2O server. Instead of sending the header downstream, the server accepts the value as a request environment variable, taking the suffix of the header name as the name of the variable.
This example shows how to read request data, parse json and then log data from mruby.
paths:
"/":
mruby.handler: |
Proc.new do |env|
input = env["rack.input"] ? env["rack.input"].read : '{"default": "true"}'
parsed_json = JSON.parse(input)
parsed_json["time"] = Time.now.to_i
logdata = parsed_json.to_s
[204, {"x-fallthru-set-POSTDATA" => logdata}, []]
end
access-log:
path: /path/to/access-log.json
escape: json
format: '{"POST": %{POSTDATA}e}'


Auto-Update-Year v1.0.1
This is just a test:
Full Year:
Full Year with Copyright:
Short Year:
Short Year with Copyright:
Full Year with Copyright and space:
Short Year with Copyright and space:


You are submitting a new proposal for {{ speaker.name }}. Please begin by selecting the type of proposal below:
{% else %}To submit content for {{ camp.title }} please begin by selecting the type of event below:
{% endif %}{{ event_type.description }}
{% endif %} {% endfor %}If you have questions or experience problems submitting proposals here please let us know on IRC or by mail. You can also send an email with your proposal and the Content team will take care of creating it in the system.


The Interpolate Points tool allows you to predict values at new locations based on measurements from a collection of points. The tool takes point data with values at each point and returns a raster of predicted values. For example
The point layer that contains the points where the values have been measured.
Choose the field whose values you wish to interpolate.
Choose your preference for speed versus accuracy. More accurate predictions take longer to calculate. This parameter alters the default values of several other parameters of Interpolate Points in order to optimize speed of calculation, accuracy of results, or a balance of the two.
Choose whether to transform your data to the normal distribution. Interpolation is most accurate for data that follow a normal (bell-shaped) distribution. If you data does not appear to be normally distributed, you should perform a transformation.
Interpolate Points works by building local interpolation models that are mixed together to create the final prediction map. This parameter controls how many points will be contained in each local model. Smaller values will make results more local and can reveal small-scale effects, but it may introduce some instability in the calculations. Larger values will be more stable, but some local effects may be missed.
Predictions are calculated based on neighboring points. This parameter controls how many points will be used in the calculation. Using a larger number of neighbors will generally produce more accurate results, but the results take longer to calculate.
Enter the cell size and unit for the output rasters.
Choose whether you want to create a raster of standard errors for the predicted values.
Standard errors are useful because they provide information about the reliability of the predicted values. A simple rule of thumb is that the true value will fall within two standard errors of the predicted value 95 percent of the time. For example, suppose a new location gets a predicted value of 50 with a standard error of 5. This means that this tool's best guess is that the true value at that location is 50, but it reasonably could be as low as 40 or as high as 60. To calculate this range of reasonable values, multiply the standard error by 2, add this value to the predicted value to get the upper end of the range, and subtract it from the predicted value to get the lower end of the range.
 These diagnostics are useful for determining the accuracy of the predicted values. If created, the table will contain five diagnostics:
This is the name of the layer that will be created in My Content and added to the map. The default name is based on the tool name and the input layer name. If the layer already exists, you will be asked to provide another name.
Using the Save result in drop-down box, you can specify the name of a folder in My Content where the result will be saved.


I’ve had my MacBook Air for some three months now.
There are many things I love about it: even the lower-end 1.6 GHz version (the one I have) is fast enough for web development and leisure surfing/chatting/mailing; the light weight (as compared to the regular MacBook I had before) makes it painless to bring along just in case you might want to use it, and you can carry it from desk to bed in one hand with no effort; the build quality is amazing, and even durable – I’ve accidentally scratched it against the stone wall on our porch with no visible marks.
However, I would like to temper the positive reviews (mine and those of others) by pointing out a very, very annoying issue that seems relatively widespread: the core shutdown issue.
In a nutshell, every so often the kernel_task
process uses a whole lot (usually 60%+) of CPU power on one core, while the other core shuts down completely. This seems to happen a lot more frequently with an external monitor connected, and when performing CPU-intensive tasks like watching Flash video.
I really, really like the computer, but this makes me less productive, makes my neck hurt (from using the external monitor less – class action suit anyone? ;p) and is generally frustrating. This blog post is intended to warn prospective buyers, and to light what small fire I can under Apple.
It can occur even without a monitor connected and when doing other things than watching videos.
Putting the computer to sleep and waking it again (even immediately) tames kernel_task
and brings the other core back to life, but the issue will typically recur pretty soon if you keep doing CPU-intensive things.
Some days this has happened 20+ times, others not at all, depending on how I use the computer.
Sitting in a cool place (temperature-wise!), e.g. the porch in the evening, seems to make it happen less.
I plan on taking my computer to an Apple Store when I have the chance; will update this post or write a new one when there’s more to say.
I would be interested to hear from any Air owner that has not run into the issue, by the way. My boss has an Air and has seen this issue also.