Neuroscience has experienced explosive growth over the last 30 years. Membership in the Society for Neuroscience has increased from 500 in 1970 to 35,000 at present, and the field now rests on a bedrock of theoretical advances in understanding the chemical, electrical and physiological workings of the central nervous system. Yet the philosophy of science has largely ignored neuroscience. This is unfortunate since, first, there is considerable overlap between issues in the philosophy of neuroscience and issues in the philosophy of biology (much of neuroscience is, after all, biology) and, second, neuroscience offers unique puzzles resulting from its (partial) focus on questions of the mind. In an effort to develop bridges between the philosophy of neuroscience and the philosophy of science generally, we propose a session on realization and explanation in neuroscience.
It is frequently said that cognitive states and processes are "realized" in the mechanisms of the brain. The notion of "realization" was originally introduced by Putnam to describe the relationship between the "logical" and the "structural" states of a computer. He later wielded the notion as part of a multiple realizability argument against type-type reduction generally. This latter argument has become a centerpiece of discussions of reductionism and antireductionism in both the philosophy of mind and in the philosophy of biology.
The notion of realization has also assumed a central place in discussions of the status of higher-level generalizations in the so-called "special sciences". For many, the legitimacy of higher-level causal claims hinges upon the existence of lower-level realizers. Thus Stuart Glennan (1996) has argued that to say that one thing causes another (except for lowest level causal relations governed by direct causal laws) just is to say that the relation between them is realized by a mechanism linking cause and effect. Similar positions have been endorsed in the philosophy of neuroscience by Bill Bechtel, Terry Horgan, Ernest Lepore and Barry Loewer (1989) and Jaegwan Kim (see, e.g., 1995, 197). For many of these philosophers, the notion of "realization" ads much needed bite to logical notions of "supervenience" and thus becomes a crucial component in spelling out a robust form of physicalism.
Surprisingly, however, there is almost no consensus (or even, until quite recently, discussion) as to what it takes for one entity, state or process to realize another, about how philosophical and scientific senses of realization are related to one another, or about how the goal of discovering "realizers" shapes scientific practice. These are the questions to be addressed in our session. Craver develops an account of "realization" from his work on mechanisms and then uses it to criticize an argument by V.S. Ramachandran (the Oliver Sachs of the 90's) for the nonexistence of selves. Wilson compares such mechanistic accounts of realization to more metaphysical approaches, arguing that an emphasis on the former tends to reinforce unhealthy localistic biases in contemporary neuroscientific research. Von Eckardt disagrees, arguing that metaphysical approaches to realization have little to say about the notion of realization that is commonplace in neuroscientific research and so ought to be abandoned in favor of a more scientifically adequate notion. Polger, finally, uses Marr's theory of early visual processing to argue that a metaphysically robust notion of realization is necessary to assess the adequacy of physicalism in contemporary neuroscience.
Recent work on the character of mechanisms and of mechanistic levels provides the basis for an account of one sort of realization relation common in neuroscience. In neuroscientific theories, roles (R) are typically realized by mechanisms (M). This realization relation has three parts: the context C within which M realizes R, the "input-output" relation by which M realizes R, and the organized activities of the entities composing M by virtue of which M maintains that input-output relation. This account of realization provides leverage to answer three questions: (i) What are the identity conditions of Rs? (ii) What are the identity conditions of Ms? and (iii) How are the identity conditions for M's and R's related to one another? These questions are raised in the context of the neurologist V.S. Ramachandran's recent attempt to argue that "the self is a fiction" on the grounds that what we call "the self" is in fact realized by several distinct neural mechanisms. I claim, on the basis of the above account of realization and the resulting take on identity conditions, that Ramachandran's argument is deeply flawed (even if his conclusion may be largely correct).
The aim of this paper is to explore, first, the merits of the mechanism approach in the philosophy of biology for understanding explanation in cognitive neuroscience and, second, the scope and limits of cognitive neuroscience itself for understanding human psychology. We shall argue that the mechanism approach, as one would expect, can capture the mechanistic aspects of cognitive neuroscientific models quite well but cannot capture content-related aspects. Furthermore, despite its promise, there are aspects of cognition and behavior that cognitive neuroscience cannot explain, specifically, those involving the social environment. Both these points become evident when one considers cases of psychopathology.
Realization has remained a much used and seldom analyzed concept in the philosophy of psychology and, to a lesser extent, the philosophy of biology, at least until the recent appearance of a flurry of papers (e.g., Bechtel and Mundale 1999; Craver 2001; Lyons 2001; Wilson 2001). After some discussion of the differences between the more metaphysically-rarified and the more mechanistically-driven strands of these discussions, this paper focuses on the relationship between realization (or implementation) and a variety of localistic biases in contemporary research in the neurosciences. William Uttal (2001) has issued a caution about the "new phrenology" thriving in current imaging-driven research, particularly in cognitive neuroscience, and this paper will pick up on some of these concerns, relating them to recent mechanistically-driven strands in the discussion of realization.
The view that the relationship between minds and brains can be thought of on the model of software and hardware is pervasive. The most common versions of the view, known as functionalism in philosophy of mind, hold that minds are realized by brains. The question arises, How do brains realize minds? I approach the question of realization through a case study: David Marr's (1982) computational account of early visual processing. Marr's work is instructive because it is, quite literally, a textbook case of the hierarchy of mechanisms that has seemed to bear out the arguments of functionalist philosophers and cognitive scientists.


If you register an indexer with GSF, it will be called at the right times to extract relevant information from a ParseResult, and store it somewhere in persistent store. You can later quickly search this index. This lets you for example implement cross-file behavior such that a user can search the whole project for functions or classes (via the Open Type dialog in NetBeans), or cross-file go to declaration, code completion referencing symbols in other files, etc. And this can be achieved without having to go and parse other files on the fly when you're trying to collect project information. The index is always kept in sync by GSF. At startup, GSF looks at all the files in your project (as determined by the relevant source directories, see the section on Classpath) and checks whether the timestamp is more recent than the previous timestamp that is recorded in the index. Files that have changed (or have never been indexed) will be indexed, in a background thread, at startup. Similarly, as soon as a file deleted, or edited and then closed, the index will be updated. GSF also tracks whether a file has been edited, such that if you attempt to access its index when the index is considered dirty, the indexer will be immediately called such that all clients of the index can assume the index is always up to date.
Indexing is simple. It basically lets you, for any particular source file, store a series of "Documents", where each document contains a multimap. Each multimap consists of keys, and one or more values each key. Furthermore, keys can be designated as "searchable" or not. This just controls whether you can search the index by the given key. (Keys that are searchable require a bit more maintenance on the GSF side, which is why you avoid it for keys you never plan on searching by).
It is up to you to decide what information to store in the index, how to divide it into documents, how to "encode" it into Strings (all [key,value] pairs are of type [String,String], and so on. Typically, you will make this decision based on how you can later retrieve the information. So, you need to think up front about what you will need, and organize the information based on that. When you search, you can search for a given key. This will return you a set of all the documents where the search occurs. This lets you find other values associated with the [key,value] pair in the same document.
Here's how the information is currently stored for Ruby.
In Ruby, a file can contain many classes. I decided to put each
class in its own search document. This means that if I for example
search for methods that start with "foo", I can look in the same
document for the "class" attribute and I will have information
about the class containing the method. Here's an example of
a Ruby file and the search documents created by the Ruby language
plugin's indexer:
As you can see, we get two documents, one for each class in the file.
In the second class, we have two methods. Each method
is recorded with a "method" key. Later, if I call
searchDoc.getValue("method")
I will get out two strings,
{"mymethod","myother"}
. If I now want to know what
class these methods are coming from, I can call
searchDoc.getValue("class")
- or to get the fully qualified
name (fqn), searchDoc.getValue("fqn")
. I can also look
up attributes for this class with searchDoc.getValue("attrs")
which for example lets me see if this is a class or a module. I store
a number of attributes - whether a class is documented, or if it
is explicitly to be ignored, and so on. These are used by the code
completion and go to declaration feature implementations to for example
pick the best candidate among multiple possibilities.
There's a more complete list of the data stored in the Ruby index
later in this document.
To index your code, implement the
Indexer interface.
First, you must implement the isIndexable
method:
boolean isIndexable(@NonNull ParserFile file);This should just be a quick check to see if the given file should be indexed by this indexer. Typically, you'll just look at the file name and make a decision.
.js
files, as well as .html
, .jsp
and .erb
, since these embedded file types can contain
JavaScript functions we want in the index.
In some cases however, the logic can be slightly more complicated.
In the case of JavaScript again, it's pretty common to have "minimized"
versions of a file, where symbols have been replaced with single letter
names, whitespace removed etc. to make the code as small and fast as
possible. We typically don't want to index these versions, so the
JavaScript indexer checks the file name and looks for name pattern
overlaps. If it for example finds foo-debug.js
, foo-min.js
and foo.js
, it will return false
from isIndexable()
for both foo-debug.js
and foo-min.js
, and true
only for foo.js
.
IMPORTANT: You may be tempted to base your decision on the mimetype of
a file, but be careful calling file.getFileObject().getMimeType()
.
First, file.getFileObject()
can be a performance issue.
During startup, your indexer will be asked by the system for all the
source files in the project if they are indexable. Each getFileObject
can end up doing a lot of work.
A bigger problem is that when source files are deleted, the index needs to
be cleaned up. The IDE will ask all the indexers if they care about this file,
and if they do, the index entries will be cleared for this file.
(TODO: Perhaps I should just unconditionally try to delete the file in all
indices?)
In any case, when a file is deleted, its FileObject
no longer
exists, and calling file.getFileObject()
will return null.
You can end up getting an NPE in these cases if you're not careful.
The second method you have to implement in your indexer is
List<IndexDocument> index(ParserResult result, IndexDocumentFactory factory)Here, all you have to do is look up your own AST from your
ParserResult
.
Then, look through your AST, pick out the information you want to store, and store
it in the index. You do that by creating one or more documents (by calling
the IndexDocumentFactory
which is passed to you above.
The IndexDocumentFactory
lets you create an IndexDocument
.
And each IndexDocument
object has a single method:
void addPair(String key, String value, boolean searchable);So, all you have to do here is call
addPair
repeatedly, with key,value pairs.
You also get to decide if your key is searchable. You must be consistent
in how you call this method with respect to the searchable
parameter
for a given key in a given document.
You can search your index. For the various feature implementations (code completion,
go to declaration, and so on), you are passed a
CompilationInfo instance.
The CompilationInfo
holds a lot of vital state: your parser result,
the file object and document corresponding to the current file, and so on.
It also gives you access to the
Index object.
The Index
class has one method:
SearchContext
class which holds some of the
search parameters, and the search method will change into a simple
search(SearchContext)
method. I also plan to remove the result list
input parameter and just return it (created by the index) instead.
public abstract void search( @NonNull final String key, @NonNull final String value, @NonNull final NameKind kind, @NonNull final Set<SearchScope> scope, @NonNull Set<SearchResult> result, @NonNull final Set<String> includeKeys);The way this works is that you create your own empty set of SearchResults, and then you call the search method on the index with a key, a value (which for example can be a prefix), and so on. This will fill your SearchResult set with matches.
You can now iterate over the matching SearchResults (which will correspond to
IndexDocument
s your indexer have created earlier), and for each,
call one of the getValue methods:
@NonNull String getValue(@NonNull String key); @NonNull String[] getValues(@NonNull String key);If you know that you're storing just one value for a given in the index (such as the
class
or fqn
keys in the Ruby index),
you can call the getValue
method to get it directly. If you're
storing many values (such as the method
key in the Ruby index),
call getValues
to get an array of all the results.
In the search section above I glossed over some of the other parameters
in the search
method. In particular, the scope
parameter, which lets you control whether to search just the current
project, or just the libraries, or both. But how does GSF know what source
files are relevant in the project? And what about the libraries?
This is controlled by a different API in GSF, which you use to integrate into different project types and tell GSF which directories are relevant for this project, as well as register libraries. This is described in more detail in the Classpath document.
I recommend that you build an abstraction on top of the index. Your various feature implementations shouldn't go into the index and look for specific keys and so forth. That will make changing the index (which I will discuss in the next section) very difficult. Instead, you should create a class which wraps the index with logical methods. For example, in Ruby, I have a RubyIndex class which has dedicated methods like
getClasses()
getMethods()
getSubclassesOf()
getRequires()
getTransitiveRequires()
getSuperClass()
getOverridingMethod()
getInheritedMethods()
During development, including after your first release, you'll probably find that you want to make changes to the index, either because of performance reasons, or because you want to store more information to support new features. However, if you just make the change in your indexer and index query code, you might have a really hard time dealing with the fact that your users can have existing indices out there with the old data format.
Dealing with this is easy. The Indexer
class has these two
methods:
@NonNull String getIndexerName(); @NonNull String getIndexVersion();Any time you make an incompatible change to the way you are storing data in the index, just change the value of your
getIndexVersion()
method. This will force reindexing of all the code whenever your users
run with your new version of the indexer.
The way this works on the implementation side is that each index database
is isolated, and in particular, they are stored in the user directory,
under var/cache/gsf-index/your-index-name/your-index-version
.
For example, the Ruby indexer names its indexer "ruby", and the JavaScript
indexer names its indexer "javascript". This ensures that these two systems
don't interfere which each others databases. The index version is just a string,
and you can put anything you want here (as long as it's a string that is
filesystem safe, meaning it can be written on all file systems where NetBeans
runs). A good convention is to just use a number - e.g. "42" or "6.5.2", etc.
Unit testing your indexer is trivial. Create a unit test class for your
indexer, and make sure it extends GsfTestBase
. Then, just
create new tests with the following single line call:
public class RubyIndexerTest extends RubyTestBase { public void testIndexData() throws Exception { checkIndexer("testfiles/date.rb"); } public void testRails1() throws Exception { checkIndexer("testfiles/action_controller.rb"); } ...etc }All you have to do is put the test files you want into
test/unit/data
,
refer to them from the checkIndexer
call, and the GSF test infrastructure
will do the rest: it will load the file, parse it using your parser,
call your indexer, pretty print it, see if a golden file (named the same as
the input file name, plus the extra extension .indexed
) exists,
and if not create it, or otherwise diff the computed results with the golden
file. The test fails if the diffs aren't identical.
See the Unit Testing document for more information.
Sometimes a feature fails -- for example, code completion doesn't return the results you expect. One way to debug this is to use the GSF diagnostics tools. The Lucene Index Browser is described in the GSF Diagnostics Tools document.
The following table shows the data currently stored in the Ruby index, which will hopefully give some ideas for how a complete indexer/query system can work:
| Key | Value |
|---|---|
| fqn | Fully qualified name of a class or module, such as "Test::Unit" for the Unit class. |
| class | The "basename" of a class or module, such as "Unit" for the Test::Unit class. |
| class-ig | A lowercased version of the class name. Used for case insensitive queries. (This shouldn't be necessary). |
| extends | The fully qualified name of a superclass, if any. Used to compute inherited methods by iterating through class documents. |
| in | The name of the module this class is contained in. |
| require | The string required to include this class from other files, e.g. io/nonblock for the nonblock.rb file. Used for require-completion. |
| requires | A list of all the files this file requires. Used to compute file inclusion transitively. |
| includes | A list of modules included (not the same as requires) by this class or module. |
| extendWith | Used to simulate the way classes can dynamically be extended with a given module in Ruby. |
| method | A method in the class. This isn't just a method name; it's a pretty complicated encoding of the method name, its parameter list, its (optional) return type, its (optional) parameter hints or types, as well as a set of attributes for the method (is documented, is ignored, etc.) |
| field | A field in the class |
| attribute | An attribute in the class. |
| constant | A constant in the class |
| attrs | A set of attributes for the class, written as a hex value string |
| dbtable | For active record database table completion, the table name this migration refers to |
| dbversion | The version number of this migration (used to apply the migrations in the correct order) |
| dbcolumn | A column name to be added, removed or renamed (indicated with + or - after the name) |


Available Tools
The following tools are avaiable on this site:- Spatially-balanced Sampling Tool—This tool runs the GRTS spatially-balanced algorithm for selecting random sample sites using an uploaded shapefile to define the project area and strata.
- Optimal Error Rate Calculator—
- Sample Sufficiency Tool for continuous data—
- Sample Sufficiency Tool for proportions—
- DIMA Quality Control Tool—Tool for running data quality control analysis on a DIMA database.
If you have questions about these tools or need assistance, please visit the Contact Us page on the Landscape Toolbox.
What is Shiny?
Shiny is a web application framework for the R statistical software app that provides an easy way to create statistical and analytical tools that can run over the web. Shiny apps are developed in R on a desktop PC and is then hosted on a web server that is running R and Shiny. Shiny allows us to make sophisticated data analysis tools avaiable over the web to people who do not have access to statistics software apps. For more information on Shiny, check out R Studio's Shiny site.
Disclaimer!
These tools have been developed using the best available statistical theories and algorithms, and we have tested these tools extensively with different datasets. However, we make no guarantee that these tools will work for your specific datasets. You are ultimately responsible for the validity, accuracy, and interpretation of your data. We offer no warranty as to the accuracy and validity of the results. It is your responsibilty to understand what each of these tools is doing and how to use/interpret the results. The code for all of these tools is available on the Landscape Toolbox GitHub Repository.


We have now considered the elements of programming: We have used primitive arithmetic operations, we have combined these operations, and we have abstracted these composite operations by declaring them as compound functions. But that is not enough to enable us to say that we know how to program. Our situation is analogous to that of someone who has learned the rules for how the pieces move in chess but knows nothing of typical openings, tactics, or strategy. Like the novice chess player, we don't yet know the common patterns of usage in the domain. We lack the knowledge of which moves are worth making (which functions are worth declaring). We lack the experience to predict the consequences of making a move (executing a function).
The ability to visualize the consequences of the actions under consideration is crucial to becoming an expert programmer, just as it is in any synthetic, creative activity. In becoming an expert photographer, for example, one must learn how to look at a scene and know how dark each region will appear on a print for each possible choice of exposure and development[1] conditions. Only then can one reason backward, planning framing, lighting, exposure, and development to obtain the desired effects. So it is with programming, where we are planning the course of action to be taken by a process and where we control the process by means of a program. To become experts, we must learn to visualize the processes generated by various types of functions. Only after we have developed such a skill can we learn to reliably construct programs that exhibit the desired behavior.
A function is a pattern for the local evolution of a computational process. It specifies how each stage of the process is built upon the previous stage. We would like to be able to make statements about the overall, or global, behavior of a process whose local evolution has been specified by a function. This is very difficult to do in general, but we can at least try to describe some typical patterns of process evolution.
In this section we will examine some common shapes
for processes
generated by simple
functions.
We will also investigate the
rates at which these processes consume the important computational
resources of time and space.
The
functions
we will consider
are very simple. Their role is like that played by test patterns in
photography: as oversimplified prototypical patterns, rather than
practical examples in their own right.


B&R
THE
Belt and Road
Toggle navigation
10
You have 10 notifications
5 new members joined today
View all
Alexander Pierce
Alexander Pierce - Web Developer
Member since Nov. 2012
Profile
Sign out
press release wall
SAARC
23 Jan 2:00 pm
Is this template really for free? That's unbelievable!
Count Dracula
2/28/2015
How have you been? I was...
HRI
23 Jan 2:00 pm
Is this template really for free? That's unbelievable!
Accept
Decline
HRI
23 Jan 2:00 pm
Is this template really for free? That's unbelievable!
Accept
Decline


The information about the cApp
A function returning whether a state sent by the counterparty is valid
The session ID
Deposits into an ERC-20 token channel.
The amount to be deposited into the channel, in wei
The hash of the deposit transaction
Deposits into an ETH channel.
The amount to be deposited into the channel, in wei
The hash of the deposit transaction
Ends a cApp session and resolves all conditional payments in an ERC-20 token associated with the session.
The ID for the cApp session
The address of the ERC-20 token contract
The index of the winner
Ends a cApp session and resolves all conditional payments in ETH associated with the session.
The ID for the cApp session
The index of the winner
Gets the balance of an ERC-20 token channel.
The address of the ERC-20 token contract
The balance information
Gets the balance of an ETH channel.
The balance information
Opens an ERC-20 token channel.
The amount to be deposited into the channel, in wei
The amount to be deposited into the channel by the counterparty, in wei
The channel ID
Opens an ETH channel.
The amount to be deposited into the channel, in wei
The amount to be deposited into the channel by the counterparty, in wei
The channel ID
Registers an on-chain oracle
The address of the oracle contract
The ABI of the oracle contract
Resolves all conditional payments in an ERC-20 token associated with an on-chain oracle
The address of the oracle contract
The address of the ERC-20 token contract
Resolves all conditional payments in ETH associated with an on-chain oracle
The address of the oracle contract
Sends an off-chain ERC-20 token payment.
The address of the ERC-20 token contract
The amount to be sent, in wei
The ETH address of the recipient
The payment ID (currently unimplemented)
Sends an off-chain ERC-20 token payment with a condition.
The address of the ERC-20 token contract
The amount to be sent, in wei
The ETH address of the recipient
The condition for the payment to be issued
The payment ID (currently unimplemented)
Sends an off-chain ETH payment.
The amount to be sent, in wei
The ETH address of the recipient
The payment ID (currently unimplemented)
Sends an off-chain ETH payment with a condition.
The amount to be sent, in wei
The ETH address of the recipient
The condition for the payment to be issued
The payment ID (currently unimplemented)
Sends a cApp state.
The ID for the cApp session
The ETH address of the counterparty
The state represented in a byte array
Settles a cApp session by deploying the cApp contract on-chain.
The ID for the cApp session
The address of the deployed cApp contract
Withdraws from an ERC-20 token channel.
The amount to be withdrawn from the channel, in wei
The hash of the withdrawal transaction (currently unimplemented)
Withdraws from an ETH channel.
The amount to be withdrawn from the channel, in wei
The hash of the withdrawal transaction (currently unimplemented)
Creates an cApp session.


iWrite
Home
About
This project was built by
Jaime from barbarianmeetscoding.com
and is powered by
VanillaJS
.
VanillaJS


Pending invites ({{(invites|filter: {active:true}).length}})
| Id |
Email |
Group |
Sender |
Action |
| {{s_invite.id}} |
{{s_invite.email}} |
{{s_invite.groups.name}} |
{{s_invite.inviter.username}} |
Cancel invite
|
No invites yet.
Success! You've just sent an invitation!


Blog
Products
MEET - a java based app that brings together mongoDB and Twitter and shows a simple way to start to insert your company tweets up into mongoDB, this then allows for map reduce queries, business intelligence and marketing functions to take place that just simple could not be done before the availability of these technologies.
MEET functionality includes: 20 tweets per call are inserted from your nominated twitter account into your chosen mongoDB Database allowing for further analysis.
MYJARVIS - a console based application written in java that using a artifical intelligence style interface controls and displays bespoke messaging, myJarvis allows the user to control all aspects of there life in a CLI (Complete Life Interface)
myJarvis functionality includes: AI interface, twitter, facebook and email feeds, weather and stock reports, note taking, appointment reminders, remote appliance controls.
JSIMONGO - a java <IP_ADDRESS> program that uses the mongo java API to post documents up into a MongoDB Cloud instance in a time lapsed manner, this significantly helps in the test, development and visualization of many different types of realtime interfaces
JSImongo functionality will include: Run as a service, sample JSON, user defined random member data and data profiling. Full flexibility is the target. Note JSI will need to be run external to any firewalls - common place in a standard office LAN environment. This is very early days but an alpha version is now available on the downloads page.


 Maybe we could pass in a set
// of visited?
optimizer(node._mem.weights, node._mem.gradient, key=node.id)
seen.add(node.id)
for shim in node.shims:
shim.finish_update(optimizer)
After Change
for node in self.walk():
for name in node.param_names:
if node.has_grad(name):
param = node.get_param(name)
grad = node.get_grad(name)
param, grad = optimizer(param, grad, key=(node.id, name))
node.set_param(name, param)
node.set_grad(name, grad)
for shim in node.shims:
shim.finish_update(optimizer)
@contextlib.contextmanager


Midtime
Midtime: Copyright (C) 2014- MJHSC - Indie Game Creators Team - http://mjhsc.wordpress.com/
Portions: (C)2006-2011 DeepCave Exploration.
※ 2014年に、Midtimeに関する全権利・義務をDeepCave Explorationから譲渡された上で、MJHSC! - Indie Game Creators Teamが開発しています。
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
3. All advertising materials mentioning features or use of this software SHOULD display the following acknowledgement if you want to contribute our work:
This product includes Midtime technology developed by MJHSC - Indie Game Creators Team - http://mjhsc.wordpress.com/
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
MidtimeVM.dll, Midtime.ExtAPI.dll, Midtime.Network.dll
OpenHSP
Copyright (C) 1997-2011, Onion Software/onitama.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
Neither the name of the Onion Software nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.


FirefoxOS
Building a home screen
Kevin Grandon
@kevining
Where is it?
- 12 smartphones
- 13 operators
- 24 countries
Target Audiennce
- Emerging Markets
- First time smartphone users
$35 smart phone
The Home Screen
1.0 - 1.4 home screen
Riverscreen - custom home screen
2.0 vertical home screen
Replaceable Home Screens
- Make your phone your own.
- Upload your home screen to the marketplace.
How does it work?
What is an app anyway?
A website: <html>...</html>
A manifest: manifest.webapp
Web Manifest
{
"name": "My App",
"description": "My elevator pitch goes here",
"launch_path": "/index.html",
"icons": {
"512": "/img/icon-512.png",
"128": "/img/icon-128.png"
},
"developer": {
"name": "Your name or organization",
"url": "http://your-homepage-here.org"
},
"default_locale": "en"
}
WebAPI - Hardware Access
var battery = navigator.battery;
function updateBatteryStatus() {
console.log("Battery status: " + battery.level * 100 + " %");
if (battery.charging) {
console.log("Battery is charging");
}
}
battery.addEventListener("chargingchange", updateBatteryStatus);
battery.addEventListener("levelchange", updateBatteryStatus);
WebAPI - Applications
var request = window.navigator.mozApps.getAll();
request.onsuccess = function(evt) {
var apps = evt.target.result;
// Render some apps.
// Uninstall an app:
apps[0].uninstall();
};
Thanks!
Kevin Grandon
@kevining


Most of JSFEAT
methods relies on custom data structures. There are just few provided at the moment but I'm sure its number will increase with new functionality.
The core and starting structure for any project is most likely matrix_t
:
var my_matrix = new jsfeat.matrix_t(columns, rows, data_type, data_buffer = undefined);
matrix_t
is quite flexible structure, it can be used as image representation or regular matrix for mathematics. columns
and rows
is the same as defining width
and height
for image. But let's look at data_type
argument. It allows you to describe matrix_t
underlaying data.
To construct data_type
you need to use library internal signatures. NOTE: at the moment most of methods support only single channel operations due to performance reasons.
// single channel unsigned char var data_type = jsfeat.U8_t | jsfeat.C1_t; // 2 channels 32 bit integer var data_type = jsfeat.S32_t | jsfeat.C2_t; // 3 channels 32 bit float var data_type = jsfeat.F32_t | jsfeat.C3_t;
Let's put all together:
var columns = 320, rows = 240, data_type = jsfeat.U8_t | jsfeat.C1_t; var my_matrix = new jsfeat.matrix_t(columns, rows, data_type); // we can access following properties: // my_matrix.cols, my_matrix.rows // my_matrix.data - underlaying array for data holding // to check what type is used for data you can use bit mask: // if(my_matrix.type & jsfeat.U8_t) ... // my_matrix.channel = 1/2/3/4
You can resize matrix_t
at any time using resize
method. NOTE: this operation will delete current data array if new size is larger.
my_matrix.resize(new_cols, new_rows, new_channels);
You also can access matrix_t
buffer
property that is a wrapper for data
and implemented with data_t
structure.
This is just a wrapper for JavaScript ArrayBuffer
. But provides easier way to interpret underlaying data:
// you can provide preallocated ArrayBuffer var my_data = new jsfeat.data_t(size_in_bytes, buffer = undefined); var my_data_buffer = my_data.buffer; // ArrayBuffer var u8_data = my_data.u8; // Uint8Array var i32_data = my_data.i32; // Int32Array var f32_data = my_data.f32; // Float32Array
// you can also provide pre-allocated data_t for matrix var columns = 320, rows = 240, data_type = jsfeat.U8_t | jsfeat.C1_t; var data_buffer = new jsfeat.data_t(columns*rows); var my_matrix = new jsfeat.matrix_t(columns, rows, data_type, data_buffer);
A structure to wrap several matrix_t
instances. Each data
entry is 2x smaller then previous:
var levels = 3, start_width = 640, start_height = 480, data_type = jsfeat.U8_t | jsfeat.C1_t; var my_pyramid = new jsfeat.pyramid_t(levels); // this will populate data property with matrix_t instances my_pyramid.allocate(start_width, start_height, data_type); var level_0 = my_pyramid.data[0]; // cols = 640, rows = 480 var level_1 = my_pyramid.data[1]; // cols = 320, rows = 240 var level_2 = my_pyramid.data[2]; // cols = 160, rows = 120 // with build method you can draw input source to levels // skip_first_level is true by default my_pyramid.build(source_matrix_t, skip_first_level = true);
2D point with coordinates, level and score properties:
// all arguments are zero by default var my_point = new jsfeat.keypoint_t(x = 0, y = 0, score = 0, level = 0);
Used for ransac
based motion estimator.
var model_size = 4; // minimum points to estimate motion var thresh = 3; // max error to classify as inlier var eps = 0.5; // max outliers ratio var prob = 0.99; // probability of success var params = new jsfeat.ransac_params_t(model_size, thresh, eps, prob);
JSFEAT
has very simple and experimental linked pool based cache system. At the moment I'm not sure if it is really needed since most JavaScript engines have their own powerful caching. But running some tests I noticed that repeatedly calling methods that need temporary Array
(s) allocation significantly increase its execution time. So replacing allocation with pooled buffers helps to improve performance in some cases. How it works:
var size_in_bytes = 640; var temp_buffer = jsfeat.cache.get_buffer(size_in_bytes); var temp_u8 = temp_buffer.u8; // Uint8Array 640 entries // but you also can get other data types // Int32Array but length will be 640/4 = 160 entries var temp_i32 = temp_buffer.i32; // since all buffers comes from data_t instance // you can also use it to construct matrix_t var columns = 320, rows = 240, data_type = jsfeat.U8_t | jsfeat.C1_t; var my_matrix = new jsfeat.matrix_t(columns, rows, data_type, temp_buffer.data); // be careful because you always should provide enough space for matrix
NOTE: you always need to put buffer back to cache pool after you are done:
jsfeat.cache.put_buffer(temp_buffer);
At the moment the number of temporary buffers is fixed to 30 entries. I cant hardly imagine scenario where you may need more buffers. If the whole idea having cache
pool will prove its usefulness we can extend it to different data types and add auto extending functionality.
JSFEAT
has it's own jsfeat.math
module, it contains different math utilite methods that can be useful.
Calculates gaussian kernel coefficients using specified options:
var kernel_size = 5, sigma = 0, kernel_array = [], data_type = jsfeat.F32_t; jsfeat.math.get_gaussian_kernel(kernel_size, sigma, kernel_array, data_type); // you can provide zero sigma to determinate it automatically from kernel_size // or set desired value
NOTE: setting data_type
to jsfeat.U8_t
will result in integer based kernel that can be used to filter unsigned char
image avoiding floating-point operations.
Generic sorting method that allows you to specify start and end sorting indices for the source array aswell as provide custom comparison method. Current implementation was derived from *BSD system qsort()
.
// sort numeric array var arr = [10,2,1,0,0,4,6,1,3,8,5,3]; var cmp_numeric = function(a, b) { return (a < b); } jsfeat.math.qsort(arr, 0, arr.length-1, cmp_numeric); // sort array of points var point_arr = [ new jsfeat.keypoint_t(1,10), new jsfeat.keypoint_t(5,1), new jsfeat.keypoint_t(33,10), new jsfeat.keypoint_t(0,0), new jsfeat.keypoint_t(8,6), new jsfeat.keypoint_t(3,0)]; // define comparison method to sort points by ascending of y coordinates // and if y's are equal x's should ascend. var cmp_points = function(a, b) { return (a.y < b.y) || (a.y < b.y && a.x < b.x); } jsfeat.math.qsort(point_arr, 0, point_arr.length-1, cmp_points);
Calculate median value of provided Array
, NOTE: input Array
instance will be modified.
var arr = [10,2,1,0,0,4,6,1,3,8,5,3]; var median = jsfeat.math.median(arr, 0, arr.length-1);
Calculates the perspective transform from 4 pairs of the corresponding points. The function calculates the 3x3 Matrix
jsfeat.transform.perspective_4point_transform(mat:matrix_t, src_x0, src_y0, dst_x0, dst_y0, src_x1, src_y1, dst_x1, dst_y1, src_x2, src_y2, dst_x2, dst_y2, src_x3, src_y3, dst_x3, dst_y3);
Various generalized matrix operations.
Transposes a matrix.
jsfeat.matmath.transpose(At:matrix_t, A:matrix_t);
Performs matrix multiplication.
jsfeat.matmath.multiply(C:matrix_t, A:matrix_t, B:matrix_t);
Post multiply the nrows x ncols
matrix A
by the transpose of the mrows x ncols
matrix B
to form the nrows x mrows
matrix C
, i.e. C = A*B'
.
jsfeat.matmath.multiply_ABt(C:matrix_t, A:matrix_t, B:matrix_t);
Post multiply the transpose of the nrows x ncols
matrix A
by the nrows x mcols
matrix B
to form the ncols x mcols
matrix C
, i.e. C = A'*B
.
jsfeat.matmath.multiply_AtB(C:matrix_t, A:matrix_t, B:matrix_t);
Post multiply an nrows x ncols
matrix A
by its transpose. The result is an nrows x nrows
square symmetric matrix C
, i.e. C = A*A'
.
jsfeat.matmath.multiply_AAt(C:matrix_t, A:matrix_t);
Pre multiply an nrows x ncols
matrix A
by its transpose. The result is an ncols x ncols
square symmetric matrix C
, i.e. C = A'*A
.
jsfeat.matmath.multiply_AtA(C:matrix_t, A:matrix_t);
Quick inverse of 3x3 matrix. Can operate inplace.
jsfeat.matmath.invert_3x3(from:matrix_t, to:matrix_t);
Quick 3x3 matrix multiplication. Can operate inplace.
jsfeat.matmath.multiply_3x3(C:matrix_t, A:matrix_t, B:matrix_t);
Calculate 3x3 matrix determinant.
var determinant = jsfeat.matmath.mat3x3_determinant(M:matrix_t);
Solves the system of linear equations Ax = B
using Gaussian elimination with optimal pivot element chosen. NOTE: input matrix_t
instances will be modified and result output in matrix B
.
// A and B modified and result output in B jsfeat.linalg.lu_solve(A:matrix_t, B:matrix_t);
Solves the system of linear equations Ax = B
using Cholesky factorization. The matrix must be symmetrical and positively defined. NOTE: input matrix_t
instances will be modified and result output in matrix B
.
// A and B modified and result output in B jsfeat.linalg.cholesky_solve(A:matrix_t, B:matrix_t);
This routine decomposes an rows x cols
matrix A
, into a product of the three matrices U
, W
, and V'
, i.e. A = UWV'
, where U
is an rows x rows
matrix whose columns are orthogonal, W
is a 1 x cols
matrix, and V
is an cols x cols
orthogonal matrix.
// U - the left orthogonal matrix // W - vector of singular values // V - the right orthogonal matrix // options - jsfeat.SVD_U_T and/or jsfeat.SVD_V_T to return transposed U and/or V jsfeat.linalg.svd_decompose(A:matrix_t, W:matrix_t, U:matrix_t, V:matrix_t, options);
Solves the system of linear equations Ax = B
using Singular value decomposition (SVD) method; the system can be over-defined and/or the matrix A
can be singular.
// A - left-hand side of the system // B - right-hand side of the system // X - output solution jsfeat.linalg.svd_solve(A:matrix_t, X:matrix_t, B:matrix_t);
This routine calculates the pseudo-inverse of the matrix A
.
// inverts matrix A to matrix Ainvert jsfeat.linalg.svd_invert(Ainvert:matrix_t, A:matrix_t);
Computes eigenvalues and eigenvectors of a symmetric matrix.
jsfeat.linalg.eigenVV(A:matrix_t, EigenVectors:matrix_t, EigenValues:matrix_t); // you can ask for Vectors or Values only jsfeat.linalg.eigenVV(A:matrix_t, null, EigenValues:matrix_t); jsfeat.linalg.eigenVV(A:matrix_t, EigenVectors:matrix_t, null);
The functions in this module estimate various geometrical transformations between two point sets.
VIDEO STABILIZER DEMO ORB MATCHING DEMO
This kernel calculates the affine transform from corresponding points. The function calculates the 3x3 Matrix
// create affine kernel // you can reuse it for different point sets var affine_kernel = new jsfeat.motion_model.affine2d(); var affine_transform = new jsfeat.matrix_t(3, 3, jsfeat.F32_t | jsfeat.C1_t); var count = 33; var from = []; var to = []; for(var i = 0; i < count; ++i) { // you can use keypoint_t structure // or just provide object with x and y properties from[i] = { "x":Math.random()*320, "y":Math.random()*240 }; to[i] = { "x":from[i].x + 5, "y":from[i].y+5 }; } affine_kernel.run(from, to, affine_transform, count); // you can also calculate transform error for each point var error = new jsfeat.matrix_t(count, 1, jsfeat.F32_t | jsfeat.C1_t); affine_kernel.error(from, to, affine_transform, error.data, count);
This kernel calculates perspective transform between point sets. Result is 3x3 Matrix
// create homography kernel // you can reuse it for different point sets var homo_kernel = new jsfeat.motion_model.homography2d(); var homo_transform = new jsfeat.matrix_t(3, 3, jsfeat.F32_t | jsfeat.C1_t); var count = 33; var from = []; var to = []; for(var i = 0; i < count; ++i) { // you can use keypoint_t structure // or just provide object with x and y properties from[i] = { "x":Math.random()*320, "y":Math.random()*240 }; to[i] = { "x":from[i].x + 5, "y":from[i].y+5 }; } homo_kernel.run(from, to, homo_transform, count); // you can also calculate transform error for each point var error = new jsfeat.matrix_t(count, 1, jsfeat.F32_t | jsfeat.C1_t); homo_kernel.error(from, to, homo_transform, error.data, count);
RANdom SAmple Consensus. [for more info see: http://en.wikipedia.org/wiki/RANSAC]
// this class allows you to use above Motion Kernels // to estimate motion even with wrong correspondences var ransac = jsfeat.motion_estimator.ransac; // create homography kernel // you can reuse it for different point sets var homo_kernel = new jsfeat.motion_model.homography2d(); var transform = new jsfeat.matrix_t(3, 3, jsfeat.F32_t | jsfeat.C1_t); var count = 333; var from = []; var to = []; for(var i = 0; i < count; ++i) { // you can use keypoint_t structure // or just provide object with x and y properties from[i] = { "x":Math.random()*320, "y":Math.random()*240 }; to[i] = { "x":from[i].x + Math.random()*5, "y":from[i].y+Math.random()*5 }; } // each point will be marked as good(1) or bad(0) var mask = new jsfeat.matrix_t(count, 1, jsfeat.U8_t | jsfeat.C1_t); var model_size = 4; // minimum points to estimate motion var thresh = 3; // max error to classify as inlier var eps = 0.5; // max outliers ratio var prob = 0.99; // probability of success var params = new jsfeat.ransac_params_t(model_size, thresh, eps, prob); var max_iters = 1000; var ok = ransac(params, homo_kernel, from, to, count, transform, mask, max_iters);
Least Median of Squares. Similar to above algorithm but uses median error value to filter wrong matches.
// this class allows you to use above Motion Kernels // to estimate motion even with wrong correspondences var lmeds = jsfeat.motion_estimator.lmeds; // create homography kernel // you can reuse it for different point sets var affine_kernel = new jsfeat.motion_model.affine2d(); var transform = new jsfeat.matrix_t(3, 3, jsfeat.F32_t | jsfeat.C1_t); var count = 333; var from = []; var to = []; for(var i = 0; i < count; ++i) { // you can use keypoint_t structure // or just provide object with x and y properties from[i] = { "x":Math.random()*320, "y":Math.random()*240 }; to[i] = { "x":from[i].x + Math.random()*5, "y":from[i].y+Math.random()*5 }; } // each point will be marked as good(1) or bad(0) var mask = new jsfeat.matrix_t(count, 1, jsfeat.U8_t | jsfeat.C1_t); var model_size = 3; // minimum points to estimate motion var thresh = 0; // is not used in lmeds var eps = 0.45; // hard coded internally var prob = 0.99; // probability of success var params = new jsfeat.ransac_params_t(model_size, thresh, eps, prob); var max_iters = 1000; var ok = lmeds(params, affine_kernel, from, to, count, transform, mask, max_iters);
jsfeat.imgpoc
module is like library heart! It contains all kind of methods to pre/post process and analyze image data.
Convert color array input [r0,g0,b0,a0, ...]
to grayscale using Y = 0.299*R + 0.587*G + 0.114*B
formula. You can specify the source input channel order such as BGRA, RGBA, RGB and BGR.
context2d.drawImage(video, 0, 0, width, height); var image_data = context2d.getImageData(0, 0, width, height); var gray_img = new jsfeat.matrix_t(width, height, jsfeat.U8_t | jsfeat.C1_t); var code = jsfeat.COLOR_RGBA2GRAY; jsfeat.imgproc.grayscale(image_data.data, width, height, gray_img, code);
Generic resize method. Works with single and multi channel matrix_t
. If performance is critical or you need multiple image resizings it is recommended to use canvas
built-in drawImage()
method.
jsfeat.imgproc.resample(source:matrix_t, dest:matrix_t, new_width, new_height);
Works with single channel data only. NOTE: if input is jsfeat.U8_t
and options = jsfeat.BOX_BLUR_NOSCALE
dest should be at least jsfeat.S32_t
to handle accumulated values correctly.
/* options - you can pass jsfeat.BOX_BLUR_NOSCALE to avoid result values scaling */ jsfeat.imgproc.box_blur_gray(source:matrix_t, dest:matrix_t, radius, options = 0);
Works with single channel data only. You can choose between providing kernel_size
or sigma
argument or both.
jsfeat.imgproc.gaussian_blur(source:matrix_t, dest:matrix_t, kernel_size, sigma = 0);
Downsample source
to dest
writing simple 4 pix average value. Works with single channel only.
jsfeat.imgproc.pyrdown(source:matrix_t, dest:matrix_t);
Compute gradient using Scharr kernel [3 10 3] * [-1 0 1]^T
. Works with single channel only.
// result is written as [gx0,gy0,gx1,gy1, ...] sequence in 2 channel matrix_t jsfeat.imgproc.scharr_derivatives(source:matrix_t, dest:matrix_t);
Compute gradient using Sobel kernel [1 2 1] * [-1 0 1]^T
. Works with single channel only.
// result is written as [gx0,gy0,gx1,gy1, ...] sequence in 2 channel matrix_t jsfeat.imgproc.sobel_derivatives(source:matrix_t, dest:matrix_t);
Calculates one or more integral images for the source image. Using these integral images, one may calculate sum, mean, standard deviation over arbitrary up-right or rotated rectangular region of the image in a constant time. NOTE: each destinatination should be 1 pixel larger than source width = source.cols+1, height = source.rows+1
. Single channel source only.
jsfeat.imgproc.compute_integral_image(source:matrix_t, sum:Array, sqsum:Array, tilted:Array);
Equalizes the histogram of a grayscale image. The algorithm normalizes the brightness and increases the contrast of the image.
jsfeat.imgproc.equalize_histogram(source:matrix_t, dest:matrix_t);
Canny edge detector. Result contains only 0x00
and 0xFF
values.
jsfeat.imgproc.canny(source:matrix_t, dest:matrix_t, low_threshold, high_threshold);
Applies a perspective transformation to an image using 3x3 Matrix
. Single channel source only.
To avoid sampling artifacts, the mapping is done in the reverse order, from destination to the source. That is, for each pixel of the destination image, the functions compute coordinates of the corresponding “donor” pixel in the source image and copy the pixel value.
jsfeat.imgproc.warp_perspective(source:matrix_t, dest:matrix_t, warp_mat:matrix_t, fill_value = 0);
Applies an affine transformation to an image using 2x3 or 3x3 Matrix
. Single channel source only.
To avoid sampling artifacts, the mapping is done in the reverse order, from destination to the source. That is, for each pixel of the destination image, the functions compute coordinates of the corresponding “donor” pixel in the source image and copy the pixel value.
jsfeat.imgproc.warp_affine(source:matrix_t, dest:matrix_t, warp_mat:matrix_t, fill_value = 0);
Feature Detection and Description
Detects corners using the FAST
algorithm.
// threshold on difference between intensity of the central pixel // and pixels of a circle around this pixel var threshold = 20; jsfeat.fast_corners.set_threshold(threshold); var corners = [], border = 3; // you should use preallocated keypoint_t array for(var i = 0; i < img.cols*img.rows, ++i) { corners[i] = new jsfeat.keypoint_t(0,0,0,0); } // perform detection // returns the amount of detected corners var count = jsfeat.fast_corners.detect(img:matrix_t, corners:Array, border = 3);
Laplacian and min eigen value based feature detector by CVLab (Ecole Polytechnique Federale de Lausanne (EPFL), Switzerland).
var corners = [], laplacian_threshold = 30, min_eigen_value_threshold = 25; // choose threshold values jsfeat.yape06.laplacian_threshold = laplacian_threshold; jsfeat.yape06.min_eigen_value_threshold = min_eigen_value_threshold; // you should use preallocated keypoint_t array for(var i = 0; i < img.cols*img.rows, ++i) { corners[i] = new jsfeat.keypoint_t(0,0,0,0); } // perform detection // returns the amount of detected corners var count = jsfeat.yape06.detect(img:matrix_t, corners:Array, border = 5);
Yet Another Point Extractor by CVLab (Ecole Polytechnique Federale de Lausanne (EPFL), Switzerland).
var corners = [], image_width = img.cols, image_height = img.rows, radius = 5, pyramid_levels = 1; // for now only single level support // YAPE needs init before running detection jsfeat.yape.init(image_width, image_height, radius, pyramid_levels); // you should use preallocated keypoint_t array for(var i = 0; i < img.cols*img.rows, ++i) { corners[i] = new jsfeat.keypoint_t(0,0,0,0); } // perform detection // returns the amount of detected corners var count = jsfeat.yape.detect(img:matrix_t, corners:Array, border = 4);
Oriented and Rotated BRIEF. [for more info see: http://en.wikipedia.org/wiki/ORB_(feature_descriptor)]
var corners = []; // jsfeat.keypoint_t Array var cols = 32; // 32 Bytes / 256 BIT descriptor var rows = num_corners; // descriptors stored per row var descriptors = new jsfeat.matrix_t(cols, rows, jsfeat.U8_t | jsfeat.C1_t); jsfeat.orb.describe(img_u8:matrix_t, corners:Array, num_corners, descriptors:matrix_t);
Calculates an optical flow for a sparse feature set using the iterative Lucas-Kanade method with pyramids.
/* prev_pyr - previous frame 8-bit pyramid_t curr_pyr - current frame 8-bit pyramid_t prev_xy - Array of 2D coordinates for which the flow needs to be found curr_xy - Array of 2D coordinates containing the calculated new positions count - number of input coordinates win_size - size of the search window at each pyramid level max_iter - stop searching after the specified maximum number of iterations status - each element is set to 1 if the flow for the corresponding features has been found overwise 0 eps - stop searching when the search window moves by less than eps min_eigen_threshold - the algorithm calculates the minimum eigen value of a 2x2 normal matrix of optical flow equations, divided by number of pixels in a window; if this value is less than min_eigen_threshold, then a corresponding feature is filtered out and its flow is not processed, it allows to remove bad points and get a performance boost */ jsfeat.optical_flow_lk.track(prev_pyr:pyramid_t, curr_pyr:pyramid_t, prev_xy:Array, curr_xy:Array, count, win_size, max_iter = 30, status:Array = null, eps = 0.01, min_eigen_threshold = 0.0001);
The object detector initially proposed by Paul Viola and improved by Rainer Lienhart.
/* Evaluates a Haar cascade classifier at a specified scale int_sum - integral of the source image int_sqsum - squared integral of the source image int_tilted - tilted integral of the source image int_canny_sum - integral of canny source image or undefined width - width of the source image height - height of the source image scale - image scale classifier - haar cascade classifier rects - rectangles representing detected object */ var rects:Array = jsfeat.haar.detect_single_scale(int_sum:Array, int_sqsum:Array, int_tilted:Array, int_canny_sum:Array, width, height, scale, classifier);
/* Evaluates a Haar cascade classifier at all scales int_sum - integral of the source image int_sqsum - squared integral of the source image int_tilted - tilted integral of the source image int_canny_sum - integral of canny source image or undefined width - width of the source image height - height of the source image classifier - haar cascade classifier scale_factor - how much the image size is reduced at each image scale scale_min - start scale rects - rectangles representing detected object */ var rects:Array = jsfeat.haar.detect_multi_scale(int_sum:Array, int_sqsum:Array, int_tilted:Array, int_canny_sum:Array, width, height, classifier, scale_factor = 1.2, scale_min = 1);
/* Groups the object candidate rectangles rects - input candidate objects sequence min_neighbors - Minimum possible number of rectangles minus 1, the threshold is used in a group of rectangles to retain it */ var rects:Array = jsfeat.haar.group_rectangles(rects:Array, min_neighbors = 1);
The original paper refers to: YEF∗ Real-Time Object Detection, Yotam Abramson and Bruno Steux.
/* This step needed only once to create local copy of features to prevent multiple Array relocation during detection */ jsfeat.bbf.prepare_cascade(cascade); /* Build image pyramid using canvas drawImage src - source grayscale matrix_t (U8_t|C1_t) min_width - minimum width to scale pyramid to min_height - minimum height to scale pyramid to interval - number of original scale levels in pyramid */ var img_pyramid:pyramid_t = jsfeat.bbf.build_pyramid(src, min_width, min_height, interval = 4); /* Run detection img_pyramid - pyramid_t from build_pyramid method cascade - cascade data */ var rects:Array = jsfeat.bbf.detect(img_pyramid:pyramid_t, cascade); /* Groups the object candidate rectangles rects - input candidate objects sequence min_neighbors - Minimum possible number of rectangles minus 1, the threshold is used in a group of rectangles to retain it */ var rects:Array = jsfeat.bbf.group_rectangles(rects:Array, min_neighbors = 1);


{{payload.pipeline ? 'Edit' : 'New'}} Process
Please fill nameStages{{stage.value.name}}Name *Please fill nameProbability *Please fill probabilityDelete {{data.stage.name}} stage
There are no deals in this stage right now. 0" style="display: block; margin-bottom: 0.5rem; font-weight: 600;">Select another stage to move all deals before remove stage 0">
{{s.name}} {{s.id === data.stage.id ? '(Current)' : ''}}Saved changes Are you sure you wish to save and hide modal?You have unsaved changes Are you sure you wish to hide modal?Remove pipeline Are you sure you wish to remove this pipeline?


Sent! Your Audit request has been sent for review.
Heads Up! Your Audit request has already been approved, no point in re-applying.
Sabar la! Your Audit Request is still pending, please be patient.
Oops! Your Audit Request submission failed, change some few things and try again
Sorry! We have trouble processing your request now, please try again later
Yay! And your CE/CT course remark has been noted!
Unfortunately! We cannot seem to process your CE/CT course remark right now
We advise that you contact your mentor directly for further instructions.


If no update, checking event(status is 2) and noupdate(status is 1) will be invoked.
If there are updates, it will behave the same as the first visit: downloading(status is 3),progress(status is 3), updateready(status is 4).
If status is not 4 (UPDATEREADY), an exception will be thrown
FALLBACK:
Disable the network connection, you should see that the FALL BACK IMAGE OFFLINE characters on the light house image.
NETWORK:


Client Name
Address
Select one
Program
Select one
Your Initials
Lease Enforcement
Select one
Warning
30/14
Glenwood
Cottage Grove
Outreach
Issue Needing Attention
Smoking in the Unit
Housekeeping Issues
Guest Issues
Neighbor Complaint (see Notes)
Notes
Reponse
Select one
Blair
HIV A
Glenwood
Cottage Grove
Outreach


{% extends "base.html" %}
{% block title %}{{ title }}{% endblock %}
{% block content %}
Join us on April 15, 2016 at MIT.
The MIT Sustainability Summit is a student-led event that takes place every year during Earth Week on the MIT campus, drawing more than 350 attendees ranging from professionals to academics and students. The summit has emerged as a premier issue-driven event, featuring discussions with thought leaders and expert practitioners. The 2016 Sustainability Summit will focus on three key themes: disruptive product design and materials sourcing, transformative business models, and innovative new pipelines. Please stay tuned for more information about the speakers and the program.
Follow us
Keep up to date on your favorite social media.
Stay tuned
Sign up on our e-mail list to hear more about this year's speakers and future Summit events.
Get in touch
Got a question or comment? Do you have someone in mind that you'd like to see speak at the Summit? Or is your institution interested in being a sponsor? We'd like to know more! Send us an e-mail at sustainabilitysummit at mit dot edu.


| DOSE: |
2 Tbsp |
oral |
Nutmeg |
(powder / crystals) |
| |
2 Tbsp |
oral |
Nutmeg |
(powder / crystals) |
Yesterday I experimented with nutmeg for the first time after reading quite a few reports and articles on it. What I did was put 2 tablespoons in a cup and add water, I then proceeded to choke down this vile drink (made me gag and make some WILD faces). Within 20 minutes I began to feel light headed, dizzy, relaxed and in somewhat of a euphoric state, but it wore off much sooner than I had expected (from user experience reports I had assumed longer, more intense results) thinking I had taken too small a dose I proceeded to take another 2 tablespoon dose, again the same result, which intensified when i decided to go to sleep.
Upon waking up I had no hangover and felt quiet open and creative, I was also very talkative and may have annoyed many people, oh well. Along with this wired, hyper, talkative sense of alert readiness I also experienced a sense of hightened intelligence which allowed me to hold an intelligent conversation bringing me somewhat closer to someone I can now consider a 'personal' friend and believe she thinks the same way too. All this without fear of being ridiculed or made to look like a nut, thanks to a wonderful spice called nutmeg.
I do encourage at least one experience with nutmeg to everyone, but after reading all you can on it, and know the risks. I am going to discontinue use in hopes that I can live like this without aid of any substances, with a new sense of maturity and trust.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


MetaHeuristic
1.0
API Reference
General examples
MetaHeuristic
Docs
»
Index
Index
B
|
F
|
G
|
H
|
P
|
R
|
S
|
T
B
BinaryBlackHole (class in feature_selection.binary_black_hole)
F
feature_selection.binary_black_hole (module)
feature_selection.genetic_algorithm (module)
feature_selection.harmonic_search (module)
feature_selection.random_search (module)
feature_selection.simulated_anneling (module)
fit() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
fit_transform() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
G
GeneticAlgorithm (class in feature_selection.genetic_algorithm)
get_params() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
get_support() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
H
HarmonicSearch (class in feature_selection.harmonic_search)
P
plot_results() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
R
RandomSearch (class in feature_selection.random_search)
S
safe_mask() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
score() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
score_func_to_grid_search() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
set_params() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)
SimulatedAnneling (class in feature_selection.simulated_anneling)
T
transform() (feature_selection.binary_black_hole.BinaryBlackHole method)
(feature_selection.genetic_algorithm.GeneticAlgorithm method)
(feature_selection.harmonic_search.HarmonicSearch method)
(feature_selection.random_search.RandomSearch method)
(feature_selection.simulated_anneling.SimulatedAnneling method)


Disallows duplicate keys in object literals.
There is no good reason to define an object literal with the same key twice. This rule is now implemented in the TypeScript compiler and does not need to be used.
Not configurable.
"no-duplicate-key": true
{}


Starting at the root of the binary search tree,
determine how many disk accesses are required to reach
the selected (highlighted) node.
Assumptions:
1) Same color nodes are in the same disk block.
2) Consecutive reads from the same color block only count as one
disk access.
3) Consider only the direct path from the root to the
selected node.
4) There are no buffers. Every new block read has to be read from
disk and never from memory.
answer
Accessing the root node always takes one disk access.
Consecutively reading from same-color blocks counts as one disk access.
Don't forget to include the disk access for the last node (selected node) if the color is different from the parent node.


