WhereRU lets you chat with and see the current locations on a map of anyone else currently in the same map group. Join or create a new map group name and share it with your friends. If they join the same map group, you can see each other's current location and group messages. The locations on the map will update automatically whenever anyone moves. You can exit a map group at any time and your location will no longer be visible by others. Send feedback
WhereRU is great for families on the go, group events, sports teams, amusement park visits, truckers, camping, boating, traveling and adventure groups, or anytime you are with a bunch of people and you want to be able to find each other easily. Send feedback
When you create a new map group other WhereRU app users can join it. You just need to tell them the name of your map group. Remember, anyone can join any map group, so if you want your group to be private, create a unique map group name that others would not guess.
Send feedback


enter the height
enter the base
enter the hypothemus
The types of triangles include:
Equilateral triangle all three sides are equal
Isosceles triangle: with two sides equal
Scalene triangle: with three unequal sides


| Home | Trees | Indices | Help |
|
|---|
|
|
This is a top level package, hosting the entire CSB test framework. It is divided into several major parts:
/csb/test/data
(not a package)
/csb/test/app.py
This module, csb.test, contains all the glue-code functions, classes and decorators you would need in order to write tests for CSB.
Config is a common config object shared between CSB tests. Each config instance contains properties like:
Each Config
provides a convenient way to retrieve files from
/csb/test/data
. Be sure to check out Config.getTestFile and Config.getPickle. In case you need a temp file, use
Config.getTempStream or have a look at csb.io.TempFile
and csb.io.TempFolder.
All test data files should be placed in the data
folder. All test modules must be placed in the root package:
csb.test.cases. There is a strict naming convention for test modules:
the name of a test module should be the same as the name of the CSB
API package it tests. For example, if you are writing tests for
csb/bio/io/__init__.py
, the test module must be
csb/test/cases/bio/io/__init__.py
.
csb.test.cases
is the root package of all test modules
in CSB.
Writing a test is easy. All you need is to import csb.test and then create your own test cases, derived from csb.test.Case:
>>> import csb.test >>> @csb.test.unit class TestSomeClass(csb.test.Case): def setUp(self): super(TestSomeClass, self).setUp() # do something with self.config here...
In this way your test case instance is automatically equipped with a reference to the test config, so your test method can be:
>>> @csb.test.unit class TestSomeClass(csb.test.Case): def testSomeMethod(self): myDataFile = self.config.getTestFile('some.file') self.assert...
The "unit" decorator marks a test case as a collection of unit tests. All possibilities are: csb.test.unit, csb.test.functional, csb.test.custom, and csb.test.regression.
Writing custom (a.k.a. "data", "slow", "dynamic") tests is a little bit more work. Custom tests must be functions, not classes. Basically a custom test is a function, which builds a unittest.TestSuite instance and then returns it when called without arguments.
Regression tests are usually created in response to reported bugs. Therefore, the best practice is to mark each test method with its relevant bug ID:
>>> @csb.test.regression class SomeClassRegressions(csb.test.Case) def testSomeFeature(self) """ @see: [CSB 000XXXX] """ # regression test body...
if __name__ == '__main__': csb.test.Console() # Discovers and runs all test cases in the module
Test discovery is handled by test builders
and a test
runner app
. Test builders are subclasses of AbstractTestBuilder. For every test type (unit,
functional, regression, custom) there is a corresponding test
builder. AnyTestBuilder is a special builder which scans for
unit, regression and functional tests at the same time.
Test builder classes inherit the following test discovery methods:
loadTests
- load tests from a test namespace.
Wildcard namespaces are handled by loadAllTests
loadAllTests
- load tests from the given namespace,
and from all sub-packages (recursive)
loadFromFile
- load tests from an absolute file name
loadMultipleTests
- calls loadTests
for
a list of namespaces and combines all loaded tests in a single
suite
Each of those return test suite objects, which can be directly executed with python's unittest runner.
Much simpler way to execute a test suite is to use our test app
(csb/test/app.py
), which is simply an instance of csb.test.Console:
$ python csb/test/app.py --help
The app has two main arguments:
csb.test.cases.bio.io.* # io and sub-packages csb.test.cases.bio.utils # only utils . # current module
In addition to running the app from the command line, you can run it also programmatically by instantiating csb.test.Console. You can construct a test console object by passing a list of test namespace(s) and a test builder class to the Console's constructor.
Follow these guidelines when making changes to the repository:
Warning: for compatibility reasons do NOT import and use the unittest module directly. Always import unittest from csb.test, which is guaranteed to be python 2.7+ compatible.
| Submodules | |
|
| Classes | |
|
AbstractTestBuilder This is a base class, defining a test loader which exposes the loadTests method.
|
|
|
AnyTestBuilder Build a test suite of cases, marked as either unit, functional or regression tests. |
|
| Attributes | |
|
Case Base class, defining a CSB Test Case. |
|
|
Config General CSB Test Config. |
|
|
Console Build and run all tests of the specified namespace and kind. |
|
|
CustomTestBuilder Build a test suite of cases, marked as custom tests. |
|
|
FunctionalTestBuilder Build a test suite of cases, marked as functional tests. |
|
| InvalidNamespaceError | |
|
RegressionTestBuilder Build a test suite of cases, marked as regression tests. |
|
|
UnitTestBuilder Build a test suite of cases, marked as unit tests. |
| Functions | |||
|
|||
|
|||
|
|||
|
|||
|
| Variables | |
__package__ =
|
| Function Details |
A function decorator, used to mark functions which build custom (dynamic) test suites when called.
|
A class decorator, used to label functional test cases.
|
A class decorator, used to label regression test cases.
|
Mark a test case or method for skipping.
|
A class decorator, used to label unit test cases.
|
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Tue Jul 4 20:19:04 2017 | http://epydoc.sourceforge.net |


Employee Information
Name
E-mail
Job Role
Data is updated every 15 minutes.
Ethan Neff
<EMAIL_ADDRESS>Programmer
Jake Hawk
<EMAIL_ADDRESS>Freelancer
Steven Tyler
<EMAIL_ADDRESS>Designer
Michael Jackson
<EMAIL_ADDRESS>Singer


@mfairchild365
"The power of the Web is in its universality. Access by everyone regardless of disability is an essential aspect"
Tim Berners-Lee
Many different kinds. To name just a few:
About 8% of all males are colorblind (source)
By age 80, 60% of all Americans have Cataracts (source)
Most common: age related. 1.75 million individuals in the United States (source)
A screen reader demo by Laura Palmaro (Google), check out the entire video "Quality, Equality, and Accessibility"
Hamburger icon: - uses code point 2630. How do you think a screen reader speaks this icon?
"trigram for heaven"
<button></button>
<button>

Open Menu
</button>
.icon-font-menu:before {
content: "\u2630";
}
.sr-only {
position: absolute !important;
top: -9999px !important;
left: -9999px !important;
}

Your first name
<input type="text" name="firstname" />

Image source: The movie Anchorman - DreamWorks
:focus { outline: 0; }
<input name="outoforder" tabindex="5" />

Don't use the title attribute. List of reasons why:
google
google
google
There is a huge range, and a lot of this is addressed at the content development level.
Aging affects nearly 100% of the population, including you at some point.
Image source: the movie UP - from Pixar
Web Content Accessibility Guidelines (WCAG) 2.0 is the most widely used standard. Use it. Don't make your own.
4 main principles, each broken into guidelines and then into techniques
Accessible Rich Internet Applications (ARIA) aims to make complex interactions accessible.
aria-hidden="true"
- content is hidden from ATaria-live="polite"
- announce content changes to AT as they happenrole="button"
- Make a {span} a button and accessible to AT

Tab #1

Tab #2

Tab #3

Tab #4

Tab 1

Tab 1

Tab 1

Tab 1

Tab1

Tab2

Tab3

Tab4

How can this be improved?
<!doctype html>

<meta charset="utf-8">
<title>a11y issues</title>

link 1

link 2

link 3

<form>
What is your name?

<input type="text" name="full-name" />

</form>

This is footer stuff

Avoid giving meaning to divs and spans where possible. Instead use native elements.

The above are considered Landmarks, allowing AT users to jump to sections of a page quickly.
Also, please use heading elements (eg.
) correcty (in order, don't skip).
Alt text can get complicated
display: none
?display: none
- hidden from everythingaria-hidden="true"
- hidden from just AT.visually-hidden
- hidden from just your eyesUse elements for what they were designed to do. If you must change how it works or how it looks, use JS and CSS. but make sure it is still accessible. If you go rogue, so will your code. You will have to worry about:
/


Adam Byram
Tech. Geekery. Photography. Lots of Random.
Blog
Archive
Menu
Blog
Archive
2013
My Thoughts on the Surface Pro
Mar 9
Tech
2012
Thoughts on the 13" MacBook Air
Jan 5
Tech
2011
Switching to Octopress
Dec 31
Tech
2010
iPhone 4 - Early Thoughts
Jun 28
Tech
Giving Tumblr a Try
Mar 14
Tech
2009
My AT&T U-verse Experience in Knoxville
Oct 28
Tech
Finished Mass Effect
Jul 3
Tech
Site Move in Progress
Feb 22
Tech
Top 5 Favorite Apps (for Mac)
Feb 18
Tech
2008
iPhone Apps
Jul 13
Tech
Ok, so I lied - Back to Mac & WinXP
Jun 17
Tech
Going Back to Vista After 3 Months of OS X
Jun 16
Tech
Thoughts on iPhone 2.0
Jun 15
Tech
First Thoughts on iPhone SDK
Apr 6
Tech
It's Not the Platform, It's the Data
Mar 27
Tech
New Addition to the Family - Bought a MacBook
Mar 27
Tech
2007
iPhone Thoughts - One Month Later
Oct 9
Tech
Windows Vista Woes
Sep 16
Tech
Amazon Unbox Update
Sep 9
Tech
Why I Purchased an iPhone
Sep 9
Tech
HOWTO: Installing iTunes 7.4/7.4.1 on Windows Vista Ultimate 64-bit
Sep 7
Tech
Robocopy - Microsoft's Little Gem
Sep 6
Tech
Nerd Test Results
Jul 6
Tech
Making the 64-bit Jump (w/ Windows XP Professional x64)
Jun 30
Tech
3 Reasons I Probably Won't Buy an iPhone
Jun 24
Tech


We have an interval that changes the color of the button from red to blue themes, Open the dialog to see the theme being inherited to the dialog and any component inside
red
blue


More from Garage
Temasek Lifesciences Accelerator launches incubator, to invest in startups
Temasek Lifesciences Accelerator launches incubator, to invest in startups
Fri, Nov 08, 2019 - 12:33 PM Claudia Chongchongkmc@sph.com.sg@ClaudiaChongBT 2 -min read Listen to this article
The Hatchery provides key incubation and operational support services, including access to 17,000 square feet co-working space and laboratories at TLA.
PHOTO: TEMASEK LIFESCIENCES ACCELERATOR Friday, November 8, 2019 - 12:33 Claudia Chong<EMAIL_ADDRESS>@ClaudiaChongBT 2 -min read Listen to this article
TEMASEK Lifesciences Accelerator (TLA) has launched a life sciences startup programme to incubate over 30 startups in the next five years.
TLA's incubator, called The Hatchery, provides access to mentorship and 17,000 square feet of co-working space and research facilities. Key facilities include laboratories, specialised wet labs, growth chambers, greenhouses, and animal and aquaculture research facilities.
TLA will fund the best startups in the programme either through a pre-seed, seed or Series A investment via its fund, The Lifesciences Innovation Fund (TLIF). Through TLIF investments and related fundraising activities, TLA aims to support incubatees with a target of close to S$100 million in funds raised during the next five years.
TLA is a joint venture between Temasek Life Sciences Laboratory, a nonprofit philanthropic research organisation, and Temasek Holdings' venture capital arm Vertex Holdings.
The Hatchery is run by a team of professionals in TLA with experience in intellectual property commercialisation, startup investing, talent recruitment, and sales and marketing. Startups will also have access to TLA's network of scientists, entrepreneurs, business executives and investors.
Get the latest on startups
and business news
Terms & conditions Sign up
The programme is part of Enterprise Singapore's Startup SG Accelerator initiative, which provides funding and non-financial support to incubators and accelerators that catalyse growth for high potential startups.
Ted Tan, deputy chief executive of Enterprise Singapore, said: "The access to research infrastructure and equipment will enable such startups to accelerate their innovations toward commercialisation and shorten the time required for their products to go to market globally."
Singapore-based startups Allegro Aqua and Pathnova have respectively commercialised superior sea bass genetics and nasopharyngeal cancer diagnostics technologies through The Hatchery.
"We want to provide a nurturing environment to support the development of companies capable of delivering real world impact," said TLA chief executive Peter Chia.
temasek lifesciences accelerator the hatchery incubator Purchase this article
Breaking
12:13 AMNov 14, 2019 12:13 AMBanking & Finance
Primary dealers remain key for European govt bond sales, debt officials say
[BRUSSELS] The role of banks as primary dealers in European government bond auctions remains key, and pressure on...
11:58 PMNov 13, 2019 11:58 PMGovernment & Economy
Signs mount that Qatar embargo may end as mediation gears up
[KUWAIT] Efforts to resolve the standoff between Qatar and a Saudi-led bloc are gathering momentum, with an upcoming...
11:41 PMNov 13, 2019 11:41 PMGovernment & Economy
House begins Trump impeachment inquiry hearings
[WASHINGTON] The impeachment inquiry into US President Donald Trump went public on Wednesday as lawmakers began...
Scroll to next article Working individuals to have shot at entrepreneurship through Antler-NUS tie-up SHARE THIS ARTICLE


Bayern Munich defender Jerome Boateng trains alone
Bayern Munich defender Jerome Boateng has been training alone during the international break.
The 31-year-old has been working under the tutelage of interim coach Hansi Flick.
The Ghana-born German international worked on coordination, dribbling and successive ball throw amongst others.
The defender is suspended for the Bundesliga clash against Dusseldorf after picking a red card in their 5-1 win over Frankfurt.
However, he will be available for selection when the Bavarians take on Red Star Belgrade on November 26 in the UEFA Champions League.


It is a Train IVR application which invloves human interaction with their mobile devices though DTMF tones via keypad to get the live status of a running train. Sounds cool, right? Wanna try it yourself? Watch the demo below or follow the below steps yourself to get the live status of a running train using RAIL JAANKAARI.
1. Firstly, call at<PHONE_NUMBER>0 from your mobile device.
2. Once prompted to enter the application code, please use the keypad to enter 75044.
3. After hearing the message "Welcome to Rail Jaankari", please enter the unique 5-digit train number and then enter #, e.g. 12864#.
4. Next, enter the option to select the date of your journey.
5. Please wait for a while while we fetch the live running status of the train.
6. Voila, you have got the live status of the train over your phone.
Experienced Software Engineer with a demonstrated history of working with the cutting-edge technologies. Skilled in App development and web development using React JS, Node JS, React Native, etc.
Passionate about algorithms, problem solving and learning new technologies. Skilled in Core Android Development using Java and Web Development using HTML, CSS and JS. Love trekking, sight seeing and playing badmintion in spare time.


Symbol Index for "Involvement In Incident"
Symbol Index for diagram
"Involvement In Incident"
classifier (Association)
Incident (Class)
incident for (Association)
Incident Involvement Type (Class)
Inter Subject Relationship (Class)
Involvement In Incident (Class)
Outcome Of Incident (Class)
source of (Association)
SPr/Association (Generalization Node)
Subject Characteristic (Class)
Subject Location (Class)
Subject Property (Class)


Welcome to websshot
Use below link to get a website screenshot in JPG
/screenshot?width=900&height=800&url=https://github.com/hugebelieve
Params available for both GET and POST request<
/span>
- width - number
- height - number
- url - webUrl
- cache - yes/no


Default
Navbars are responsive meta components that serve as navigation headers for your application or site. They begin collapsed (and are toggleable) in mobile views and become horizontal as the available viewport width increases.
Justified navbar nav links are currently not supported.
Inverse
Toolbar
Navbars are responsive meta components that serve as navigation headers for your application or site. They begin collapsed (and are toggleable) in mobile views and become horizontal as the available viewport width increases.
Justified navbar nav links are currently not supported.
Brand Image
Replace the navbar brand with your own image by swapping the text for
an
. Since the .navbar-brand
has
its own padding and height, you may need to override some CSS depending
on your image.
Brand Center
Add the .navbar-brand-center
class to brand elements to
center the brand in the navbar for mobile views.
Search
Search Overlap
Buttons
Add the .navbar-btn
class to <button>
elements not residing in a <form>
to vertically
center them in the navbar.
Text
Wrap strings of text in an element with .navbar-text
, usually
on a

tag for proper leading and color.
Non-Nav Links
For folks using standard links that are not within the regular navbar
navigation component, use the .navbar-link
class to add
the proper colors for the default and inverse navbar options.
Mega Navbar
More Components
Grid Example
Fixed To Top
Add .navbar-fixed-top
and include a .container
or .container-fluid
to center and pad navbar content.
Fixed To Bottom
Add .navbar-fixed-bottom
and include a .container
or .container-fluid
to center and pad navbar content.
Scrollspy
Home
Ad leggings keytar, brunch id art party dolor labore. Pitchfork yr enim lo-fi before they sold out qui. Tumblr farm-to-table bicycle rights whatever. Anim keffiyeh carles cardigan. Velit seitan mcsweeney's photo booth 3 wolf moon irure. Cosby sweater lomo jean shorts, williamsburg hoodie minim qui you probably haven't heard of them et cardigan trust fund culpa biodiesel wes anderson aesthetic. Nihil tattooed accusamus, cred irony biodiesel keffiyeh artisan ullamco consequat.
Link
Ad leggings keytar, brunch id art party dolor labore. Pitchfork yr enim lo-fi before they sold out qui. Tumblr farm-to-table bicycle rights whatever. Anim keffiyeh carles cardigan. Velit seitan mcsweeney's photo booth 3 wolf moon irure. Cosby sweater lomo jean shorts, williamsburg hoodie minim qui you probably haven't heard of them et cardigan trust fund culpa biodiesel wes anderson aesthetic. Nihil tattooed accusamus, cred irony biodiesel keffiyeh artisan ullamco consequat.
Action
Ad leggings keytar, brunch id art party dolor labore. Pitchfork yr enim lo-fi before they sold out qui. Tumblr farm-to-table bicycle rights whatever. Anim keffiyeh carles cardigan. Velit seitan mcsweeney's photo booth 3 wolf moon irure. Cosby sweater lomo jean shorts, williamsburg hoodie minim qui you probably haven't heard of them et cardigan trust fund culpa biodiesel wes anderson aesthetic. Nihil tattooed accusamus, cred irony biodiesel keffiyeh artisan ullamco consequat.
Another Action
Ad leggings keytar, brunch id art party dolor labore. Pitchfork yr enim lo-fi before they sold out qui. Tumblr farm-to-table bicycle rights whatever. Anim keffiyeh carles cardigan. Velit seitan mcsweeney's photo booth 3 wolf moon irure. Cosby sweater lomo jean shorts, williamsburg hoodie minim qui you probably haven't heard of them et cardigan trust fund culpa biodiesel wes anderson aesthetic. Nihil tattooed accusamus, cred irony biodiesel keffiyeh artisan ullamco consequat.
Something Else Here
Ad leggings keytar, brunch id art party dolor labore. Pitchfork yr enim lo-fi before they sold out qui. Tumblr farm-to-table bicycle rights whatever. Anim keffiyeh carles cardigan. Velit seitan mcsweeney's photo booth 3 wolf moon irure. Cosby sweater lomo jean shorts, williamsburg hoodie minim qui you probably haven't heard of them et cardigan trust fund culpa biodiesel wes anderson aesthetic. Nihil tattooed accusamus, cred irony biodiesel keffiyeh artisan ullamco consequat.


Batch history API is often easier to understand as you can manually feed data into your components which need it. If Resolution of the data request is not specified the history API uses the resolution of data you've specified with AddSecurity() or your Universe. If the Symbol is not specified then history for all symbols is returned for the period
// Request history for specific symbol, default to AddSecurity resolution. IEnumerable<TradeBar> bars = History("SPY", TimeSpan.FromDays(7)); // Request history for specific symbol, at specific resolution. IEnumerable<TradeBar> bars = History("SPY", TimeSpan.FromDays(7), Resolution.Minute); //Get last 14 bars of SPY, default to AddSecurity resolution. //Note you can't get "14 ticks" -- getting a specific number of bars only applies to TradeBar data. IEnumerable<TradeBar> bars = History("SPY", 14); //Get last 14 bars of SPY, at specific resolution. IEnumerable<TradeBar> bars = History("SPY", 14, Resolution.Minute); // Request history for specific symbol, default to AddSecurity resolution. IEnumerable<QuoteBar> bars = History<QuoteBar>("EURUSD", TimeSpan.FromDays(7)); // Request history for specific symbol, at specific resolution. IEnumerable<QuoteBar> bars = History<QuoteBar>("EURUSD", TimeSpan.FromDays(7), Resolution.Minute); //Get last 14 bars of EURUSD, default to AddSecurity resolution. //Note you can't get "14 ticks" -- getting a specific number of bars only applies to QuoteBar data. IEnumerable<QuoteBar> bars = History<QuoteBar>("EURUSD", 14); //Get last 14 bars of EURUSD, at specific resolution. IEnumerable<QuoteBar> bars = History<QuoteBar>("EURUSD", 14, Resolution.Minute); // Get history for all tickers we're subscribed to, at their native resolution IEnumerable<Slice> slices = History(TimeSpan.FromDays(7)); // Get history for all tickers we're subscribed to, at a specific resolution IEnumerable<Slice> slices = History(TimeSpan.FromDays(7), Resolution.Minute); // For custom data, we need to define the type. E.g.: Quandl AddData<Quandl>("SYMBOL") IEnumerable<Quandl> bars = History<Quandl>("SYMBOL", TimeSpan.FromDays(7)); IEnumerable<Quandl> bars = History<Quandl>("SYMBOL", 14);
# Get history for all tickers we're subscribed to, at their native resolution slices = self.History(timedelta(7)) # Get history for all tickers we're subscribed to, at a specific resolution slices = self.History(timedelta(7), Resolution.Minute) # Equity case: # Request history for specific symbol, default to AddSecurity resolution. bars = self.History("SPY", TimeSpan.FromDays(7)) # Request history for specific symbol, at specific resolution. bars = self.History("SPY", TimeSpan.FromDays(7), Resolution.Minute) # Get last 14 bars of SPY, default to AddSecurity resolution. # Note you can't get "14 ticks" -- getting a specific number of bars only applies to TradeBar data. bars = self.History("SPY", 14) # Get last 14 bars of SPY, at specific resolution. bars = self.History("SPY", 14, Resolution.Minute) # Other assets (QuoteBar) case: # We need to use map method to select only the specific symbol bars = map(lambda x: x["EURUSD"], self.History(timedelta(7))) bars = map(lambda x: x["EURUSD"], self.History(timedelta(7), Resolution.Minute)) bars = map(lambda x: x["EURUSD"], self.History(14)) bars = map(lambda x: x["EURUSD"], self.History(14, Resolution.Minute)) # Get history in pandas.DataFrame format, use list of string df = self.History(["EURUSD"], timedelta(7)) df = self.History(["EURUSD"], timedelta(7), Resolution.Minute) df = self.History(["EURUSD"], 14) df = self.History(["EURUSD"], 14, Resolution.Minute)
The returned data is presented in ascending order, meaning that last element has most recent information. Therefore, if you want to use historical data to warm up an indicator, you should use the list in its original order.
Batch data returned as $[IEnumerable<Slice> slices,T:QuantConnect.Data.Slice], $[IEnumerable<TradeBar> slices,T:QuantConnect.Data.Market.TradeBar] or $[IEnumerable<QuoteBar> slices,T:QuantConnect.Data.Market.QuoteBar] has all the normal slice helpers - to assist using the data in your strategy, for example:
In Python batch data can also be returned as pandas.DataFrame. It is a multi-index dataframe where the first index is the symbol where the time column is the EndTime of the bar. It is designed in LEAN to prevent the forward-looking in algorithm trading.
//From slice -> tradebars, or slice -> decimals. IEnumerable<Slice> slices = History(TimeSpan.FromDays(7), Resolution.Minute); IEnumerable<TradeBar> bars = slices.Get("SPY"); // Bars IEnumerable<decimal> decimals = slices.Get("SPY", Field.Close); // Close from slice // Many math libraries need double arrays, decimals -> double[] double[] doubleArray = decimals.ToDoubleArray(); // Get the most recent bar List<TradeBar> list = bars.ToList(); TradeBar mostRecentBar = list.Last();
# Request history for a single asset eurusd_slices = self.History(["EURUSD"], 5) # multi-index dataframe # Good practice to check whether the dataframe is empty if not eurusd_slices.empty: eurusd_bars = eurusd_slices.loc["EURUSD"] # single index dataframe eurusd_close = eurusd_bars["close"] # use lowercase # Get the most recent bar most_recent_bar = eurusd_close.tail(1) # Request history for a list of symbols symbols_slices = self.History(["AAPL", "SPY", "VXX"], 4) # multi-index dataframe if not symbols_slices.empty: # single index dataframe for SPY df_spy = slices.loc["SPY"] # A series of the SPY closing price spy_close = df_spy['close'] # single index dataframe with the closing price of all symbols all_symbols_close = slices["close"].unstack(level=0) # Get the most recent bar of each symbol most_recent_bars = all_symbols_close.tail(1)


cells SARS-CoV- host OpenUrl interaction antibody Vero invasion CrossRef infected novel Zhang detected viral Figure virus antiviral binding cells. performed (containing Liu Wang assay cell cells, coronavirus cultured localization protein COVID- Chen Spike Therefore, medium μg/mL ACE Huang Meplazumab Meplazumab) SARS-CoV anti-SARS-CoV- antibody, different dilution incubated receptor respiratory route specific supernatants used viruses (RBD) Abstract CD-SP Co-IP ELISA FREE Jiang SARS SP, SPR Text added anti-CD concentrations confirmed infection invading membrane sections using (nm-gold -well Biological, China) ELISA. Finally, His-CD Meplazumab, SARS-CoV-, Sino ability acute affinity arrows) colloid, competitive control crystal drug effect enzyme goat group harvested infection, inhibition inhibitory kidney measured microplate negative new observe observed patients produced quantitative reported research results severe similar stained target treatment value violet