Owner: {{ owner }}
Birthdate: {{ owner.birthdate }}
Passport: {{ owner.passport_number }}
Address: {{ owner.address }}
Nationality: {{ owner.nationality }}


VERSION=89
CLUSTER=${CLUSTER?:CLUSTER must be set}
TOOL=/sw/apps/bioinfo/vep
mkdir -p $TOOL
cd $TOOL
mkdir -p $VERSION mf
VERSIONDIR=$TOOL/$VERSION
cd $VERSIONDIR
CLUSTERDIR=$VERSIONDIR/$CLUSTER
mkdir -p $CLUSTER src_$CLUSTER
cd src_$CLUSTER
wget https://github.com/Ensembl/ensembl-tools/archive/release/${VERSION}.zip
unzip ${VERSION}.zip
cd ensembl-tools-release-${VERSION}/scripts/variant_effect_predictor/
No need to install DBD::mysql
within perl_modules/5.18.4
since this was already done for vep/82
.
Now back to vep. Create the cache directory.
CACHEDIR=/sw/data/uppnex/vep/${VERSION}
mkdir -p $CACHEDIR
module load perl/5.18.4
module load perl_modules/5.18.4
export PATH=$CLUSTERDIR/htslib:$PATH
export PERL5LIB=$CLUSTERDIR:$PERL5LIB
./INSTALL.pl -d $CLUSTERDIR -t -c $CACHEDIR
NOTE: running the INSTALL.pl script will generate a question:
Have you
1. added /sw/apps/bioinfo/vep/87/milou to your PERL5LIB environment variable?
2. added /sw/apps/bioinfo/vep/87/milou/htslib to your PATH environment variable?
(y/n)
The two export
lines above do that, so answer y
.
Note: the installer claimed to be configured to install v88 of the Ensembl API. We are installing VEP/89, not sure it matters.
Onwards, according to the instructions for 87: It will install BioPerl and htslib and maybe a few other things for itself as parts of the Ensembl API for VEP only. Seems to want its own versions, so just let it continue. It will also run some tests, which is nice.
It will later ask if you want to install cache files, fasta files, and others. On milou, answer y
, and then 0
to install all choices. This part takes a long time. If there is an error/message during cache installation (the first step), then it will not ask to install Fasta or plugins; if this happens, then rerun the INSTALL script, saying n
to the cache installation but y
to the rest. FASTA will probably not be installed (because of the cache installation) and install plugins, but not data. That will be up to the users of the plugins. One uses ExAC, which we do have as a database.
If on rackham, answer n
to all cache installation questions.
Copy over the scripts.
cd $VERSIONDIR/src_$CLUSTER/ensembl-tools-release-${VERSION}/scripts/variant_effect_predictor/
mkdir $CLUSTERDIR/scripts
rsync -rPlt * $CLUSTERDIR/scripts/
Ensure all can find the proper perl via #!/usr/bin/env perl
line to and (unlike earlier VEP versions) do not deactiveate the install script so users can install their own to their own project directories.
cd $CLUSTERDIR/scripts
vi *.pl


{% extends "base_layout.html" %} {% block head_scripts %} {% endblock %} {% block page_detail %} {% include "show_flashed_messages.html" %} Upload Image Upload your own image and see what our classifier thinks. Image must be a jpg and cannot exceed 3 MBs. Error classifying image. {% if result %} Result {% endif %} {% endblock %} {% block page_end_scripts %} {% endblock %}
Upload your own image and see what our classifier thinks.


THE GOOD SON A film review by Scott Renshaw Copyright 1993 Scott Renshaw
Starring: Macaulay Culkin, Elijah Wood, Wendy Crewson, Daniel Hugh Kelly. Screenplay: Ian McEwan. Director: Joseph Ruben. Reviewed by Scott Renshaw.
I have a confession to make which may compromise my integrity as a reviewer (if that isn't an oxymoron): I wanted THE GOOD SON to be horrible. *Really* horrible. I've grown so tired of Macaulay Culkin's yelping mug and the highly-publicized power grabs by his manager-dad, that I wanted him to be wholly responsible for a colossal failure. Well, THE GOOD SON isn't horrible; it's merely mediocre, which may be worse. At least a truly awful thriller can provoke campy laughs. All THE GOOD SON provoked in me was boredom.
THE GOOD SON is the story of Mark (Elijah Wood), a young boy who has just lost his mother to cancer and is guilt-ridden because he promised her he wouldn't let her die. When his father (David Morse) is forced to leave the country on business soon after Mom's death, Mark is taken across country to stay with his Uncle Wallace (Daniel Hugh Kelly) and Aunt Susan (Wendy Crewson) in New England. There Mark soon becomes fast friends with their son, his cousin Henry (Macaulay Culkin). All seems well until Henry begins to pull some rather destructive pranks. As Mark becomes more and more frightened of Henry, Henry becomes more and more malevolent, until Mark begins to fear that Henry's directionless mayhem might be turned on his own family.
I had very little problem with the basic premises of THE GOOD SON. I could accept that a child might be pushed over the edge into pathological behavior by a trauma (the drowning of Henry's infant brother); I could accept that parents still in shock over the death of one child might be completely unwilling to believe that one of their other children is a creep, even in the face of evidence. The problems with THE GOOD SON are almost entirely in the execution. The film waits far too long, nearly a third of its running time, before introducing us to Henry, setting up Mark's guilt and showing off desert scenery. By then, it's so late in the game that Henry has to get too crazy too soon. There's no time for the menace to build slowly, or for the early pranks to be tame enough so that Mark could get a bit caught up in them himself. Ian McEwan's script seemed to need another draft and earlier plot points.
The performances are also a big problem. Elijah Wood is fine, a good young actor forced to spend most of this film making his eyes as wide as possible. His relatives, however, don't fare as well. I said that I accepted the idea of oblivious parents in shock, but Wendy Crewson and Daniel Hugh Kelly don't play Susan and Wallace as shocked. We're never specifically told how long it has been since the death of the other son, and that would have helped. As it is, Wallace seems perfectly recovered, while Susan appears simply melancholy, striking Bronte-esque poses on a seaside promontory.  This is also parly the fault of a performance by Culkin lacking in subtlety. Instead of the straightforward tone of a true sociopath, Culkin adopts the wide-eyed, solemn, sing-song style any parent would instantly recognize as a child lying. It's even harder to believe he's able to convince a family therapist. To give him his due, he does a decent job of playing the devilish prankster; that is, after all, what he was in the HOME ALONE movies. It's homicidal that he hasn't quite mastered.
If there's one surprising culprit in THE GOOD SON's failings, it's director Joseph Ruben. After THE STEPFATHER and SLEEPING WITH THE ENEMY, you'd think he'd have the "psychotic extended family" thing down cold. But THE GOOD SON goes everywhere you expect it to go, exactly when you expect it. It's a competent but cut-and-paste directing job, providing the minimum recommended allowance of suspense. I never groaned out loud, but I never felt any real tension, either.
THE GOOD SON is not a complete failure. It's the kind of thriller where you might jump once, then wonder why you fell for *that* old bit. And as reluctant as I am to admit it, Culkin shows that he might be more than a one-trick pony given a little seasoning. It just might be a good idea if his next trick is something original.
On the Renshaw scale of 0 to 10 pranks: 5.
-- Scott Renshaw Stanford University Office of the General Counsel
.
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


Bar
Foo
1
2
click me
hello
x-project: [
]
x-reproject: [
]
x-rereproject: [
]
projected
projected with id that needs escaping
Local dom without insertion point.
Elements without test attribute
Elements with test attribute
simple
Attr1
Attr2
Foo: [
] Bar: [
]
[
]
[
]


Introduction
IFA is a library for Interative Flow Analysis of computer programs.
This software is for compiler developers and program analysis
researchers. It is based on work initially done by the author at
the University of Illinois Champaign-Urbana. Papers describing this
work can be found at
papers.
This implementation was begun as part of the
Chapel programming
language.
These pages are under construction. For more information, please contact the author
directly.
Features
- Iterative Flow Analysis
- Time/Space Efficient
- Comes with full source
- Written in C++
- Open Source Licence (MIT)
Documentation
Man page for ifa
Manual
FAQ
Download
Source (git)
Contact the author: jplevyak at gmail


{% extends 'common/base.html' %} {% block title %}Welcome aboard{% endblock %} {% block content %}
Bundles are related models, URLs and views.
Create one with the command shake add yourbundle
.
Routes are set up in urls.py
Your bundle's internal routes are defined in yourbundle/__init__.py
Run “python manage.py syncdb
” to create your database. If you already've a database created, edit the SQLALCHEMY_URI setting in settings/dev.py with your username and password.


Find Your Zodiac
Choose your birthday
Show Me!
“Millionaires don't use Astrology, billionaires do.”
― J.P. Morgan


Current graph:
Untitled
Save
Load
Randomize
Clear
Make complete
Information:
Number of nodes:
Number of edges:
Nodes powers:
Incidence matrix:
Add new node
x:
y:
Create
Add new edge
Source:
Target:
Oriented
Create
Selected node:
Power:
Label:
Data:
Choose file
No file
Color:
Input color
Yellow
Red
Green
Blue
Purple
Shape:
Choose shape
Circle
Diamond
Square
Cross
Star
Equilateral
Drop
Selected edge:
Color:
Choose color
Yellow
Red
Green
Blue
Purple
Drop
⤺ Hide me! ⤺
Search
Find shortest path
from:
to:
Find path
Find all paths
from:
to:
Find all paths
⤺ Show me! ⤺


Man pleads not guilty in murder of retired town official
SALEM, Mass. (AP) - A Massachusetts man accused of killing a retired town official has pleaded not guilty.
Leedell Graham, of Haverhill, pleaded not guilty to murder charges Thursday in Salem Superior Court in the beating death of 82-year-old Patsy Schena at his Groveland home on June 21.
The Salem News reports 48-year-old Graham was indicted by a grand jury on the murder charge, as well as counts of home invasion and breaking and entering to commit a felony in October.
Schena was the town’s retired building inspector and police say he and Graham knew each other through “business dealings” unrelated to the town.
Prosecutors asked for Graham to continue being held without bail and his attorney did not object but asked the judge to issue the order without prejudice.
Police say this was the town’s first murder since 1992.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Ghost allows you to inject code to the top and bottom of your template files without editing them. This allows for quick modifications to insert useful things like tracking codes and meta data
Blog Header
Code here will be injected to the {{ghost_head}}
helper at the top of each page of your blog


Sometimes I’m amazed that I spend my days creating magic and fantasy and that people buy it. It’s like connecting with the inner child in me; I’m just having a great time, and I’m chuckling to myself that this is really happening, that I can do this with my life.
A designer, like an archaeologist or geologist; researches, uncovers and adds context to precious, overlooked treasures by digging deep beneath the surface.
See portfolioIf the reader notices the interior page design of a book – even if he or she likes what they see – I’ve missed, because I distracted them from their reading.
The space between an idea and a concept is your lips. If you can’t say it out loud you can’t do it.
The way a team plays as a whole determines its success. You may have the greatest bunch of individual stars in the world, but if they don’t play together, the club won’t be worth a dime.
I like jumping back and forth between a few different things to let my subconscious chew on one problem while my conscious works on something else.
I like jumping back and forth between a few different things to let my subconscious chew on one problem while my conscious works on something else.
I like jumping back and forth between a few different things to let my subconscious chew on one problem while my conscious works on something else.
If the reader notices the interior page design of a book – even if he or she likes what they see – I’ve missed, because I distracted them from their reading.


Issac Newton(1643-1727) made many profound contributions to science. He was an important figure in the Scientific Revolution. He worked on optics. He discovered universal gravitation. He also shares credit for inventing calculus.
In his work Philosophiæ Naturalis Principia Mathematica, Newton formulated his three laws of motion that predict how forces cause acceleration. These laws make up the foundation of classical physics.
Newton's First Law: Inertia
"An object either remains at rest or continues to move at a constant velocity, unless acted upon by a net external force."
An object will not accelerate unless it is acted on by unbalanced forces.
All matter has inertia. Inertia is the resistance of any physical object to any change in velocity, or acceleration. An object with a large mass, has a large inertia, and a high resistance to acceleration.
solution
Friction slows things down. As air particles strike a fast moving object the object slows down and the air speeds up. This spreads out the movement, but the movement is still there.
Newton's Second Law: Force
"The vector sum of the external forces F on an object is equal to the mass m of that object multiplied by the acceleration vector of the object."
$$\sum F=ma$$
\( F \) = force [N, Newtons, kg m/s²]
vector
a push or a pull
\(m\) = mass [kg, kilogram]
the measure of an object's resistance to acceleration
\(a\) = acceleration [m/s²]
vector
the change in velocity every second
\( \sum \) = The greek letter Sigma represents a summation of numbers. It means add up all the forces to get a net force.
$$\sum F=F_{1}+F_{2}+F_{3}+...$$If there was a 5 N force to the left and a 20 N force to the right we could get the net force by adding them. Force is a vector, so the left force should be negative.
$$\sum F= - 5 \, \mathrm{N} + 20 \, \mathrm{N} $$ $$\sum F= 15 \, \mathrm{N}$$solution
solution
$$ \text{Vectors pointed down or left are negative.}$$ $$\sum F=ma$$ $$-2000+1900=(100)(a)$$ $$-100=(100)(a)$$ $$-1 \mathrm{\tfrac{m}{s^{2}}}= a$$ $$ \text{The boat will accelerate to the left.}$$ $$ u = 0 $$ $$ \Delta x = ?$$ $$ \Delta t = 6\mathrm{s}$$ $$ \Delta x = u\Delta t+ \tfrac{1}{2} a \Delta t^{2}$$ $$ \Delta x = (0)(6)+\tfrac{1}{2} (-1)(6)^{2}$$ $$ \Delta x = \tfrac{1}{2} (-1)(6)^{2}$$ $$ \Delta x = -18 \, \mathrm{m}$$ $$ \text{The boat will move 18 meters to the left.}$$Play around with the net force simulation to get a feeling for how adding force vectors produces acceleration.
Question: Could the tug of war be moving left, but have a net force to the right?
solution
An object could be moving in one direction and have a force in the opposite direction if it was slowing down.
To test this out, add one person to the left. Click go. Wait a second. Add two on the right.
Question: On the motion mode, find the mass of the gift.
hint
We need to solve a 1-D motion problem with constant accelerate. We can record the initial and final velocities if you check the "values" and "speed" boxes. Get a stopwatch to record the time elapsed.
After we use a kinematics equation to solve for acceleration, we can use Newton's 2nd law to calculate the mass.
solution
I applied a 10N force for 10 seconds and recorded the time and velocities.
solution
$$ \text{m is constant}$$ $$ \text{F and a are directly proportional}$$ $${\Uparrow \atop F} {\atop =} { \atop m} {\Uparrow \atop a} $$ $$ \text{Increasing F will increase a}$$solution
$$ \text{F is constant}$$ $$ \text{m and a are inversely proportional}$$ $${ \atop F} {\atop =} { \Downarrow \atop m} {\Uparrow \atop a} $$ $$ \text{doubling m will half a}$$ $$ a = 1 \, \mathrm{\tfrac{m}{s^2}}$$Newton's Third Law:
Equal and Opposite Force Pairs
"When one body exerts a force on a second body, the second body simultaneously exerts a force equal in magnitude and opposite in direction on the first body."
$$F_1 = -F_2$$
If you push on something it will push back with the same force, but in the opposite direction. Forces always come in equal, but opposite pairs.
Most of the time force pairs come from objects in contact, but even non-contact forces, like gravity, still obey this law.
solution
The force the ground applies is equal and opposite to the force you apply on the ground. The magnitude is 1000 N. The direction is up.
solution
When a fist is punching a face, the face is also punching the fist. That's deep...
Anyways, the force is equal and opposite. The magnitude is 140 N.
hint
Calculate the force the water bottle feels when it accelerates at 40 m/s². Plug the negative value of that force in as the force you feel.
solution
The force the water bottle feels is equal and opposite to the force you feel.


{% extends 'layout.html' %} {% block title %}{% endblock %} {% block content %} {{ title }} {{ callToAction }} Insert your Favorite Album View Full List Albums
{{ callToAction }}
Insert your Favorite Album View Full List Albums
{{ band.description }}


Shuts down a running a distributed TPU system.
tf.compat.v1.tpu.shutdown_system(job=None)
job
: The job (the XXX in TensorFlow device specification /job:XXX) that
contains the TPU devices that will be shutdown. If job=None it is
assumed there is only one job in the TensorFlow flock, and an error will
be returned if this assumption does not hold.


{% extends 'blog/base.html' %} {% block content %}
We've emaild you instructions for setting your password, if an account exists with the email you entered. You should receive them sortly


ISO-INFO
Section: User Commands (1)Updated: August 2010
Index Return to Main Contents
NAME
iso-info - manual page for iso-infoSYNOPSIS
iso-info OPTION...- Shows Information about an ISO 9660 image.
DESCRIPTION
- -d, --debug=INT
- Set debugging to LEVEL
- -i, --input[=FILE]
- Filename to read ISO-9960 image from
- -f
- Generate output similar to 'find . -print'
- -l, --iso9660
- Generate output similar to 'ls -lR'
- --no-header
- Don't display header and copyright (for regression testing)
- --no-joliet
- Don't use Joliet-extension information
- --no-rock-ridge
- Don't use Rock-Ridge-extension information
- --no-xa
- Don't use XA-extension information
- -q, --quiet
- Don't produce warning output
- -V, --version
- display version and copyright information and exit
Help options:
- -?, --help
- Show this help message
- --usage
- Display brief usage message
AUTHOR
Rocky Bernstein<EMAIL_ADDRESS>Copyright © 2003, 2004, 2005, 2007, 2008 R. BernsteinThis is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Have driver: GNU/Linux ioctl and MMC driver Have driver: cdrdao (TOC) disk image driver Have driver: bin/cuesheet disk image driver Have driver: Nero NRG disk image driver No CD-ROM device found.
SEE ALSO
cd-info(1) for information about an ISO-9660 image. cd-read(1) to read portions of an ISO 9660 image.
Index
This document was created by man2html, using the manual pages.
Time: 05:29:05 GMT, December 24, 2015


Starting to know the world of HTML, CSS
Started to learn about website programming properly from Mr Dudy (Malaysian Top Freelancer)
Starting to know the proper ways of programming using HTML5
Learn the awesomeness of CSS3, Java Script, JQuery
We can make it
We Do Mobile
We Do Blog of Wordpress
Lead Designer
Lead Marketer
Lead Developer
Lorem ipsum dolor sit amet, consectetur adipisicing elit. Aut eaque, laboriosam veritatis, quos non quis ad perspiciatis, totam corporis ea, alias ut unde.


Your username and password are the same no matter how you check your mail:
| Username: | Your whole email address. |
|---|---|
| Password: | Your mail password. |
Webmail lets you check your email from any web browser. Your webmail site is:
When you set up your email on your phone, desktop, or other device, you will be asked to choose a protocol.
This method is preferred on Android devices but is not available on iOS devices.
Your mail server is {{hostname}}. Use the following settings when prompted:
| Protocol | Port | Options |
|---|---|---|
| IMAP | 993 | SSL |
| SMTP | 587 | STARTTLS (“always” or “required”, if prompted) |
In addition to setting up your email, you’ll also need to set up contacts and calendar synchronization separately.
On iOS devices and devices on this compatibility list, set up your mail as an Exchange or ActiveSync server. Use these settings when prompted:
| Server | {{hostname}} |
|---|---|
| Options | Secure Connection |
Your device should also provide a contacts list and calendar that syncs to this box when you use this method.
Your box using a technique called greylisting to cut down on spam. Greylisting works by delaying mail from people you haven’t received mail from before for up to about 10 minutes. The vast majority of spam gets tricked by this. If you are waiting for an email from someone new, such as if you are registering on a new website and are waiting for an email confirmation, please give it up to 10-15 minutes to arrive.
Every incoming email address also receives mail for +tag
addresses. If your email address is<EMAIL_ADDRESS>, you can also accept mail at<EMAIL_ADDRESS>. Use this as a fast way to create aliases or to segment incoming mail for your own filtering rules.
Your box sets strict email sending policies for your domain names to make it harder for spam and other fraudulent mail to claim to be you. Only this machine is authorized to send email on behalf of your domain names. If you use any other service to send email as you, it will likely get spam filtered by recipients.


Wolves star Raul Jimenez shines for Mexico once again
Wolves striker Raul Jimenez is heading back to Compton after keeping up his immense form with Mexico.
by Joe EdwardsAfter scoring twice in a 3-0 victory over Panama on Saturday, Jimenez came on in the 71st minute and set up Uriel Antuna against Bermuda to win the game 2-1 in stoppage-time – in the early hours of this morning.
The triumph saw Mexico end the Concacaf Nations League group stage with a perfect record of four wins from four.
Romain Saiss captained Morocco as they won 3-0 in Burundi in African Cup of Nations qualifying on Tuesday.
That put Saiss & Co joint top of the group, with Mauritania.
Patrick Cutrone played the full 90 minutes for Italy U21s in a 6-0 rout against Armenia – but did not get on the scoresheet after scoring twice against Iceland at the weekend.
Everton striker Moise Kean was at the double as Italy moved to second in their Euro qualifying group.
Belgium enjoyed a 6-1 success against Cyprus, but Leander Dendoncker was an unused substitute for Roberto Martinez's side. Former Villa centre forward Christian Benteke bagged a brace for Belgium.
Ruben Vinagre and Pedro Neto were not involved as Portugal U21s won 3-2 in Norway.
The Wolves duo pulled out of the squad early with minor knocks and will be working at Compton as they look to play a part against Bournemouth, back in league action on Saturday.


Assess how much of the error in prediction is due to lack of model fit.
ols_pure_error_anova(model, ...)
| model | An object of class |
|---|---|
| ... | Other parameters. |
ols_pure_error_anova
returns an object of class
"ols_pure_error_anova"
. An object of class "ols_pure_error_anova"
is a
list containing the following components:
lack of fit sum of squares
pure error sum of squares
regression sum of squares
error sum of squares
total sum of squares
regression mean square
error mean square
lack of fit mean square
pure error mean square
f statistic
lack of fit f statistic
p-value of f statistic
p-value pf lack of fit f statistic
tibble containing data for the response and predictor of the model
regression sum of squares degrees of freedom
error sum of squares degrees of freedom
lack of fit degrees of freedom
pure error degrees of freedom
data.frame; contains computed values used for the lack of fit f test
character vector; name of response variable
character vector; name of predictor variable
The residual sum of squares resulting from a regression can be decomposed into 2 components:
Due to lack of fit
Due to random variation
If most of the error is due to lack of fit and not just random error, the model should be discarded and a new model must be built.
The lack of fit F test works only with simple linear regression. Moreover, it is important that the data contains repeat observations i.e. replicates for at least one of the values of the predictor x. This test generally only applies to datasets with plenty of replicates.
Kutner, MH, Nachtscheim CJ, Neter J and Li W., 2004, Applied Linear Statistical Models (5th edition). Chicago, IL., McGraw Hill/Irwin.
model <- lm(mpg ~ disp, data = mtcars) ols_pure_error_anova(model)#> Lack of Fit F Test #> ----------------- #> Response : mpg #> Predictor: disp #> #> Analysis of Variance Table #> ---------------------------------------------------------------------- #> DF Sum Sq Mean Sq F Value Pr(>F) #> ---------------------------------------------------------------------- #> disp 1 808.8885 808.8885 314.0095 1.934413e-17 #> Residual 30 317.1587 10.57196 #> Lack of fit 25 304.2787 12.17115 4.724824 0.04563623 #> Pure Error 5 12.88 2.576 #> ----------------------------------------------------------------------


---
layout: post
title: iDuprey.com Geek Update
categories: []
tags: []
status: publish
type: post
published: true
meta:
_original_post_id: ''
_original_import_author: John Duprey
author:
---
Its been a while since I've posted to my journal. A lot is going on and with
the new addition in our house, and
a dog, its hard to find time for a lot of extraneous activities. Somehow I managed to squeak in some quality geek time the last few days.
It took me a while, but I finally updated
iDuprey.com server software to the latest
Gentoo Linux with
2.6 kernel. I had a few snags with portage, but finally wrapped up the kernel build yesterday.
I upgraded the the iDuprey.com photo album software to the latest stable version. The latest pictures of
Emma are up too.
In preparation for upgrading my desktop/dev/test linux box to Gentoo or Suse, I haven't decided, I migrated my Subversion source repositories over to iDuprey.com. I've exposed the code to the web:
http://www.iDuprey.com/websvn/ (*gulp*) Most of the code consists of half baked ideas (crap), but kamikaze is actually useful. Kamikaze-QSCM (
http://kamikaze-qscm.tigris.org) is my first real attempt at an open source project.
I made a half hearted attempt at learning
CSS. I toyed with the idea of improving the
iDuprey.com launch page using a pure CSS/dhtml/javascript design. As you can see
here, I didn't get too far. :)
I've been actively populating my bookmark collection online using now using
http://del.icio.us/. You can marvel at my collection here:
http://del.icio.us/jduprey.


Can you tell which rabbit doesn't have a twin in this viral brainteaser?, Business Insider - Business Insider Singapore
by Talia Lakritz- Hungarian artist Gergely Dudás creates mind-boggling brainteasers, often containing hidden objects or details.
- In his latest illustration, there are 12 pairs of rabbits with matching patterns and one who doesn’t have a twin.
- Visit Insider’s homepage for more stories.
Hungarian artist Gergely Dudás creates mind-boggling brainteasers, often containing hidden objects or details, and challenges the internet to find them. In past drawings, he’s hidden a mouse among mushrooms, a penguin among toucans, and a heart among flowers.
He’s also released three books of brainteasers: one of holiday puzzles called “Bear’s Merry Book of Hidden Things,” a Halloween-themed book called “Bear’s Spooky Book of Hidden Things,” and his latest, “Bear’s Springtime Book of Hidden Things.”
In his latest illustration, Dudás drew 12 pairs of rabbits with matching patterns on their ears, faces, and bellies – but one rabbit doesn’t have a twin. Can you find the odd one out?
Take a look at the brainteaser below.
Did you find the rabbit without a twin?
It’s there somewhere.
Keep looking.
If you’re stuck, here’s a hint.
It’s in the fourth row down.
If you still don’t see it, the answer is below.
Last chance to turn back!
Here it is:
No other rabbit has a darker yellow pattern on both of its ears and around its nose.