Dear {{USER}},
Welcome to Infosys DevOps Platform (IDP).
We are glad to inform you that Application {{APPLICATION}} has been {{METHOD}} in IDP
Please find the roles assigned :
  Developers : {{DEVELOPER}}
  Pipeline Admins : {{PIPELINE_ADMIN}}
  Release Managers : {{RELEASE_MANAGER}}
  Environement Details :
{{ENVIRONMENT_DETAILS}}
To login in IDP Portal use your LDAP credentials.
Please click here visit Infosys DevOps Platform Portal.
Have a good day!!!
Regards,
IDP Team


Hynospace Outlaw is getting mod support next week
by Fraser BrownCyberspace adventure Hypnospace Outlaw is getting an update next week that will open the gates of its retro virtual internet to mods. The modding update will launch with some mods ready to go, and if you fancy making some yourself, you can start straight away.
It's apparently the game's biggest update and will let players make reskins of the interface, brand new websites, cheats and new storylines. Surprisingly, it won't be using Steam Workshop, instead opting mod.io and an in-game mod menu where you can browse and download them.
 If you want to start making one now, you can find out more on the official Discord server, where you also might be able to find some collaborators.
I keep meaning to go back to it, and if nothing else this has reminded me it's been languishing in my library for too long. Andy Kelly called it "one of the best detective games on PC" in his Hypnospace Outlaw review, so it's worth a look even if you're not fussed about the mods.
Mods will be available from November 19.
Disclosure: PC Gamer contributor Xalavier Nelson Jr. worked on Hypnospace Outlaw.


Book Id: {{home.book.bookId}}
Book Title: {{home.book.bookTitle}}
Book Author: {{home.book.author}}
Book Topic: {{home.book.topic}}
User Name: {{home.book.user.userName}}
Name: {{home.book.user.name}}
Email Id: {{home.book.user.email}}
Phone Number: {{home.book.user.phone}}
Issue Date : {{home.book.issueDate | date}}
Return Date : {{home.book.returnDate}}


Copyright © 2011-2022 Michael Truog
Version: 2.0.5 Jun 20 2023 18:35:41 ------------------------------------------------------------------------
This module defines the cloudi_service behaviour.
Required callback functions: cloudi_service_init/4, cloudi_service_terminate/3.
Optional callback functions: cloudi_service_handle_request/11, cloudi_service_handle_info/3.
Authors: Michael Truog (mjtruog at protonmail dot com).
The user module should export: cloudi_service_init(Args, Prefix, Timeout, Dispatcher) ==> {ok, State} {stop, Reason} {stop, Reason, State} State = undefined, if not returned Reason = restart | shutdown | Term cloudi_service_handle_request(RequestType, Name, Pattern, RequestInfo, Request, Timeout, Priority, TransId, Source, State, Dispatcher) ==> {reply, Response, StateNew} {reply, ResponseInfo, Response, StateNew} {forward, NameNext, RequestInfoNext, RequestNext, StateNew} {forward, NameNext, RequestInfoNext, RequestNext, TimeoutNext, PriorityNext, StateNew} {noreply, StateNew} {stop, Reason, StateNew} Reason = restart | shutdown | Term cloudi_service_handle_info(Request, State, Dispatcher) ==> {noreply, State} {stop, Reason, StateNew} Reason = restart | shutdown | Term cloudi_service_terminate(Reason, Timeout, State) Always called when the service terminates (either due to a stop tuple return value, an error/exit/throw exception or an exit signal). ==> ok The work flow (of the service) can be described as follows: User module Generic ----------- ------- cloudi_service_init <----- . loop cloudi_service_handle_request <----- . -----> reply cloudi_service_handle_info <----- . cloudi_service_terminate <----- .
dispatcher() = pid()
Source Erlang Process of a CloudI Service that will receive the service request response. The same Erlang process receives the CloudI Service's incoming service requests based on its subscriptions.
error_reason() = timeout
key_values() = cloudi_key_value:key_values()
key_values(Key, Value) = cloudi_key_value:key_values(Key, Value)
pattern_pid() = cloudi:pattern_pid()
priority() = cloudi:priority()
priority_value() = cloudi:priority_value()
request() = cloudi:request()
request_info() = cloudi:request_info()
request_result() = {reply, ResponseInfo::response_info(), Response::response()} | {forward, NameNext::service_name(), RequestInfoNext::request_info(), RequestNext::request(), TimeoutNext::timeout_value_milliseconds(), PriorityNext::priority_value()} | noreply
request_type() = send_async | send_sync
response() = cloudi:response()
response_info() = cloudi:response_info()
service_name() = cloudi:service_name()
service_name_pattern() = cloudi:service_name_pattern()
service_name_pattern_suffix() = cloudi:service_name_pattern_suffix()
source() = pid()
timeout_milliseconds() = cloudi:timeout_milliseconds()
timeout_period() = cloudi:timeout_period()
timeout_value_milliseconds() = cloudi:timeout_value_milliseconds()
trans_id() = cloudi:trans_id()
version 1 UUID
| context_options/1 |
Get the context options from the service's configuration.A service would only use this when delaying the creation of a context for child processes. |
| demonitor/2 |
Demonitor an Erlang pid.The function will make sure an Erlang pid is demonitored properly. |
| demonitor/3 |
Demonitor an Erlang pid with options.The function will make sure an Erlang pid is demonitored properly. |
| destination_refresh_immediate/1 |
Configured service destination refresh is immediate.. |
| destination_refresh_lazy/1 |
Configured service destination refresh is lazy.. |
| dispatcher/1 |
Return the Erlang pid representing the service sender.Use when the Dispatcher is stored and used after the current cloudi_service callback has returned. |
| duo_mode/1 |
Determine if duo_mode is enabled.. |
| forward/9 |
Forward a service request.. |
| forward_async/8 |
Forward an asynchronous service request.. |
| forward_sync/8 |
Forward a synchronous service request.. |
| get_pid/2 |
Get a service destination based on a service name.. |
| get_pid/3 |
Get a service destination based on a service name.. |
| get_pids/2 |
Get all service destinations based on a service name.. |
| get_pids/3 |
Get a service destination based on a service name.. |
| mcast_async/3 |
Send a multicast asynchronous service request.Asynchronous service requests are sent to all services that have subscribed to the service name pattern that matches the destination. |
| mcast_async/4 |
Send a multicast asynchronous service request.Asynchronous service requests are sent to all services that have subscribed to the service name pattern that matches the destination. |
| mcast_async/6 |
Send a multicast asynchronous service request.Asynchronous service requests are sent to all services that have subscribed to the service name pattern that matches the destination. |
| mcast_async_active/3 |
Send a multicast asynchronous service request.Asynchronous service requests are sent to all services that have subscribed to the service name pattern that matches the destination. |
| mcast_async_active/4 |
Send a multicast asynchronous service request.Asynchronous service requests are sent to all services that have subscribed to the service name pattern that matches the destination. |
| mcast_async_active/6 |
Send a multicast asynchronous service request.Asynchronous service requests are sent to all services that have subscribed to the service name pattern that matches the destination. |
| mcast_async_passive/3 |
Send a multicast asynchronous service request.An alias for mcast_async. |
| mcast_async_passive/4 |
Send a multicast asynchronous service request.An alias for mcast_async. |
| mcast_async_passive/6 |
Send a multicast asynchronous service request.An alias for mcast_async. |
| monitor/2 |
Monitor an Erlang pid.The function will make sure an Erlang pid is monitored properly so the cloudi_service_handle_info/3 callback receives the monitor result. |
| prefix/1 |
Configured service default prefix.All subscribed/unsubscribed service names use this prefix. |
| priority_default/1 |
Configured service default priority.. |
| process_count/1 |
Return the initial process count of this instance of the service.The configuration of the service defined how many instances should exist. |
| process_count_max/1 |
Return the process count maximum of this instance of the service.This will be the same as the process_count, unless count_process_dynamic configuration provides a maximum that is greater than the process_count. |
| process_count_min/1 |
Return the process count minimum of this instance of the service.This will be the same as the process_count, unless count_process_dynamic configuration provides a minimum that is less than the process_count. |
| process_index/1 |
Return the 0-based index of this instance of the service.The configuration of the service defined how many instances should exist. |
| recv_async/1 |
Receive an asynchronous service request.Use a null TransId to receive the oldest service request. |
| recv_async/2 |
Receive an asynchronous service request.Either use the supplied TransId to receive the specific service request or use a null TransId to receive the oldest service request. |
| recv_async/3 |
Receive an asynchronous service request.Either use the supplied TransId to receive the specific service request or use a null TransId to receive the oldest service request. |
| recv_async/4 |
Receive an asynchronous service request.. |
| recv_asyncs/2 |
Receive asynchronous service requests.. |
| recv_asyncs/3 |
Receive asynchronous service requests.. |
| recv_asyncs/4 |
Receive asynchronous service requests.. |
| return/2 |
Return a service response.. |
| return/3 |
Return a service response.. |
| return/9 |
Return a service response.. |
| return_async/8 |
Return an asynchronous service response.. |
| return_nothrow/9 |
Return a service response without exiting the request handler.Should rarely, if ever, be used. |
| return_sync/8 |
Return a synchronous service response.. |
| self/1 |
Return the Erlang pid representing the service.. |
| send_async/3 |
Send an asynchronous service request.. |
| send_async/4 |
Send an asynchronous service request.. |
| send_async/5 |
Send an asynchronous service request.. |
| send_async/6 |
Send an asynchronous service request.. |
| send_async/7 |
Send an asynchronous service request.. |
| send_async_active/3 |
Send an asynchronous service request.The response is sent to the service as an Erlang message which is either:{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl"). to have:
#return_async_active{} (or) #timeout_async_active{} |
| send_async_active/4 |
Send an asynchronous service request.The response is sent to the service as an Erlang message which is either:{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl"). to have:
#return_async_active{} (or) #timeout_async_active{} |
| send_async_active/5 |
Send an asynchronous service request.The response is sent to the service as an Erlang message which is either:{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl"). to have:
#return_async_active{} (or) #timeout_async_active{} |
| send_async_active/6 |
Send an asynchronous service request.The response is sent to the service as an Erlang message which is either:{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl"). to have:
#return_async_active{} (or) #timeout_async_active{} |
| send_async_active/7 |
Send an asynchronous service request.The response is sent to the service as an Erlang message which is either:{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl"). to have:
#return_async_active{} (or) #timeout_async_active{} |
| send_async_active/8 |
Send an asynchronous service request with a previously generated transaction id.Only meant for special transaction handling. |
| send_async_passive/3 |
Send an asynchronous service request.An alias for send_async. |
| send_async_passive/4 |
Send an asynchronous service request.An alias for send_async. |
| send_async_passive/5 |
Send an asynchronous service request.An alias for send_async. |
| send_async_passive/6 |
Send an asynchronous service request.An alias for send_async. |
| send_async_passive/7 |
Send an asynchronous service request.An alias for send_async. |
| send_sync/3 |
Send a synchronous service request.. |
| send_sync/4 |
Send a synchronous service request.. |
| send_sync/5 |
Send a synchronous service request.. |
| send_sync/6 |
Send a synchronous service request.. |
| send_sync/7 |
Send a synchronous service request.. |
| source_subscriptions/2 |
Get a list of all service name patterns a service request source is subscribed to.The source pid can be found at: cloudi_service_handle_request(_, _, _, _, _, _, _, _, Source, _, _) |
| subscribe/2 |
Subscribe to a service name pattern.. |
| subscribe_count/2 |
Determine how may service name pattern subscriptions have occurred.. |
| suffix/2 |
Service request suffix from a service name or service name pattern.. |
| timeout_async/1 |
Configured service default asynchronous timeout (in milliseconds).. |
| timeout_max/1 |
Maximum possible service request timeout (in milliseconds).Use ?TIMEOUT_MAX_ERLANG directly from cloudi_constants.hrl instead, if possible. |
| timeout_sync/1 |
Configured service default synchronous timeout (in milliseconds).. |
| trans_id/1 |
Return a new transaction id.The same data as used when sending service requests is used. |
| unsubscribe/2 |
Unsubscribe from a service name pattern.. |
context_options(Dispatcher::dispatcher()) -> cloudi:options()
demonitor(Dispatcher::dispatcher(), MonitorRef::reference()) -> true
demonitor(Dispatcher::dispatcher(), MonitorRef::reference(), Options::list()) -> true
destination_refresh_immediate(Dispatcher::dispatcher()) -> boolean()
destination_refresh_lazy(Dispatcher::dispatcher()) -> boolean()
dispatcher(Dispatcher::dispatcher()) -> DispatcherNew::pid()
duo_mode(Dispatcher::dispatcher()) -> boolean()
forward(Dispatcher::dispatcher(), RequestType::request_type(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_value_milliseconds(), Priority::priority(), TransId::trans_id(), Source::source()) -> no_return()
forward_async(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_value_milliseconds(), Priority::priority(), TransId::trans_id(), Source::source()) -> no_return()
forward_sync(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_value_milliseconds(), Priority::priority(), TransId::trans_id(), Source::source()) -> no_return()
get_pid(Dispatcher::dispatcher(), Name::service_name()) -> {ok, PatternPid::pattern_pid()} | {error, Reason::error_reason()}
get_pid(Dispatcher::dispatcher(), Name::service_name(), Timeout::timeout_period()) -> {ok, PatternPid::pattern_pid()} | {error, Reason::error_reason()}
get_pids(Dispatcher::dispatcher(), Name::service_name()) -> {ok, PatternPids::[pattern_pid(), ...]} | {error, Reason::error_reason()}
get_pids(Dispatcher::dispatcher(), Name::service_name(), Timeout::timeout_period()) -> {ok, PatternPids::[pattern_pid(), ...]} | {error, Reason::error_reason()}
mcast_async(Dispatcher::dispatcher(), Name::service_name(), Request::request()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
mcast_async(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
mcast_async(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
mcast_async_active(Dispatcher::dispatcher(), Name::service_name(), Request::request()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
mcast_async_active(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
mcast_async_active(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
mcast_async_passive(Dispatcher::dispatcher(), Name::service_name(), Request::request()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
mcast_async_passive(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
mcast_async_passive(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority()) -> {ok, TransIdList::[trans_id()]} | {error, Reason::error_reason()}
monitor(Dispatcher::dispatcher(), Pid::pid()) -> MonitorRef::reference()
prefix(Dispatcher::dispatcher()) -> Prefix::service_name_pattern()
priority_default(Dispatcher::dispatcher()) -> PriorityDefault::cloudi_service_api:priority()
process_count(Dispatcher::dispatcher()) -> ProcessCount::pos_integer()
process_count_max(Dispatcher::dispatcher()) -> ProcessCountMax::pos_integer()
process_count_min(Dispatcher::dispatcher()) -> ProcessCountMin::pos_integer()
process_index(Dispatcher::dispatcher()) -> ProcessIndex::non_neg_integer()
recv_async(Dispatcher::dispatcher()) -> {ok, ResponseInfo::response_info(), Response::response(), TransId::trans_id()} | {error, Reason::error_reason()}
recv_async(Dispatcher::dispatcher(), TransId::timeout_period() | trans_id()) -> {ok, ResponseInfo::response_info(), Response::response(), TransId::trans_id()} | {error, Reason::error_reason()}
recv_async(Dispatcher::dispatcher(), TransId::timeout_period() | trans_id(), Consume::trans_id() | boolean()) -> {ok, ResponseInfo::response_info(), Response::response(), TransId::trans_id()} | {error, Reason::error_reason()}
recv_async(Dispatcher::dispatcher(), Timeout::timeout_period(), TransId::trans_id(), Consume::boolean()) -> {ok, ResponseInfo::response_info(), Response::response(), TransId::trans_id()} | {error, Reason::error_reason()}
recv_asyncs(Dispatcher::dispatcher(), TransIdList::[trans_id()]) -> {ok, [{ResponseInfo::response_info(), Response::response(), TransId::trans_id()}]} | {error, Reason::error_reason()}
recv_asyncs(Dispatcher::dispatcher(), Timeout::timeout_period(), TransIdList::[trans_id()]) -> {ok, [{ResponseInfo::response_info(), Response::response(), TransId::trans_id()}]} | {error, Reason::error_reason()}
recv_asyncs(Dispatcher::dispatcher(), Timeout::timeout_period(), TransIdList::[trans_id()], Consume::boolean()) -> {ok, [{ResponseInfo::response_info(), Response::response(), TransId::trans_id()}]} | {error, Reason::error_reason()}
return(Dispatcher::dispatcher(), Response::response()) -> no_return()
return(Dispatcher::dispatcher(), ResponseInfo::response_info(), Response::response()) -> no_return()
return(Dispatcher::dispatcher(), RequestType::request_type(), Name::service_name(), Pattern::service_name_pattern(), ResponseInfo::response_info(), Response::response(), Timeout::timeout_value_milliseconds(), TransId::trans_id(), Source::source()) -> no_return()
return_async(Dispatcher::dispatcher(), Name::service_name(), Pattern::service_name_pattern(), ResponseInfo::response_info(), Response::response(), Timeout::timeout_value_milliseconds(), TransId::trans_id(), Source::source()) -> no_return()
return_nothrow(Dispatcher::dispatcher(), RequestType::request_type(), Name::service_name(), Pattern::service_name_pattern(), ResponseInfo::response_info(), Response::response(), Timeout::timeout_value_milliseconds(), TransId::trans_id(), Source::source()) -> ok
return_sync(Dispatcher::dispatcher(), Name::service_name(), Pattern::service_name_pattern(), ResponseInfo::response_info(), Response::response(), Timeout::timeout_value_milliseconds(), TransId::trans_id(), Source::source()) -> no_return()
self(Dispatcher::dispatcher()) -> Self::source()
send_async(Dispatcher::dispatcher(), Name::service_name(), Request::request()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period(), PatternPid::pattern_pid() | undefined) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority(), PatternPid::pattern_pid() | undefined) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async_active(Dispatcher::dispatcher(), Name::service_name(), Request::request()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
send_async_active(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
send_async_active(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period(), PatternPid::pattern_pid() | undefined) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
send_async_active(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
send_async_active(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority(), PatternPid::pattern_pid() | undefined) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
send_async_active(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority(), TransId::trans_id(), PatternPid::pattern_pid()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
{return_async_active, Name, Pattern, ResponseInfo, Response, Timeout, TransId}
(or)
{timeout_async_active, TransId}
use -include_lib("cloudi_core/include/cloudi_service.hrl").
to have:
#return_async_active{}
(or) #timeout_async_active{}
send_async_passive(Dispatcher::dispatcher(), Name::service_name(), Request::request()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async_passive(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async_passive(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period(), PatternPid::pattern_pid() | undefined) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async_passive(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority()) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_async_passive(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority(), PatternPid::pattern_pid() | undefined) -> {ok, TransId::trans_id()} | {error, Reason::error_reason()}
send_sync(Dispatcher::dispatcher(), Name::service_name(), Request::request()) -> {ok, ResponseInfo::response_info(), Response::response()} | {ok, Response::response()} | {error, Reason::error_reason()}
send_sync(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period()) -> {ok, ResponseInfo::response_info(), Response::response()} | {ok, Response::response()} | {error, Reason::error_reason()}
send_sync(Dispatcher::dispatcher(), Name::service_name(), Request::request(), Timeout::timeout_period(), PatternPid::pattern_pid() | undefined) -> {ok, ResponseInfo::response_info(), Response::response()} | {ok, Response::response()} | {error, Reason::error_reason()}
send_sync(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority()) -> {ok, ResponseInfo::response_info(), Response::response()} | {ok, Response::response()} | {error, Reason::error_reason()}
send_sync(Dispatcher::dispatcher(), Name::service_name(), RequestInfo::request_info(), Request::request(), Timeout::timeout_period(), Priority::priority(), PatternPid::pattern_pid() | undefined) -> {ok, ResponseInfo::response_info(), Response::response()} | {ok, Response::response()} | {error, Reason::error_reason()}
source_subscriptions(Dispatcher::dispatcher(), Source::source()) -> [service_name_pattern()]
The source pid can be found at:
cloudi_service_handle_request(_, _, _, _, _, _, _, _, Source, _, _)
subscribe(Dispatcher::dispatcher(), Pattern::service_name_pattern_suffix()) -> ok | error
subscribe_count(Dispatcher::dispatcher(), Pattern::service_name_pattern_suffix()) -> non_neg_integer()
suffix(Dispatcher::dispatcher(), NameOrPattern::service_name() | service_name_pattern()) -> Suffix::service_name() | service_name_pattern()
timeout_async(Dispatcher::dispatcher()) -> TimeoutAsync::cloudi_service_api:timeout_send_async_value_milliseconds()
timeout_max(Dispatcher::dispatcher()) -><PHONE_NUMBER>
timeout_sync(Dispatcher::dispatcher()) -> TimeoutSync::cloudi_service_api:timeout_send_sync_value_milliseconds()
trans_id(Dispatcher::dispatcher()) -> trans_id()
unsubscribe(Dispatcher::dispatcher(), Pattern::service_name_pattern_suffix()) -> ok | error
Generated by EDoc


Docker complements LXC with a high-level API which operates at the process level. It runs unix processes with strong guarantees of isolation and repeatability across servers.
Docker is a great building block for automating distributed systems: large-scale web deployments, database clusters, continuous deployment systems, private PaaS, service-oriented architectures, etc.
Any combination of binaries, libraries, configuration files, scripts, virtualenvs, jars, gems, tarballs, you name it. No more juggling between domain-specific tools. Docker can deploy and run them all.
Docker can run on any x64 machine with a modern linux kernel - whether it's a laptop, a bare metal server or a VM. This makes it perfect for multi-cloud deployments.
docker isolates processes from each other and from the underlying host, using lightweight containers.
Because containers are isolated in their own filesystem, they behave the same regardless of where, when, and alongside what they run.
Under the hood, Docker is built on the following components:


"Sense Of Place, European Landscape Photography" / BOZAR - Brussels Center for Fine Arts, Belgium
"Dam and Man in Savoy" / EDF Foundation, Paris, France
"Máze" / Blue Sky Gallery, Portland (OR), USA
"Máze" / Abbaye-Aux-Dames, Les Boréales-Plateforme de Création Nordique, Caen, France
"Máze" / Northern Photographic Center, Oulu, Finland
"Máze" / The Apartment Gallery, Oslo, Norway - Design: Torgeir Hjetland
"Máze" / Boldhype Gallery, New York, USA - Photo : Corey Arnold
"Dam and Man in Savoy" / Public installation in several villages located nearby the dams, Savoy-Alps, France


Kitty rescued in Bangladesh after getting stuck in a window
by Ben BoltonA kitten in Dhaka, Bangladesh, found itself in a precarious position.
The feline had managed to get itself stuck in a window on the 3rd floor of a building and couldn't manage to wiggle out.
Three young men walking by saw the cat unable to move and decided to try to help.
"A cat was stuck on building's third-floor window," one of the men told ViralHog. "My two friends and I were crossing by the front of the building and saw it. My friends went inside the building and one friend climbed down to the window and saved the cat."
You can see the man who climbed out on the window petting the cat to calm it down, and then wiggling it out in order to pass it to his friend above.
The kitty made it out safely thanks to the caring men — especially the brave one with no fear of heights!


You'll notice that the List.it icon was automatically added to your Add-on Bar. You can click this to open or close the sidebar.
Firefox gives you the ability to customize the way your toolbars look. If you want the List.it icon to be somewhere else, just right click on one of your toolbars and select 'Customize.' This will allow you to click and drag the icon, and even remove it completely.
You can also toggle the sidebar from the Firefox menu. At the top of your browser, you can go to View>Sidebar>List.it which will allow you to open and close the sidebar.
If you don't see a View button, you have your Menu Bar hidden. You can make it appear by right clicking on one of your toolbars and clicking on 'Menu Bar.'
For your convenience, we've given you a hotkey that you can use anywhere in Firefox. It can also open and close the sidebar. It has a default keyboard shortcut but you can change that by going to the Options Page and adjusting your settings.
| Default Shortcut | Use |
|---|---|
| Control+Shift+L | Open/Close the sidebar |


{% extends 'layout/base.html' %} {% block 'content' %}
This application communicates with a WoT enabled network to allow you to control your devices


Scroll down for details and registration.
Install instructions for each of the workshop sessions can be found HERE
Venue
This is an in-person event. The workshops will be held in either rm1.17 or rm1.19 of the Otago Business School (aka Commerce Building), University of Otago.
Timetable
The timetable is shown below
Workshop sessions are designed to be tasters for the topics rather than comprehensive lessons. A laptop will be required to fully participate in most workshop sessions.
Skill level description:
In order to convey the skill level of a particular workshop the following terms are used to describe the assumed levels of prior knowledge or experience.
Beginner: Someone new to the topic with minimal prior knowledge of the workshop topic beyond the stated pre-requisites
Post-beginner: Greater expectation of prior knowledge or experience beyond the direct topic being covered in the workshop
In general, the "Entry" stream is recommended for beginners, and the "Other" stream recommended for previous ResBaz or Carpentries workshop attendees.
Monday 5th July
Birds of a Feather (BoF): R users - meet over lunch with other people using R
Click on workshop names to expand the description
Entry Stream:
This workshop will provide an overview of how to get started working with R. This will be done by providing a explaination of the RStudio environment and and introduction to the R programming language syntax.
Targeted skill level: beginner
Software required: R and RStudio
This workshop will introduce how to get started with data in R using the dplyr and tidyr packages for R which are useful for data manipulation and tidying.
Targeted skill level: beginner
Software required: R and RStudio
This workshop will introduce how to make plots using the ggplot2 package in R for visualising data.
Targeted skill level: beginner
Software required: R and RStudio
Other Stream:
This workshop will extend your understanding of R and cover how to interact with non-data.frame structured data such as vectors, matrices and lists. We'll also look at creating your own functions and loops.
Targeted skill level: post-beginner
Software required: R and RStudio
Take the time to explore the lesser known functions and packages of the Tidyverse. Learn about how to access googlesheets, use times/dates, manipulate text, use functional programming to replace loops, and more.
Targeted skill level: post-beginner
Software required: R and RStudio
This workshop will introduce you to the power of regular expressions - a way of searching using patterns. We'll cover how to use patterns to find files, and things in files.
Targeted skill level: beginner
Software required: Web browser or UNIX shell
Tuesday 6th July
Birds of a Feather (BoF): Subject Areas - meet over lunch with other people in a similar research subject area
Click on workshop names to expand the description
Entry level:
- Load data into OpenRefine
- perform basic data cleaning operations
- Export data from OpenRefine
- clean and organise data
- want to apply the same data cleaning operation to multiple datasets
Targeted skill level: beginner
Software required: OpenRefine
This workshop will provide a 'good-enough' practices overview for how to go about setting up and working on a project using reproducible research principles.
Targeted skill level: beginner
Software required: Text editor e.g. notepad or textedit
This session will provide you with advice and skills on how to start tackling error messages and where to look for help.
Targeted skill level: beginner
Software required: none - but R and RStudio would be uesful
Other Stream:
This workshop will introduce you to the world of using creating simple websites using the markdown language. A it will involve a pratical application of version control principles which can be applied to other code as well.
- Creating up a github account
- Creating a repository
- Introduction to markdown syntax for formatting
- Creating a simple webpage with markdown
- Modifying pages and tracking changes
- How to use Github for collaboration
Targeted skill level: all
Software required: web-browser
This workshop will introduce you to workflow language systems that are used for creating reproducible research workflows. This workshop will use Snakemake as the example
Targeted skill level: post-beginner
Software required: to be announced
Targeted skill level: all
Software required: none
Wednesday 7th July
Click on workshop names to expand the description
Entry level:
- open the commandline
- understand how to navigate and create files and directories
- run commandline programs
- task automation
Targeted skill level: beginner
Software required: MacOS/Linux - Terminal (comes pre-installed). Windows - GitBash
This session will cover useful code snippets that are designed to improve your overall experience doing computational research. This will include how to customise your BASH and R environments, useful keyboard short cuts, and short pieces of code to do common tasks e.g. read a directory of files into R.
Targeted skill level: beginner
Software required: none - useful:R and RStudio, and UNIX shell
Other Stream:
- obtain a pre-built docker image
- create a dockerfile to create a custom contatiner
- access the docker container and run a command
- share data between the host and the container
Targeted skill level: post-beginner
Software required: Docker
This workshop will introduce text analysis in R. This will touch on sentiment analysis, word frequencies, and more.
Targeted skill level: post-beginner
Software required: R and RStudio
Install instructions for each of the workshop sessions can be found HERE
Speakers
Dr. Nick Mortimer (GNS). Seeing the big picture: the discovery of Te Riu-a-Māui / Zealandia, Earth’s 8th continent.
Dr. Eddy Dowle (Department of Anatomy). Genome-wide variation and transcriptional changes in diverse developmental processes underly the rapid evolution of seasonality in a temperate fly.
Claire Grant (Genomics Aotearoa). Science Communication
Assoc. Prof David Orlovich (Department of Botany)
Registration Instructions
Open to University of Otago students and staff. This is an in-person event.
Select the appropriate ticket(s)
- general admission if you want to attend the talks and have food provided*
- workshop - if you wish to attend one or more workshops
If you have selected a workshop ticket:
- Select no more than one workshop per session
- If you are a beginner/novice it is recommended to choose from the Entry stream.
Registration has closed.
Any questions please email<EMAIL_ADDRESS>*Note that during the registration process you will be asked about your food preferences. We are hoping to be able to provide lunch for attendees, but this request is still going through the University's approval process, so we are not yet sure about our ability to cater this event. This will be confirmed with attendees before the event.


Call of Duty: Modern Warfare tops October 2019 NPD charts
October sees a couple of strong debut titles.
by Samuel TolbertSource: Activision
What you need to know
- The October 2019 NPD data has been released
- For this month, Call of Duty: Modern Warfare took the top spot on Xbox One and overall.
- The Nintendo Switch was the bestselling console overall.
- You can grab Call of Duty: Modern Warfare for $60 on Amazon.
Every month, the NPD Group releases information on the top-selling games across all video game platforms in the United States. While it doesn't account for worldwide sales, it does provide a good snapshot of one the largest video game markets. Mat Piscatella, an analyst for NPD, has shared the results for October 2019. For this month, data was tracked from October 6 through November 2, 2019.
Call of Duty: Modern Warfare had a massive launch, taking the #1 spot for the month overall. Obsidian Entertainment's RPG The Outer Worlds also did well, grabbing the #2 spot for the month, while also launching in Xbox Game Pass. Nintendo Switch exclusive Luigi's Mansion 3 grabbed the #3 spot. Grand Theft Auto V, the game that just won't stop selling, snagged an impressive spot at #14. Gears 5 dropped out of the overall top 20 but was the 10th best-selling game on Xbox One. The Nintendo Switch was, yet again, the bestselling console of the month.
Here are the numbers for the October 2019 NPD results:
- Total: $1.03 billion, down 34% year-over-year from $1.57 billion
- Video games hardware: $182 million, down 41% year-over-year from $307 million
- PC and video games software: $620 million, down 22% year-over-year from $983 million
- Accessories and game cards: $231 million, down 4% year-over-year from $277 million
Here are the October 2019 game sales rankings (based on dollar sales, not units):
- Call of Duty: Modern Warfare 2019
- The Outer Worlds
- Luigi's Mansion 3*
- Madden NFL 20
- NBA 2K20
- Tom Clancy's Ghost Recon: Breakpoint
- WWE 2K20
- FIFA 20
- Borderlands 3
- Ring Fit Adventure
- The Legend of Zelda: Link's Awakening*
- Mario Kart 8*
- Minecraft***
- Grand Theft Auto V
- Mortal Kombat 11
- Overwatch
- Super Smash Bros. Ultimate*
- Code Vein
- Red Dead Redemption II
- The Legend of Zelda: Breath of the Wild*
- *Does not include digital sales
- **Does not include Steam sales
- ***Minecraft digital sales include Xbox One and PlayStation 4, but not other digital sales.
Here are the best-selling games of October 2019 by platform:
PlayStation 4
- Call of Duty: Modern Warfare 2019
- The Outer Worlds
- NBA 2K20
- Madden NFL 20
- Tom Clancy's Ghost Recon: Breakpoint
- WWE 2K20
- FIFA 20
- Borderlands 3
- Mortal Kombat 11
- Grand Theft Auto V
Xbox One
- Call of Duty: Modern Warfare 2019
- Tom Clancy's Ghost Recon: Breakpoint
- Madden NFL 20
- The Outer Worlds
- NBA 2K20
- Borderlands 3
- WWE 2K20
- FIFA 20
- Grand Theft Auto V
- Gears 5
Nintendo Switch
- Luigi's Mansion 3*
- Ring Fit Adventure
- The Legend of Zelda: Link's Awakening*
- Mario Kart 8*
- Super Smash Bros. Ultimate*
- Overwatch
- The Legend of Zelda: Breath of the Wild*
- The Witcher 3: Wild Hunt*
- Super Mario Maker 2*
- New Super Mario Bros. U Deluxe*
Here are the best-selling games of 2019 year-to-date:
- Call of Duty: Modern Warfare 2019
- NBA 2K20
- Madden NFL 20
- Borderlands 3
- Mortal Kombat 11
- Kingdom Hearts III
- Tom Clancy's The Division 2
- Anthem
- Super Smash Bros. Ultimate*
- Grand Theft Auto V
That's all for the breakdown of this month's numbers. For more information, you can consult Mat Piscatella's thread right here. If you'd like details on last month's NPD breakdown, you can find that right here.
Next level combat
Call of Duty: Modern Warfare
Times have changed
Call of Duty: Modern Warfare raises the stakes once again in 2019. Infinity Ward brings a raw and provocative take on the first-person shooter, shining a gritty light on the changing nature of modern combat.
Get more Xbox
Xbox
- Xbox One S vs. Xbox One X: Which should you buy?
- Best Xbox One X and Xbox One S Accessories
- Best Xbox One Headsets 2019
- Best Xbox One Wireless Headsets 2019
- Best Xbox Controller Charging Stations in 2019
We may earn a commission for purchases using our links. Learn more.


{% extends "base.html" -%} {% block content %}
This is a simple real time chat for Enterprises and Programmers
If you wanna talk about jobs or nerd stuffs let's talk!
Register Login


Erin O'Brien
This is a web page dedicated to my grandmother, Erin O'Brien. I will use this page to give some descriptions of some of the pictures on the pictures page.
This is a web page dedicated to my grandmother, Erin O'Brien. I will use this page to give some descriptions of some of the pictures on the pictures page.


NICO ICON A film review by Lax Madapati Copyright 1996 Lax Madapati
Germany, 1995 Running Time: 1:12
Cast: None credited Director: Susanne Ofteringer Screenplay: Susanne Ofteringer Cinematography: Judith Kaufmann, Katarzyna Remin Music: Jens Tukiendorf, Charles Blackwell
Nico Icon, through a series of interviews and original footage, attempts to portray the story of a multi-faceted woman Nico who was a member of the '60s rock band 'The Velvet Underground'. A refugee from Germany born Christa Paffgen during World War II, Nico was also a fashion model, a reclusive beauty, a feckless mother and a reckless junkie. Or so, the director Susanne Ofteringer wants us to believe, at the end of it all.
The film, or rather documentary, starts off with Nico singing the Velvet Underground's 'Femme Fatale' in a very lugubrious tone and alternates between clips of original footage and interviews with several people associated with Nico at various stages of her life. What is surprising is the number of famous people Nico has associated herself with, right from her modeling days upto her ultimate obscure demise, veering on a path of self-destruction, self- inflicted and substance abuse.
In between clips of original footage, we get to hear different view points of the many people Nico's path in life crossed with. Most of them seem to agree that the beauty that she is, Nico resented her own good looks and would much rather be depressed and gloomy and be known as a musician rather than just a beautiful woman. Jackson Browne, the rock musician and one of Nico's many lovers (who also contributed to her first solo album 'Chelsea Girl') explains about her initiation into The Velvet Underground. Paul Morrisey, director of most of Andy Warhol movies and who was responsible for putting Nico with The Velvet Underground as a second singer and organ player via Andy Warhol, amid strong initial resistance from band members Lou Reed and company, tells how Nico deliberately spoilt her looks by dying her hair with strange colors and taking drugs. Danny Fields, music journalist, explains her association with rock legend Jim Morrison and how she enjoyed Morrison's alleged attempt to kill her once during a sex ritual.
Most touching of all accounts on Nico is the one narrated by Edith Boulonge, mother of one of Nico's many lovers Alian Delon, by who Nico begot a child Ari. Edith tells how after Alian discovered that Nico was pregnant and disowned her child, asked Edith to choose between her son Alian and Nico's child Ari. Edith chose to take care of the child Ari and justifies it saying, "Alian is a grown-up and he can take care of himself but Ari is a little child and needs a mother". She sure didn`t want the child to be with Nico as all she would do is feed little Ari with potato chips. There is also an interesting narration from the grown up Ari (who is now thirty years old and lives in Paris) who claims that it was his own mother Nico that initiated him into heroin when he was eighteen and went to Manchester to live with Nico.
No doubt the footage that Ofteringer manages to uncover is exhaustive - ranging from French TV commercials, to performance pieces of the Velvet Under ground's ironic debut at the American Psychiatric Convention to her debut in films in the legendary film maker Federico Fellini's classic 'La Dolce Vita' (1960) as a blonde model to her heydays of association with Andy Warhol and her final days of drugs, decadence and eventual but eventless demise. With clever and snappy editing, all this footage is intertwined with the interviews and juxtaposed with music and dialogue to create a fast paced pop collage. For the most part, the film does take an unbiased and disinterested stance but sometimes strays into irritating `show-me-some-sympathy' portrayals with words like 'she is alone' flying across images of Nico.
Much like the ambiguous title of the film 'Nico Icon', Ofteringer portrays Nico in an ambiguous manner - as a person whose life was mostly filled with sadness and despair but who actually derived pleasure from it all.
Rating: On the SuperNova Scale ***1/2 / *****
(The Supernova Scale: - dud; * poor; ** fair; *** good; **** excellent; ***** memorable)
The Velvet Underground ----------------------
This rock and roll band was formed in 1965 with the initial line-up of Lou Reed, Maureen Tucker on drums, John Cale and Sterling Morrison on guitars. Later on, Doug and Billy Yule replaced John Cale and Maureen Tucker respective ly and Andy Warhol, who produced VU's early records, added on Nico as a second singer and organ player. VU released their first self titled record in 1967 and made another three studio albums in the next three years, none of which cracked the Top 100 charts. Two members John Cale and Lou Reed went on to be popular and the other two remained in total obscurity. Four managers are in litigation about Nico's royalties and her son Ari is also trying to get his share. But during those five hard-fought and hard-luck years, VU had an un- deniable influence on a whole generation of youngsters. It`s true that hardly anyone bought any records of VU. But ironically, those who did, went on to form their own bands - David Bowie, Patti Smith, Talking Heads, Iggy Pop, R.E.M., U2, Henry Rollins, Sonic Youth... The list is endless and filled with the super stars of today's rock. Recently, the record label Polydor released remastered editions of many of VU's albums.
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


"""Gaussian processes regression. """
# Authors: Jan Hendrik Metzen<EMAIL_ADDRESS># Modified by: Pete Green<EMAIL_ADDRESS># License: BSD 3 clause
import warnings
from operator import itemgetter
import numpy as np
from scipy.linalg import cholesky, cho_solve, solve_triangular
import scipy.optimize
from ..base import BaseEstimator, RegressorMixin, clone
from ..base import MultiOutputMixin
from .kernels import RBF, ConstantKernel as C
from ..utils import check_random_state
from ..utils.validation import check_array
from ..utils.optimize import _check_optimize_result
from ..utils.validation import _deprecate_positional_args
class GaussianProcessRegressor(MultiOutputMixin,
RegressorMixin, BaseEstimator):
"""Gaussian process regression (GPR).
The implementation is based on Algorithm 2.1 of Gaussian Processes
for Machine Learning (GPML) by Rasmussen and Williams.
In addition to standard scikit-learn estimator API,
GaussianProcessRegressor:
* allows prediction without prior fitting (based on the GP prior)
* provides an additional method sample_y(X), which evaluates samples
drawn from the GPR (prior or posterior) at given inputs
* exposes a method log_marginal_likelihood(theta), which can be used
externally for other ways of selecting hyperparameters, e.g., via
Markov chain Monte Carlo.
Read more in the :ref:`User Guide <gaussian_process>`.
.. versionadded:: 0.18
Parameters
----------
kernel : kernel instance, default=None
The kernel specifying the covariance function of the GP. If None is
passed, the kernel "1.0 * RBF(1.0)" is used as default. Note that
the kernel's hyperparameters are optimized during fitting.
alpha : float or array-like of shape (n_samples), default=1e-10
Value added to the diagonal of the kernel matrix during fitting.
Larger values correspond to increased noise level in the observations.
This can also prevent a potential numerical issue during fitting, by
ensuring that the calculated values form a positive definite matrix.
If an array is passed, it must have the same number of entries as the
data used for fitting and is used as datapoint-dependent noise level.
Note that this is equivalent to adding a WhiteKernel with c=alpha.
Allowing to specify the noise level directly as a parameter is mainly
for convenience and for consistency with Ridge.
optimizer : "fmin_l_bfgs_b" or callable, default="fmin_l_bfgs_b"
Can either be one of the internally supported optimizers for optimizing
the kernel's parameters, specified by a string, or an externally
defined optimizer passed as a callable. If a callable is passed, it
must have the signature::
def optimizer(obj_func, initial_theta, bounds):
# * 'obj_func' is the objective function to be minimized, which
# takes the hyperparameters theta as parameter and an
# optional flag eval_gradient, which determines if the
# gradient is returned additionally to the function value
# * 'initial_theta': the initial value for theta, which can be
# used by local optimizers
# * 'bounds': the bounds on the values of theta
....
# Returned are the best found hyperparameters theta and
# the corresponding value of the target function.
return theta_opt, func_min
Per default, the 'L-BGFS-B' algorithm from scipy.optimize.minimize
is used. If None is passed, the kernel's parameters are kept fixed.
Available internal optimizers are::
'fmin_l_bfgs_b'
n_restarts_optimizer : int, default=0
The number of restarts of the optimizer for finding the kernel's
parameters which maximize the log-marginal likelihood. The first run
of the optimizer is performed from the kernel's initial parameters,
the remaining ones (if any) from thetas sampled log-uniform randomly
from the space of allowed theta-values. If greater than 0, all bounds
must be finite. Note that n_restarts_optimizer == 0 implies that one
run is performed.
normalize_y : boolean, optional (default: False)
Whether the target values y are normalized, the mean and variance of
the target values are set equal to 0 and 1 respectively. This is
recommended for cases where zero-mean, unit-variance priors are used.
Note that, in this implementation, the normalisation is reversed
before the GP predictions are reported.
.. versionchanged:: 0.23
copy_X_train : bool, default=True
If True, a persistent copy of the training data is stored in the
object. Otherwise, just a reference to the training data is stored,
which might cause predictions to change if the data is modified
externally.
random_state : int or RandomState, default=None
Determines random number generation used to initialize the centers.
Pass an int for reproducible results across multiple function calls.
See :term: `Glossary <random_state>`.
Attributes
----------
X_train_ : array-like of shape (n_samples, n_features) or list of object
Feature vectors or other representations of training data (also
required for prediction).
y_train_ : array-like of shape (n_samples,) or (n_samples, n_targets)
Target values in training data (also required for prediction)
kernel_ : kernel instance
The kernel used for prediction. The structure of the kernel is the
same as the one passed as parameter but with optimized hyperparameters
L_ : array-like of shape (n_samples, n_samples)
Lower-triangular Cholesky decomposition of the kernel in ``X_train_``
alpha_ : array-like of shape (n_samples,)
Dual coefficients of training data points in kernel space
log_marginal_likelihood_value_ : float
The log-marginal-likelihood of ``self.kernel_.theta``
Examples
--------
>>> from sklearn.datasets import make_friedman2
>>> from sklearn.gaussian_process import GaussianProcessRegressor
>>> from sklearn.gaussian_process.kernels import DotProduct, WhiteKernel
>>> X, y = make_friedman2(n_samples=500, noise=0, random_state=0)
>>> kernel = DotProduct() + WhiteKernel()
>>> gpr = GaussianProcessRegressor(kernel=kernel,
... random_state=0).fit(X, y)
>>> gpr.score(X, y)
0.3680...
>>> gpr.predict(X[:2,:], return_std=True)
(array([653.0..., 592.1...]), array([316.6..., 316.6...]))
"""
@_deprecate_positional_args
def __init__(self, kernel=None, *, alpha=1e-10,
optimizer="fmin_l_bfgs_b", n_restarts_optimizer=0,
normalize_y=False, copy_X_train=True, random_state=None):
self.kernel = kernel
self.alpha = alpha
self.optimizer = optimizer
self.n_restarts_optimizer = n_restarts_optimizer
self.normalize_y = normalize_y
self.copy_X_train = copy_X_train
self.random_state = random_state
def fit(self, X, y):
"""Fit Gaussian process regression model.
Parameters
----------
X : array-like of shape (n_samples, n_features) or list of object
Feature vectors or other representations of training data.
y : array-like of shape (n_samples,) or (n_samples, n_targets)
Target values
Returns
-------
self : returns an instance of self.
"""
if self.kernel is None: # Use an RBF kernel as default
self.kernel_ = C(1.0, constant_value_bounds="fixed") \
* RBF(1.0, length_scale_bounds="fixed")
else:
self.kernel_ = clone(self.kernel)
self._rng = check_random_state(self.random_state)
if self.kernel_.requires_vector_input:
X, y = self._validate_data(X, y, multi_output=True, y_numeric=True,
ensure_2d=True, dtype="numeric")
else:
X, y = self._validate_data(X, y, multi_output=True, y_numeric=True,
ensure_2d=False, dtype=None)
# Normalize target value
if self.normalize_y:
self._y_train_mean = np.mean(y, axis=0)
self._y_train_std = np.std(y, axis=0)
# Remove mean and make unit variance
y = (y - self._y_train_mean) / self._y_train_std
else:
self._y_train_mean = np.zeros(1)
self._y_train_std = 1
if np.iterable(self.alpha) \
and self.alpha.shape[0] != y.shape[0]:
if self.alpha.shape[0] == 1:
self.alpha = self.alpha[0]
else:
raise ValueError("alpha must be a scalar or an array"
" with same number of entries as y.(%d != %d)"
% (self.alpha.shape[0], y.shape[0]))
self.X_train_ = np.copy(X) if self.copy_X_train else X
self.y_train_ = np.copy(y) if self.copy_X_train else y
if self.optimizer is not None and self.kernel_.n_dims > 0:
# Choose hyperparameters based on maximizing the log-marginal
# likelihood (potentially starting from several initial values)
def obj_func(theta, eval_gradient=True):
if eval_gradient:
lml, grad = self.log_marginal_likelihood(
theta, eval_gradient=True, clone_kernel=False)
return -lml, -grad
else:
return -self.log_marginal_likelihood(theta,
clone_kernel=False)
# First optimize starting from theta specified in kernel
optima = [(self._constrained_optimization(obj_func,
self.kernel_.theta,
self.kernel_.bounds))]
# Additional runs are performed from log-uniform chosen initial
# theta
if self.n_restarts_optimizer > 0:
if not np.isfinite(self.kernel_.bounds).all():
raise ValueError(
"Multiple optimizer restarts (n_restarts_optimizer>0) "
"requires that all bounds are finite.")
bounds = self.kernel_.bounds
for iteration in range(self.n_restarts_optimizer):
theta_initial = \
self._rng.uniform(bounds[:, 0], bounds[:, 1])
optima.append(
self._constrained_optimization(obj_func, theta_initial,
bounds))
# Select result from run with minimal (negative) log-marginal
# likelihood
lml_values = list(map(itemgetter(1), optima))
self.kernel_.theta = optima[np.argmin(lml_values)][0]
self.log_marginal_likelihood_value_ = -np.min(lml_values)
else:
self.log_marginal_likelihood_value_ = \
self.log_marginal_likelihood(self.kernel_.theta,
clone_kernel=False)
# Precompute quantities required for predictions which are independent
# of actual query points
K = self.kernel_(self.X_train_)
K[np.diag_indices_from(K)] += self.alpha
try:
self.L_ = cholesky(K, lower=True) # Line 2
# self.L_ changed, self._K_inv needs to be recomputed
self._K_inv = None
except np.linalg.LinAlgError as exc:
exc.args = ("The kernel, %s, is not returning a "
"positive definite matrix. Try gradually "
"increasing the 'alpha' parameter of your "
"GaussianProcessRegressor estimator."
% self.kernel_,) + exc.args
raise
self.alpha_ = cho_solve((self.L_, True), self.y_train_) # Line 3
return self
def predict(self, X, return_std=False, return_cov=False):
"""Predict using the Gaussian process regression model
We can also predict based on an unfitted model by using the GP prior.
In addition to the mean of the predictive distribution, also its
standard deviation (return_std=True) or covariance (return_cov=True).
Note that at most one of the two can be requested.
Parameters
----------
X : array-like of shape (n_samples, n_features) or list of object
Query points where the GP is evaluated.
return_std : bool, default=False
If True, the standard-deviation of the predictive distribution at
the query points is returned along with the mean.
return_cov : bool, default=False
If True, the covariance of the joint predictive distribution at
the query points is returned along with the mean
Returns
-------
y_mean : ndarray of shape (n_samples, [n_output_dims])
Mean of predictive distribution a query points
y_std : ndarray of shape (n_samples,), optional
Standard deviation of predictive distribution at query points.
Only returned when `return_std` is True.
y_cov : ndarray of shape (n_samples, n_samples), optional
Covariance of joint predictive distribution a query points.
Only returned when `return_cov` is True.
"""
if return_std and return_cov:
raise RuntimeError(
"Not returning standard deviation of predictions when "
"returning full covariance.")
if self.kernel is None or self.kernel.requires_vector_input:
X = check_array(X, ensure_2d=True, dtype="numeric")
else:
X = check_array(X, ensure_2d=False, dtype=None)
if not hasattr(self, "X_train_"): # Unfitted;predict based on GP prior
if self.kernel is None:
kernel = (C(1.0, constant_value_bounds="fixed") *
RBF(1.0, length_scale_bounds="fixed"))
else:
kernel = self.kernel
y_mean = np.zeros(X.shape[0])
if return_cov:
y_cov = kernel(X)
return y_mean, y_cov
elif return_std:
y_var = kernel.diag(X)
return y_mean, np.sqrt(y_var)
else:
return y_mean
else: # Predict based on GP posterior
K_trans = self.kernel_(X, self.X_train_)
y_mean = K_trans.dot(self.alpha_) # Line 4 (y_mean = f_star)
# undo normalisation
y_mean = self._y_train_std * y_mean + self._y_train_mean
if return_cov:
v = cho_solve((self.L_, True), K_trans.T) # Line 5
y_cov = self.kernel_(X) - K_trans.dot(v) # Line 6
# undo normalisation
y_cov = y_cov * self._y_train_std**2
return y_mean, y_cov
elif return_std:
# cache result of K_inv computation
if self._K_inv is None:
# compute inverse K_inv of K based on its Cholesky
# decomposition L and its inverse L_inv
L_inv = solve_triangular(self.L_.T,
np.eye(self.L_.shape[0]))
self._K_inv = L_inv.dot(L_inv.T)
# Compute variance of predictive distribution
y_var = self.kernel_.diag(X)
y_var -= np.einsum("ij,ij->i",
np.dot(K_trans, self._K_inv), K_trans)
# Check if any of the variances is negative because of
# numerical issues. If yes: set the variance to 0.
y_var_negative = y_var < 0
if np.any(y_var_negative):
warnings.warn("Predicted variances smaller than 0. "
"Setting those variances to 0.")
y_var[y_var_negative] = 0.0
# undo normalisation
y_var = y_var * self._y_train_std**2
return y_mean, np.sqrt(y_var)
else:
return y_mean
[docs] def sample_y(self, X, n_samples=1, random_state=0):
"""Draw samples from Gaussian process and evaluate at X.
Parameters
----------
X : array-like of shape (n_samples, n_features) or list of object
Query points where the GP is evaluated.
n_samples : int, default=1
The number of samples drawn from the Gaussian process
random_state : int, RandomState, default=0
Determines random number generation to randomly draw samples.
Pass an int for reproducible results across multiple function
calls.
See :term: `Glossary <random_state>`.
Returns
-------
y_samples : ndarray of shape (n_samples_X, [n_output_dims], n_samples)
Values of n_samples samples drawn from Gaussian process and
evaluated at query points.
"""
rng = check_random_state(random_state)
y_mean, y_cov = self.predict(X, return_cov=True)
if y_mean.ndim == 1:
y_samples = rng.multivariate_normal(y_mean, y_cov, n_samples).T
else:
y_samples = \
[rng.multivariate_normal(y_mean[:, i], y_cov,
n_samples).T[:, np.newaxis]
for i in range(y_mean.shape[1])]
y_samples = np.hstack(y_samples)
return y_samples
[docs] def log_marginal_likelihood(self, theta=None, eval_gradient=False,
clone_kernel=True):
"""Returns log-marginal likelihood of theta for training data.
Parameters
----------
theta : array-like of shape (n_kernel_params,) default=None
Kernel hyperparameters for which the log-marginal likelihood is
evaluated. If None, the precomputed log_marginal_likelihood
of ``self.kernel_.theta`` is returned.
eval_gradient : bool, default=False
If True, the gradient of the log-marginal likelihood with respect
to the kernel hyperparameters at position theta is returned
additionally. If True, theta must not be None.
clone_kernel : bool, default=True
If True, the kernel attribute is copied. If False, the kernel
attribute is modified, but may result in a performance improvement.
Returns
-------
log_likelihood : float
Log-marginal likelihood of theta for training data.
log_likelihood_gradient : ndarray of shape (n_kernel_params,), optional
Gradient of the log-marginal likelihood with respect to the kernel
hyperparameters at position theta.
Only returned when eval_gradient is True.
"""
if theta is None:
if eval_gradient:
raise ValueError(
"Gradient can only be evaluated for theta!=None")
return self.log_marginal_likelihood_value_
if clone_kernel:
kernel = self.kernel_.clone_with_theta(theta)
else:
kernel = self.kernel_
kernel.theta = theta
if eval_gradient:
K, K_gradient = kernel(self.X_train_, eval_gradient=True)
else:
K = kernel(self.X_train_)
K[np.diag_indices_from(K)] += self.alpha
try:
L = cholesky(K, lower=True) # Line 2
except np.linalg.LinAlgError:
return (-np.inf, np.zeros_like(theta)) \
if eval_gradient else -np.inf
# Support multi-dimensional output of self.y_train_
y_train = self.y_train_
if y_train.ndim == 1:
y_train = y_train[:, np.newaxis]
alpha = cho_solve((L, True), y_train) # Line 3
# Compute log-likelihood (compare line 7)
log_likelihood_dims = -0.5 * np.einsum("ik,ik->k", y_train, alpha)
log_likelihood_dims -= np.log(np.diag(L)).sum()
log_likelihood_dims -= K.shape[0] / 2 * np.log(2 * np.pi)
log_likelihood = log_likelihood_dims.sum(-1) # sum over dimensions
if eval_gradient: # compare Equation 5.9 from GPML
tmp = np.einsum("ik,jk->ijk", alpha, alpha) # k: output-dimension
tmp -= cho_solve((L, True), np.eye(K.shape[0]))[:, :, np.newaxis]
# Compute "0.5 * trace(tmp.dot(K_gradient))" without
# constructing the full matrix tmp.dot(K_gradient) since only
# its diagonal is required
log_likelihood_gradient_dims = \
0.5 * np.einsum("ijl,jik->kl", tmp, K_gradient)
log_likelihood_gradient = log_likelihood_gradient_dims.sum(-1)
if eval_gradient:
return log_likelihood, log_likelihood_gradient
else:
return log_likelihood
def _constrained_optimization(self, obj_func, initial_theta, bounds):
if self.optimizer == "fmin_l_bfgs_b":
opt_res = scipy.optimize.minimize(
obj_func, initial_theta, method="L-BFGS-B", jac=True,
bounds=bounds)
_check_optimize_result("lbfgs", opt_res)
theta_opt, func_min = opt_res.x, opt_res.fun
elif callable(self.optimizer):
theta_opt, func_min = \
self.optimizer(obj_func, initial_theta, bounds=bounds)
else:
raise ValueError("Unknown optimizer %s." % self.optimizer)
return theta_opt, func_min
def _more_tags(self):
return {'requires_fit': False}


Fun Facts About the Moon
- The dark side of the moon is a myth (not true) all of the moon receives the same amount of sunlight just that the earth doesn't see all of the moon
- Waves in the ocean are caused by the moon because of its gravitational pull (think of it like a magnet and the water is the thing getting pulled by the magnet)
- The moon is getting further from the earth it is drifting 3.8 cm every year in 50 billion years the moon will take 47 years to orbit the earth instead of the current 27.3 days now
- The moon has been walked by 12 people all american males last time in 1972 since then all unmanned vehicles have visited the moon
- The first craft to land on the moon was the Luna 1 in 1959
- If all goes to plan the next person to walk on the moon will be in 2019
- During the 1950s the USA considered detonating a nuclear bomb on the moon to show power


I am a problem solver.
I spent 16 years working in mental health, helping others solve their problems. Eventually I came to the
realization that while I loved helping clients through their problems, ultimately I had no control over the
final outcome.
What I love most about being a software developer is that I have the ability to solve any problem. I still
have the satisfaction of breaking something apart and trying to understand what the issue is. Now, I also
get to solve that problem. There is something so incredibly satisfying about not only being able to
understand the problem, but being able to create a solution and implement it.
Software development has allowed me to expand upon a part of my previous career that I enjoyed most
while
also providing the ability to directly solve a problem.
(January 2010 – September 2017) Billing Specialist (Part-time)
(January 2010 – July 2015) Counselor (Part-time)
(April 2008 – January 2010) Office Manager (Full-time)
For my front-end capstone at Nashville Software School I created Dram. Dram is a single page whiskey tasting application which allows users to participate in live whiskey tastings, view and share their reviews instantly, and provide searchable historical data. I built the application using React and used reactstrap for styling. Dram was tested at a live whiskey tasting in which 10 people utilized the application to participate in a blind tasting while saving their ratings and reviews.
I built a project with 4 teammates that was a social media platform called Nutshell. This was our third group project at Nashville Software School and we used HTML, CSS, Javascript, CRUD functionality, API fetch calls, Flexbox, Visual Studio Code, Git, Github, http-server, json-server, Bootstrap, Grunt, and Browserify to build the website. During this project I learned to use more GitHub features including creating, reading, and completing issues, and card flow in the project session. I also gained experience using Browserify and Bootstrap in building a website.
For my back-end capstone at Nashville Software School I created 1000Words. 1000Words is an interactive photo album which allows users to talk about their photos and tag them with keywords using speech-to-text technology. 1000Words allows users to search through all of their photos quickly using only keywords or dates, significantly decreasing the amount of time needed to find photos. I built the application using C#, ASP.Net MVC, Entity Framework, Identity Framework, Recorder.js, and Google Cloud Speech-to-Text API.