The response from an API which returns the result of a query
Operator that takes an Observable string value
and debounces it by the time
parameter, and checks that the value changes.
When the debounce completes the queryMethod
is called and the result returned.
The response from an API which returns the result of a query
The time to debounce the query by
The method that returns the search
An Observable value of T
Operator that is only executed on the first emission from an Observable The operator is passed a callback which is then executed
The value type of the Observable
The callback to be executed when this operator is run
An Observable value of T
Generated using TypeDoc
A function passed to debounceWithQuery as the second parameter, takes a string from an Observable source and returns an observable result of T


YAML Files¶
Models and communication between models during are specified by the user in one or more YAML files. YAML files have a human readable structure that can be parsed by many different programming languages to recreate data structures. While the YAML language can express very complex data structures (more information can be found here), only a few key concepts are needed to create a YAML file for use with the cis_interface framework.
- Indentation: Entries with the same indentation belong to the same collection.
- Sequences: Entries that begin with a dash and a space (- ) are members of a sequence collection. Members of a sequence can be text, collections, or a mix of both.
- Mappings: Mapping entries use a colon and a space (: ) to seperate a
key: value
pair. Keys are text and values can be text or a collection.
Model Options¶
At the root level of a cis_interface YAML, should be a mapping key model:
or models:
. This denotes information pertaining to the model(s) that should
be run. The value for this key can be a single model entry:
models:
name: modelA
language: python
args: ./src/gs_lesson4_modelA.py
or a sequence of model entries:
models:
- name: modelA
language: python
args: ./src/gs_lesson4_modelA.py
- name: modelB
language: c
args: ./src/gs_lesson4_modelB.c
At a minimum, each model entry should contain the following keys:
| Key | Description | |
|---|---|---|
| name | Unique name used to identify the model. This will be used to report errors associated with the model. | |
| language | The language that the model is written in. Valid values include: | |
| Value | Description | |
| executable | The model is a pre-compiled executable. | |
| python | The model is written in Python. | |
| matlab | The model is written in Matlab. | |
| c | The model is written in C. | |
| c++/c | The model is written in C++. | |
| make | The model is written in C/C++ and has a Makefile. | |
| cmake | The model is written in C/C++ and has a CMakeLists.txt | |
| lpy | The model is an LPy lsystem model. | |
| args | The full path to the file containing the model program that will be run by the driver or a list starting with the program file and including any arguments that should be passed as input to the program. | |
| inputs | A mapping object containing the entry for a model input channel or a list of input channel entries. If the model does not get input from another model, this may be ommitted. | |
| outputs | A mapping object containing the entry for a model output channel or a list of output channel entries. If the model does not output to another model, this may be ommitted. |
Models entries can also have the following optional keys:
| Key | Description |
|---|---|
| is_server | If True , this model will be considered to function as a
server for one or more models. The corresponding channel that
should be passed to the cis_interface API will be the name of
the model. |
| client_of | The names of one or more models that this model will call as a
server. If there are more than one, this should be specified as
a sequence collection. The corresponding channel(s) that should
be passed to the cis_interface API will be the name of the
server model joined with the name of the client model with an
underscore <server_model>_<client_model> . There will be one
channel created for each server the model is a client of. |
Communication Options¶
There are two options for specifying communication channels for the models. One specifying the connections between communication channels and one explicitly specifying the drivers.
Connection Method¶
To specify communication via connections, each input/output entry for the models need only contain a unique name for the communication channel. This can be specified as text:
input: channel_name
or a key, value mapping:
input:
name: channel_name
The key/value mapping form should be used when other information about the communication channel needs to be provided (e.g. message format, field names, units).
When using the connection format for specifying communication patterns, the
YAML also needs to contains a connections
key at the same level as the
models
key.
Connection Options¶
The coordesponding value for the connections
key should be one or more
mapping collections with the following keys:
| Key | Description |
|---|---|
| input/input_file | The channel/file that messages should be recieved from. To
specify a model channel, this should be the name of an
entry in a model’s outputs section. If this is a file,
it should be the absolute path to the file or the relative
path to the file from the directory containing the YAML. |
| output/output_file | The channel/file that messages recieved from the input
channel/file should be sent to. If the input value is
a file, the output value cannot be a file. To specify
a model channel, this should be the name of an entry in a
model’s inputs section. |
Connection mappings can also have the following optional keys:
| Key | Description | |
|---|---|---|
| translator | One or more functions that should be used to tranlate messages from the connection input before passing it alone to the connection output. Translators should be specified as strings with the format “<package.module>:<function>” such that <function> can be imported from <package>. | |
| format_str | A C-style format string specifying how messages should be formatted/parsed from/to language specifying types (see C-Style Format Strings). | |
| field_names | A sequence collection of names for the fields present in the format string. | |
| field_units | A sequence collection of units for the fields present in the format string (see Units). | |
| as_array | True or False. If True and filetype is table, the table will be read in it’s entirety and passed as an array. | |
| filetype | Only valid for connections that direct messages from a file to a model input channel or from a model output channel to a file. Values indicate how messages should be read from the file and include: | |
| Value | Description | |
| binary | The entire contents of the file are read as a single message. This is the default if not provided. | |
| ascii | The contents of the file are read one line at a time. | |
| table | The file is assumed to be an ASCII table and read one row at a time. The format of the table is either read from the header or inferred from the table. | |
| pandas | The file is a table created from a Pandas data frame. | |
| ply | The file contains a 3D structure in Ply format. | |
| obj | The file contains a 3D structure in Obj format. |
The connection entries are used to determine which driver should be used to connect communication channels/files. Any additional keys in the connection entry will be passed to the input/output driver that is created for the connection. A full description of the available input/output drivers and potential arguments can be found here.
Driver Method¶
In specifying communication via drivers, each input/output entry for the models should be a mapping collection with, at minimum, the following keys:
| Key | Description |
|---|---|
| name | The name of the channel that will be provided by the model to the cis_interface API. This can be any text, but should be unique. |
| driver | The name of the input/output driver class that should be used. A list of available input/output drivers can be found here. |
| args | For connections made to other models, this should be text that matches that of the other model’s corresponding driver. For connections made to files, this should be the path to the file, relative to the location of the YAML file. |
Any additional keys in the input/output entry will be passed to the input/output driver. A full description of the available input/output drivers and potential arguments can be found here.
Validation¶
|yggdrasil| uses a JSON schema to validate the provided
YAML specification files. If you would like to validate a set of YAML specification
files without running the integration, this can be done via the yggvalidate
CLI.:
$ yggvalidate name1.yml name2.yml ...


System Commands
Alfred includes a very useful set of system commands so that you can quickly control macOS directly from your keyboard.
In this section, you'll find out about:
Using System Commands in Alfred
The System Commands keywords allow you to tell your Mac to perform an action without having to use the mouse to find a menu item in macOS.
The following actions can be performed by using the associated keyword. Each keyword can be customised in Alfred's Preferences under Features > System and some actions include an optional confirmation pop-up.
- Screen Saver
- Show Trash
- Empty Trash
- Log Out
- Sleep
- Sleep Displays
- Lock
- Restart
-
Shut Down
- Hide (applications)
- Quit (applications)
- Force Quit (applications)
-
Quit All (applications)
- Volume Up
- Volume Down
-
Toggle Mute
- Eject (Local Mounted Volumes)
- Eject All
Want to lock your screen without returning to the login screen?
Launch System Preferences, go to Security & Privacy > General, and check the box to "require password X minutes after sleep or screen saver begins". Using the "screensaver" keyword will now lock your screen, requiring a password to unlock.
If you prefer this to the default Lock action, you can even disable the Lock action and change the screensaver keyword to "lock".
Using the Eject and Eject All commands
The Eject and Eject All actions have additional optional settings.
Setting media types to eject
By default, Alfred will look for local mounted volumes when you use the Eject action; This includes USB drives, DVDs and mounted images.
You can change the type of media included in your Eject list, changing to scope to only removable media, or to more broadly include mounts in /Volumes/ as well.
Adding volumes to a blacklist
If there are any volumes you want to avoid ejecting by mistake, these can be added to your blacklist. Simply click the + button in the bottom right and type the name of the volume you'd like Alfred to exclude from the Eject list.
Wildcards (using the asterisk *) and simple character classes (e.g. [Bb]ackup) can be used for volumes where the name can vary.
You can remove the volume later on by selecting it and pressing the - button, and can reset the original blacklist with the Reset button.


Use WASD keys to create art. Just mess around and see what happens.
Note: Watch out, Twitter share might get blocked as a popup.
Note Two: If you create big pieces or art it will only be proper replayable on a screen equally large or larger than yours.


To filter datasets by their category, on the Datasets page, click the Category: All dropdown and then select a category.
To filter datasets by their delivery options, on the Datasets page, click the Delivery Options: All dropdown and then select a delivery option.


This graphic will show the weaknesses of non-unified measurement sources, and publisher tracking. It will also show improved Facebook measurement with this data, and therefore more accurate cross-channel attribution (less attribution to direct). Note: We support custom channel attribution logic.


Software engineer at @ilegra
About
Archive
@mail
@twitter
@linkedin
@github
© 2018. All rights reserved.
Joel Corrêa
Blog
20 May 2018 -
A better decision making framework
15 Apr 2016 -
LXC - Linux Containers
05 May 2015 -
Designing a State Machine without conditionals
03 Apr 2015 -
Facebook - React JS
15 Mar 2015 -
Netflix Stack - Turbine
15 Mar 2015 -
Netflix Stack - Simian army
15 Mar 2015 -
Netflix Stack - Ribbon
15 Mar 2015 -
Netflix Stack - Hystrix
15 Mar 2015 -
Netflix Stack
15 Mar 2015 -
Amazon AWS Stack
14 Mar 2015 -
Google Guice
10 Jan 2015 -
Requirement patterns catalog
10 Jan 2015 -
Twitter highlights
04 Jan 2015 -
Requirement pattern concepts
02 Jan 2015 -
Contents of requirement specifications
02 Jan 2015 -
Agile production
28 Dec 2014 -
Webservices API styles
26 Dec 2014 -
Architectural analysis
20 Dec 2014 -
Wildfly 8
20 Dec 2014 -
Java 8
20 Dec 2014 -
Enterprise integration patterns
19 Dec 2014 -
Property-based testing
18 Dec 2014 -
Service discovery
18 Dec 2014 -
Apache ZooKeeper
17 Dec 2014 -
Requirement patterns - Introduction
16 Dec 2014 -
Lean architecture - Introduction
15 Dec 2014 -
Service design patterns - Web services
06 Dec 2014 -
Spring 4
30 Nov 2014 -
Architectural requirements
08 Nov 2014 -
Architectural styles
03 Nov 2014 -
Architecture oriented development
19 Oct 2014 -
Gatling
31 Aug 2014 -
Kibana
31 Aug 2014 -
ELK Platform
25 Aug 2014 -
Logstash
24 Aug 2014 -
Elastic Search
24 Aug 2014 -
CouchBase
24 Aug 2014 -
Big Data / NoSQL Reference
24 Aug 2014 -
Apache Spark
24 Aug 2014 -
Apache Mesos


Register for the next Beginning Teen Astronomy Camp
The next Beginning Teen Astronomy Camp is scheduled for
June 10-16, 2019
Students should be between the ages of 13 and 15 years. Some exceptions are made in special circumstances by Dr. McCarthy, the Camp Director.
Reservations are limited to 25 students. Completed applications are being accepted on a first-come, first-served basis. Students are required to contact Dr. McCarthy before applying.
June 10-16, 2019
Students should be between the ages of 13 and 15 years. Some exceptions are made in special circumstances by Dr. McCarthy, the Camp Director.
Reservations are limited to 25 students. Completed applications are being accepted on a first-come, first-served basis. Students are required to contact Dr. McCarthy before applying.
Astronomy Campers get a behind the scenes look at the Steward Observatory Mirror Lab.
Parents
Before Applying, you must consider your child's transportation to and from Astronomy Camp. We require
that students arrive in Tucson on the first day (June 10) of Camp before 3 pm Tucson time. On the last day (June 16),
we will be driving two hours from a remote mountain site to Tucson, so students cannot depart on airline flights any
earlier than 2:00 pm Tucson time. Limitations in airline schedules may make these arrangements difficult depending on your location.
Although we can accommodate a few students arriving one day early and/or departing one day late, such arrangements are inconvenient and
will necessitate additional cost to you.
Please email Dr. McCarthy, if you have travel concerns and questions.
Also, please note the following:
Please email Dr. McCarthy, if you have travel concerns and questions.
Also, please note the following:
- The tuition fee of $1100 includes all expenses during the Camp session such as room, board, materials, and local travel.
- Scholarships are available in case of financial need. Please include the Scholarship Form in your application.
- Travel arrangements must be confirmed with Dr. McCarthy no later than April 15.
- Scholarship notification will made no later than March 4.
To Apply
In order to apply, first email Dr. McCarthy to confirm space is available and then mail the following five items in a single mailing to the address shown below. We will then send you follow-up information.
The remainder of the $1100 tuition fee must be received no later than April 15.
Cancellation after this date will result in a forfeiture of 50% of the tuition fee.
Mail the above five items together to:
- Parents: Please read the above admonition about travel to/from Tucson.
- The completed application form
- A handwritten, 500 word essay on "Why I Want to Attend Astronomy Camp," including a description of the kinds of celestial objects you hope to study at Camp
- Your deposit in the amount of $250 (payable to Astronomy Camp) unless you are a scholarship applicant. [The full tuition is $1100; $50 is a non-refundable handling fee.]
- The signed disclaimer form
- Scholarship Application form (if necessary).
Mail the above five items together to:
Dr. Don McCarthy
Beginning Astronomy Camp for Teens
Steward Observatory
933 N. Cherry Ave.
Tucson, AZ 85721-0065
Beginning Astronomy Camp for Teens
Steward Observatory
933 N. Cherry Ave.
Tucson, AZ 85721-0065
Home | Information | Registration | Articles | Links
All Images, Media and Content - Copyright © 2019 Astronomy Camp
Site Design by Jacob Omann. Maintained by Astronomy Camp. Updated December 28, 2018
All Images, Media and Content - Copyright © 2019 Astronomy Camp
Site Design by Jacob Omann. Maintained by Astronomy Camp. Updated December 28, 2018


[gecode-users] Using AFC in Gecode 4, more
Kish Shen
kisshen at cisco.com
Tue Jul 9 04:20:22 CEST 2013
Hi,
I probably posted my last message too quickly. I suspect I might not
have given enough background for what I mean by 'doing search in ECLiPSe'.
ECLiPSe use 'events' to record any changes to the Gecode state -- adding
variables, adding propagators, setting a variable to a value, removing a
value from a variable, i.e. events are used to set up the problem, as
well as the 'search'. When the search is done in ECLiPSe,
then the setting (and removal) of values are done at the ECLiPSe level,
and Gecode is updated using events, i.e. the search is not done using
Gecode branching. Rather, branching is done at the ECLiPSe level as part
of a normal Prolog search-tree, and the recomputation/cloning of space
is explicitly managed by ECLiPSe, using events to recompute from the
nearest clone.
Hope this short explanation is enough to convey the essentials of how
search is done in ECLiPSe...
Cheers,
Kish
More information about the users
mailing list


This theme will look great on any device, no matter the size!
Featuring the latest build of the new Bootstrap 4 framework!
Ready to use with your own content, or customize the source files!
Posted by Start Bootstrap on August 24, 2018


Data ReadThis utility will create the selected object using data from the text box to the right. The data needs to contain columns of data as follows:{latitude(degs)} {longitude(degs)} [{altitude(meters)} {name}]NOTE: [{altitude} and {name}] are optional, altitude will default to 0 if not included.AreaTargetLineTarget Targets MTO (single track) MTO (points) VO Primitive (Line) |


Syllabus
Teacher Contact Info
Clinton Dreisbach<EMAIL_ADDRESS>(919) 360-9150 – call after 5 PM for emergencies only
Schedule
Class is from September 15 to December 12, 2014.
Lecture is from 9 AM to 12:30 PM Monday-Thursday, with breaks during that time. Depending on the topic, we may end early.
Lab is from 1 PM to 5 PM Monday-Thursday and 9 AM - 5 PM on Friday.
Office hours and one-on-one instruction
A teacher or TA will be available Monday-Friday from 9 AM to 5 PM at minimum. During lab time, you can schedule one-on-one time with either of us. After hours, we may be available in the classroom or in HipChat, which we use for group communication.
Holidays
We will take three days off for Thanksgiving, November 26-28th.
Topics
These topics are listed week-by-week. However, this list is not definitive and we will reorder things based off how the class is going.
Each list of topics is a list of things students should be comfortable with at the end of that week.
Week 1
By the end of this week, students should be comfortable with:
- Computational thinking
- Setting up your computer for development
- Writing Ruby programs
- Using objects in programming
- Getting input and producing output from a program
- Creating your own objects and classes
- Iteration and using blocks
Week 2
- Using Git and GitHub to manage source code
- Testing your code
- Inheritance
- Using modules
- Using external libraries
- Reading and writing simple regular expressions
Week 3
- Creating web pages with HTML & CSS
- Generating web sites using Middleman
- Using data in a file to dynamically create web pages
- Preprocessing Sass and using CSS libraries with the asset pipeline
- Deploying static web sites to GitHub pages
Week 4
- Starting Rails projects
- Using PostgreSQL to store data
- Using Rails models to manipulate data in a database
- Using Rails scaffolds to display models
- Making simple validations for models in Rails
- Building custom views in Rails
- Creating database migrations
- Querying for data in Rails
- Associating different models in Rails
- Using Rails' form helpers
- Testing Rails models
- Deploying Rails applications to Heroku
Week 5
- Using advanced Rails associations, including polymorphic associations
- Making advanced queries for subsets of data using SQL fragments
- Migrating existing data
- Sorting data from user input
- Building custom controllers in Rails
- Applying REST principles
- Displaying data in different formats
- Using filters in your controllers
- Using sessions to store data, such as login status
- Showing flash messages
- Making helpers for Rails views
- Building forms with SimpleForm
- Using alternatives to HTML + ERb for templating
- Testing Rails controllers
Week 6
- Writing JavaScript
- Using server-generated JavaScript responses to remotely submit data and update pages
- Using jQuery to script interactions
- Creating requests with Ajax
- Consuming APIs in JavaScript
- Testing applications from the outside-in with Capybara
- Using the asset pipeline to process JS and use external JS libraries
- Understanding CoffeeScript
Week 7
- Authenticating users
- Handling file uploads
- Paginating data
- Building APIs
- Some of the following:
- Tagging data
- Creating a favorites or rating system
- Adding search to your application
- Asynchronous processing
- Building drag-and-drop applications
- Resizing and cropping images
- Editing in-place
Week 8
- Building single-page applications
- Building web applications for mobile devices
Week 9
This week is a week for review and catch-up. Things will fall through the cracks during the previous 8 weeks, and so we have this week as a flex week to make sure we cover everything you need.
Week 10
During this week, you will be pitching your final project ideas, forming groups, and getting feedback. In class, we will cover some software development principles. You should be comfortable with:
- Breaking up features into distinct tasks to work on
- Estimating the size of programming tasks
- Using Agile development to run a project
Weeks 11-13
Yes, we have thirteen weeks in this course, because of the Thanksgiving holiday!
You will be working on your final project and presentation during this time.
Capstone Project
During the last three weeks of the course, you will be working on your capstone project, putting all you've learned into practice. You will be working by yourself, or with a group of 2-4 people on your project.
During week 10, you'll present your idea for a final project and get feedback, helping you scope the project. During weeks 11, 12, and 13, you'll work primarily on this project. We will have lecture time, but it will be tailored to what you need to know for your project and may be optional. We will let you know what days lecture is optional.
This project must use Ruby on Rails to build a web application of significant size, backed by a database and using some of the libraries we covered during class.
Materials
All students must bring their own MacBook laptop. Your MacBook should have a minimum of 4 GB of RAM and 128 GB of hard drive space. Those are minimum specs, and I recommend getting 8 GB of RAM and a 256 GB hard drive, but that’s your choice to make. Any of the current MacBook Air models or MacBook Pro models will work. I have a 13-inch MacBook Pro and really dig it.
Your MacBook must be running OS X Mavericks. Mavericks is a free upgrade from the App Store.
There is no commercial software required for the class, but you may want to purchase some. We are going to use a free text editor in class, Atom. We also have a classroom license you can use for RubyMine.
Policies
Absence policy
You can miss up to 4 lectures; after that, your enrollment in the job placement program is forfeit. I don't recommend missing any, as we will be moving very fast.
Late homework policy
Your homework is due by 6 AM on the day it is due. After that, it is late.
I would rather see a solid attempt on time than a complete assignment late. Solid attempts are not considered late.
Honor code
You are expected to do your own work. You should use all resources available to you, including open-source code, but copy and pasting open-source code is prohibited: you should use it only for inspiration or as a library in a bigger project.
Copying homework is taken very seriously and can result in forfeiting job placement.
Code of Conduct
Like the technical community as a whole, classes at The Iron Yard are made up of a mixture of people from all different backgrounds.
Diversity is one of our huge strengths, but it can also lead to communication issues and unhappiness. To that end, we have a few ground rules that we ask people to adhere to when they're taking a class at The Iron Yard. These rules apply equally to teachers, students, other staff, and guest lecturers.
This isn't an exhaustive list of things that you can't do. Rather, take it in the spirit in which it's intended - a guide to make it easier to enrich all of us, the technical communities in which we participate.
This code of conduct applies to all communication: this includes in class, HipChat, email, and other forums such as Skype, Google+ Hangouts, etc.
If you believe someone is violating the code of conduct, we ask that you report it by talking to your teacher. If you do not feel comfortable talking to your teacher, speak with any Iron Yard teacher or campus director.
-
Be welcoming, friendly, and patient.
-
Be considerate. Your work will be used by other people, and you in turn will depend on the work of others. Any decision you take will affect your colleagues, and you should take those consequences into account when making decisions.
-
Be respectful. Not all of us will agree all the time, but disagreement is no excuse for poor behavior and poor manners. We might all experience some frustration now and then, but we cannot allow that frustration to turn into a personal attack. It's important to remember that a community where people feel uncomfortable or threatened is not a productive one. Members of the Iron Yard community should be respectful when dealing with other members as well as with people outside the Iron Yard community.
-
Be careful in the words that you choose. Be kind to others. Do not insult or put down other people. Behave professionally. Remember that harassment and sexist, racist, or exclusionary behavior are not appropriate for this class. This includes, but is not limited to:
- Violent threats or language directed against another person.
- Sexist, racist, or otherwise discriminatory jokes and language.
- Posting sexually explicit or violent material.

- Unwelcome sexual attention.
- Advocating for, or encouraging, any of the above behavior.
-
Repeated harassment of others. In general, if someone asks you to stop, then stop.
-
When we disagree, we try to understand why. Disagreements, both social and technical, happen all the time and The Iron Yard is no exception. It is important that we resolve disagreements and differing views constructively. Remember that we're different. The strength of The Iron Yard comes from its varied members, people from a wide range of backgrounds. Different people have different perspectives on issues. Being unable to understand why someone holds a viewpoint doesn't mean that they're wrong. Don't forget that it is human to err and blaming each other doesn't get us anywhere, rather offer to help resolving issues and to help learn from mistakes.
This text is taken from the Django project.


Gallery Images
Event Summary
Calaska Culture Camp had a remarkable 30 Aleut, Tlingit, and Haida Natives and their families. We started the day off with a talking circle introducing ourselves with our english name, native name, Eagle/Raven and what house we are from. We quickly learned how a lot of us are related through our ancestors.
When finished with the talking circle; the paint brushes, sand paper, planners and deer hide all began to form beautiful finished projects of drums, paddles, devil's club beaded necklaces and drum sticks.
The 10” deer rawhide drums were led by John Hannon and myself. This was the longest station because students have to stretch the rawhide lacing, punch holes in the rawhide with a hammer and awl, lace the rawhide through the holes around the round frame and tighten the lacing while forming a handle. The accomplishment of creating your very own art is very rewarding and calming when listening to your drum after it dries.
For the paddle making it is self taught with samples and someone to answer questions along the way. Devils club was gathered in Craig, Alaska and prepared for drumsticks and beads. Samples and demonstrations were shown at the beginning of camp.
Lunch was provided by the host consisting of a large pot of clam chowder, Smoked and plain packed Alaskan Salmon, Sailor boy hard tack,Soap berries and drinks. Thanks to the many donations of goodies provided by the students we had snacks and dessert. During lunch we watched The Bear Stands Up by Ester Shea of Ketchikan Alaska.
Some students were able to finish their drums and paddles enough to be able to paint designs. This was very rewarding to watch the excitement in the air as the students completed their work of art. The vibrations from the drums and drumsticks became the heartbeat of the hall.
At the end of the day we had a drawing with jars of fish, jams, peaches, to name a few.
A huge Thank You to Jay Silva, Shirley Ann Giannini, Robert and Anne Kennedy, John Hannon, for making this first Culture Camp a success. The hours of planning, preparing and watching it come together made it worth the while.
-DonnaRae James


QuantConnect's LEAN engine manages your portfolio and data feeds letting you focus on your algorithm strategy and execution.
Data is piped into your strategy via event handlers, upon which you can place trades. We provide basic portfolio management
and fill modelling underneath the hood automatically. This is provided by the QCAlgorithm
base class.
All algorithms extend QCAlgorithm
, which provides some key helper properties for you to use: Security Manager,
Portfolio Manager, Transactions Manager, Notification Manager and Scheduling Manager. Along with hundreds of helper methods
to make the API easy to use. We'll go into more detail on those below.
The Securities
property
get_Securities()
method is a dictionary of Security objects. Each asset
(equity, forex pair etc) in your algorithm has a security object. All the models for a security live on these objects:
e.g.
Securities["IBM"].FeeModel
or Securities["IBM"].Price
.
self.Securities["IBM"].FeeModel
or self.Securities["IBM"].Price
.
Portfolio
self.Portfolio
is a dictionary of SecurityHolding classes.
These classes track the individual portfolio items profit and losses, fees and quantity held. e.g.
Portfolio["IBM"].LastTradeProfit
self.Portfolio["IBM"].LastTradeProfit
.
Other helpers like Transactions
, Schedule
, Notify
, and Universe
have their
own helper methods which we'll explain below.


Image Gallery
IMG
Home
(current)
Features
Pricing
Contact
Dropdown link
Action
Another action
Something else here
Image Gallery
Calming images for your mind
Masonary


Product Search by Product Id
Product ID: {{productSearchResult.id}}
Name: {{productSearchResult.name}}
Description: {{productSearchResult.description}}
Price: {{productSearchResult.price}}
Available: {{productSearchResult.product_available}}
Hateoas Link: {{productSearchResult.link}}
Order successfully created
Id: {{orderCreatedResult.id}}
Total: {{orderCreatedResult.orderTotal}}
Status: {{orderCreatedResult.orderStatus}}
Hateoas Link: {{orderCreatedResult.link[0]}}
Hateoas Link: {{orderCreatedResult.link[1]}}
Order Status: {{orderStatus.orderStatus}}
Hateoas Link: {{orderStatus.link}}
Order Canceled
Hateoas Link: {{cancelResult.link}}
Order Search by Order Id
Order Id: {{ orderSearchResult.id}}
Total: {{ orderSearchResult.orderTotal}}
Status: {{ orderSearchResult.orderStatus}}
Hateoas Link: {{orderSearchResult.link[0]}}
Hateoas Link: {{orderSearchResult.link[1]}}
Hateoas Link: {{orderSearchResult.link[2]}}
Hateoas Link: {{orderSearchResult.link[3]}}
Customer Search by Cust Id
Customer Id: {{ customerSearchResult.id}}
First Name: {{ customerSearchResult.firstName}}
Last Name: {{ customerSearchResult.lastName}}
Phone: {{ customerSearchResult.phone}}
Hateoas Link: {{customerSearchResult.link[0]}}
Partner Search by Partner Id
Partner Id: {{ partnerSearchResult.id}}
Company: {{ partnerSearchResult.companyName}}
Address: {{ partnerSearchResult.address}}
Phone: {{ partnerSearchResult.phone}}
City: {{ partnerSearchResult.city}}
State: {{ partnerSearchResult.state}}
Postal Code: {{ partnerSearchResult.postalCode}}
Country: {{ partnerSearchResult.country}}
Phone: {{ partnerSearchResult.phone}}
Email: {{ partnerSearchResult.email}}
Hateoas Link: {{partnerSearchResult.link[0]}}
List All Partner Resources
Partner Id: {{ partnerSearchResult.id}}
Company: {{ partnerSearchResult.companyName}}
Address: {{ partnerSearchResult.address}}
Phone: {{ partnerSearchResult.phone}}
City: {{ partnerSearchResult.city}}
State: {{ partnerSearchResult.state}}
Postal Code: {{ partnerSearchResult.postalCode}}
Country: {{ partnerSearchResult.country}}
Phone: {{ partnerSearchResult.phone}}
Email: {{ partnerSearchResult.email}}
Hateoas Link: {{partnerSearchResult.link[0]}}


MoneyShot Media
Wallace Inc
Menu
Home
Packages
About Us
Sitemap
The Sitemap for the website.
MoneyShot Media | SiteMap


Lua compile and embed in Windows
First we will build Lua source code into a static library.
Download Lua source code from here. 5.3.5 is the latest version as of this writing.
Decompress the archive file lua-5.3.5.tar.gz
.
In Visual Studio 2015, click menu File
- New
- Project...
. In the dialog, click menu Templates
- Visual C++
- Empty Project
. In the Name:
textbox, enter the project name. In the Location:
textbox, enter where to put the project. In the Solution name:
textbox, enter the solution name. Click OK
button to create the project.
In the Solution Explorer
panel, right click the project name, click menu Properties
. In the Properties
dialog, click menu Configuration Properties
- General
. Set Target Name
to lua
. Set Target Extension
to .lib
. Set Configuration Type
to Static library (.lib)
.
In the Solution Explorer
panel, right click the project name, click menu Add...
- Existing items...
. Add all the files in the src
directory of Lua source code to the project, excluding lua.c
and luac.c
.
Click menu Build
- Configuration Manager...
. Set Active solution configuration
to Release
. Set Active solution platform
to x64
.
Build the project.
If the build is successful, the result file is x64/Release/lua.lib
.
Now we will use the static library in another project.
In Visual Studio 2015, create another Visual C++ empty project.
Create a lib
directory in the project directory. Put lua.lib
in it.
In the Solution Explorer
panel, right click the project name, click menu Properties
. In the Properties
dialog, click menu Configuration Properties
- C/C++
- General
. Add path of Lua source code's src
directory to Additional Include Directories
. In the Properties
dialog, click menu Configuration Properties
- Linker
- General
. Add path of the lib
directory containing lua.lib
to Additional Library Directories
. Click OK
button.
Click menu Build
- Configuration Manager...
. Set Active solution configuration
to Release
. Set Active solution platform
to x64
.
Create a main.c
file:
#pragma comment(lib, "lua.lib")
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
static int sum(lua_State *L)
{
// Get the number of arguments
int args_count = lua_gettop(L);
double args_sum = 0;
int i;
for (i = 1; i <= args_count; i++)
{
if (!lua_isnumber(L, i))
{
lua_pushstring(L, "Argument is not a number.");
lua_error(L);
}
args_sum += lua_tonumber(L, i);
}
lua_pushnumber(L, args_sum);
// Return the number of results
return 1;
}
int main(int argc, char *argv[])
{
lua_State* L = luaL_newstate();
luaL_openlibs(L);
lua_pushstring(L, "hello");
lua_setglobal(L, "GLOBAL_VALUE");
lua_register(L, "sum", sum);
luaL_dostring(L, "print('To run `demo.lua`')");
luaL_dofile(L, "demo.lua");
lua_close(L);
return 0;
}
Build the project.
If the build is successful, the result file is x64/Release/Demo.exe
(The file name depends on your project name.).
Create a demo.lua
file in the x64/Release
directory:
local sum_value = sum(1, 2, 3)
print("The sum is "..sum_value)
print("GLOBAL_VALUE is "..GLOBAL_VALUE)
Run Demo.exe
.
Demo.exe
will run demo.lua
.
We can see demo.lua
is able to access the global value GLOBAL_VALUE
and the sum
function defined in the C program.
Comments:


Welcome to the website of James's software shop! In here, you'll find all your software requirements are fulfilled. Please contact me for further information!
"We've seen it for ourselves! It's amazing!" - Google, 2019


coqos_add(1) Qualcomm Atheros Open Powerline Toolkit coqos_add(1) NAME coqos_add - Add a managed data stream SYNOPSIS coqos_add action priority rate ttl operand condition [condition] [...] [device] [...] DESCRIPTION This page is under construction. Add a managed stream to one or more powerline devices using the VS_CONN_ADD message. Consult the Qualcomm Atheros Firmware Technical Reference Manual for a description of this vendor specific message type. This program is part of the Qualcomm Atheros Powerline Toolkit. See the plc man page for an overview and installation instructions. BACKGROUND Bandwidth management prioritizes streams so that data from lowest priority stream is dropped first whenever one of the following conditions is detected. This ensures that the remaining streams continue operate at their full pontential. Degraded line condition The channel degrades to the point where the available PHY rate from the transmitter to the receiver is too low due to the variability of the power line.s characteristics. Over subscription Too much data is being sent per second, resulting in packet loss due to excessive collisions due to excessive channel oversubscription. Lack of channel Capacity On starting new source there is not enough channel capacity to support it. OPTIONS -e Redirects stderr messages to stdout. By convention progress messages and error messages are printed on stderr while primary program output is printed on stdout. This option prints all output on stdout in cases where this is desired. -i interface Select the host Ethernet interface. All requests are sent via this host interface and only reponses received via this host interface are recognized. The default interface is eth1 because most people use eth0 as their principle network connection; however, if environment string "PLC" is defined then it takes precedence over the default interface. This option then takes precedence over either default. -q Suppresses status messages on stderr. -r Display relative memory offsets on output. This option is the default. -v Prints additional information on stdout. In particular, this option dumps outgoing Ethernet packets on stdout. -?,--help Displays program help information on stderr. This option takes precedence over all other options on the command line except version information. -!,--version Displays program version information on stderr. This option takes precedence over all other options on the com‐ mand line except help information. Use this option when sending screen dumps to Atheros technical staff. ARGUMENTS action The action taken for frames that satisfy the selection criteria. Valid actions are "CAP0", "CAP1", "CAP2", "CAP3" to specify the channel access priority queue. CAP0 and CAP1 are for best effort data. CAP2 is for video and non urgent MMEs. CAP3 is for voice, urgent MMEs and control messages such as IGMP and MLD. priority The relative priority of this stream. Valid values are 0 through 15 where 0 is the lowest priority and 15 is the highest. destination The destination MAC address. rate The average expected data rate for this stream. Valid values are 1 to 9000 where units are in 10kbps so the mini‐ mum rate is 10kbps and the maximum rate is 90mbps. ttl The time to live for this stream. Valid values are 10000 to 2000000 where units are in microseconds so the mini‐ mum is time is 10 milliseconds and the maximum time is 2 seconds. operand The operand specifies the logical relationship between conditions before the action to be taken. Valid operands are listed and described under OPERANDS. condition A conditional expression consisting of a field, operator and value. See CONDITIONS for more information. device The MAC address of some powerline device. More than one address may be specified on the command line. If more than one address is specified then operations are performed on each device in turn. The default address is "local". See DEVICES for more information. CONDITIONS A condition consists of a field, an operator and a value. One condition is required but three are permitted. Condition order is not important but all conditions must appear after the operand and before the control. field The field is the part of the Ethernet frame to be examined. Some fields are not valid for some actions but this program does not enforce such rules since validation is performed by runtime firmware on each device. Recognized fields are listed and described under FIELDS. operator The operator specifies the relationsip that must exist between the field and value in order for the condition to evaluate True. Currently, only equality operators are supported. Valid operators are listed and described under OPERATORS. value The value must be appropriate to the field type. Some fields are MAC or IP addresses, some are integers, some are bitmaps and others are states. Integers and bitmaps may be expressed in binary, decimal or hexadecimal format. Binary values staRt with 0b. Hexadecimal values start with 0x. States are expressed using keywords. Users are responsible for knowing how many bits are significant for each type of value. Valid values are described along with fields under FIELDS. OPERANDS The operand indicates the logical relationship that must exist between conditions in the rule set before the action is applied to a frame. Operands are expressed as discrete alphanumeric strings entered in upper, lower or mixed character case. Failure to enter a known operand will result in an error message that lists all possible operands. They are posi‐ ton sensitive. One operand is allowed and it must appear after the action and before any condition. Any Apply the action to frames that satisfy any of the conditions. This is equivalent to the logical or operation. All Apply the action to frames that satisfy all of the conditions. This is equivalent to the logical and operation. Always Apply the action to all frames, regardless of any and all conditions that may be specified. FIELDS Fields indicate the portion of the frame that is inspected during selection and the size and format of the value permited in the condition statement. They are expressed as discrete alphanumeric strings entered in upper, lower or mixed charac‐ ter case. Failure to enter a known field will result in an error message that lists all possible fields. ET A 16-bit Ethertype expressed in decimal, hexadecimal or binary. The format is described in IEEE Standard 802-2001 [4]. EthDA A 48-bit Ethernet destination address expressed in hexadecimal. The format is described in IEEE Standard 802-2001 [4]. EthSA A 48-bit Ethernet source address expressed in hexadecimal. The format is described in IEEE Standard 802-2001 [4]. VLANUP An 8-bit Ethernet VLAN tag where the lower 3 bits are the User Priority sub-field of a VLAN Tag defined in IEEE Std 802.1Q-1998 (Virtual Bridged Local Area Networks) [11]. The upper 5 bits should be zero. VLANID A 16-bit VLAN identifier where the lower 12 bits are the VLAN Identifier (VID) defined in IEEE Std 802.1Q-1998 (Virtual Bridged Local Area Networks) [11]. The upper 4 bits should be zero. IPV4TOS An 8-bit Type-of-Service code where the format is defined in the RFC 791 (Internet Protocol) [14]. IPV4PROT An 8-bit Ethernet Protocol identifier. The format is defined in the RFC 791 (Internet Protocol) [14]. IPV4SA A 32-bit Internet Protocol source address expressed in dotted-decimal notation. The official format is defined in RFC 791 (Internet Protocol) [14]. Our implementation permits empty octets and leading zeros within fields. For example, "..." is equivalent to "<IP_ADDRESS> and "127..000.001" is equivalent to "<IP_ADDRESS>". IPV4DA A 32-bit Internet Protocol destination address expressed in dotted-decimal notation. The official format is defined in RFC 791 (internet Protocol) [14]. Our implementation permits empty octets and leading zeros within fields. For example, "..." is equivalent to "<IP_ADDRESS> and "127..000.001" is equivalent to "<IP_ADDRESS>". IPV6TC An 8-bit Internet Protocol V6 traffic class expressed as defined in RFC 2460 (Internet Protocol Version 6) [17]. IPV6FL A 24-bit IPV6 flow label where the lower 20 bits are the IPv6 Flow Label defined in RFC 2460 (Internat Protocol Version 6) [17]. The upper 4 bits should be zero. The value can be entered either as a decimal, binary or hex integer. IPV6SA A 128-bit IPV6 source address expressed as colon-separated hexadecmial quartets (octet pairs). The official for‐ mat is defined in RFC 2460 (Internet Protocol Version 6) [17]. Our implementation permits multiple empty fields, abreviated fields and leading zeros within fields. When multiple empty fields appear, only the right-most occu‐ rance expands to zeros. For example, "FFFF::DDDD::BBBB::AAAA" is equivalent to "FFFF:0000:DDDD:0000:BBBB:0000:0000:AAAA". IPV6DA A 128-bit IPV6 destination address expressed as colon-separated hexadecimal quartets (octet pairs). The official format is defined in RFC 2460 (Internet Protocol Version 6) [17]. Our implementation permits multiple empty fields, abbreviated fields and leading zeros within fields. When multiple empty fields appear, only the right- most occurance expands to zeros. For example, "AAAA::BBBB::CCCC::DDDD" is equivalent to "AAAA:0000:BBBB:0000:CCCC:0000:0000:DDDD". TCPSP A 16-bit TCP source port as a decimal integer. The format is defined in RFC 793 (Transmission Control Protocol [15]). TCPDP A 16-bit TCP destination port expressed as a decimal integer. The format is defined in RFC 793 (Transmission Con‐ trol Protocol [15]). UDPSP A 16-bit UDP source port expressed as a decimal integer. The format is defined in RFC 768 (User Datagram Protocol [13]). UDPDP A 16-bit UDP destination port expressed as a decimal integer. The format is defined in RFC 768 (User Datagram Protocol [13]). IPSP A 16-bit IP source port expressed as a decimal integer. This condition applies to either TCP or UDP packets, depending on the protocol used, and is valid only for actions "CAP0", "CAP1", "CAP2", "CAP3" and "Drop". IPDP A 16-bit IP destination port expressed as a decimal integer. This condition applies to either TCP or UDP packets, depending on the protocol used, and is valid only for actions "CAP0", "CAP1", "CAP2", "CAP3" and "Drop". MME A 24-bit Atheros HomePlugAV Management Message type expressed in hexadecimal. The first byte is the MMV and the next two bytes are the MMTYPE for a HomePlug AV frame as defined in the HomePlug AV Specification. The MMTYPE will match any MME sub-type (Request; Confirm; Indicate; Response). This field is only valid for action "Boost". OPERATORS An operator indicates an equality between a field and a value. An operator is an alphanumeric string entered in upper, lower or mixed character case. Failure to enter a known operator will result in an error message that lists all possible operators. Operators are position sensitive and must appear between each field and value. Is Indicates that the frame field must equal the associated value for the condition to evaluate true. Not Indicates that the frame field must not equal the associated value for the condition to true true. STATES A state is a special case of value. True,On,Yes,Present Indicates a positive state or presence of some entity. All are equivalent and can be used interchangeably. Dou‐ ble negatives are permitted so "Is True" is equvalent to "Not False". False,Off,No,Missing Indicates a negative state or absence of some entity. ALl are equivalent and can be used interchangeably. Double negatives are permitted so "Is False" is equvalent to "Not True". DEVICES Powerline devices use Ethernet Media Access Control (MAC) addresses. A MAC address is a 48-bit value entered as 12 hex‐ adecimal digits in upper, lower or mixed character case. Octets may be separated with colons for clarity. For example, "00b052000001", "00:b0:52:00:00:01" and "00b052:000001" are valid and equivalent. The following MAC addresses are common or special and may be entered by name instead of number. all Same as "broadcast". broadcast A synonym for the Ethernet broadcast address, FF:FF:FF:FF:FF:FF. All devices, whether local, remote or foreign recognize messages sent to this address. A remote device is any device at the far end of a powerline connection. A foreign device is any device not manufactured by Atheros. local A synonym for the Qualcomm Atheros vendor specific Local Management Address (LMA), 00:B0:52:00:00:01. All local Atheros devices recognize this address but remote and foreign devices do not. A remote device is any device at the far end of a powerline connection. A foreign device is any device not manufactured by Atheros. See the Qual‐ comm Atheros HomePlug AV Firmware Technical Reference Manual for more information. DISCLAIMER Atheros HomePlug AV Vendor Specific Management Message structure and content is proprietary to Qualcomm Atheros, Ocala FL USA. Consequently, public information may not be available. Qualcomm Atheros reserves the right to modify message structure and content in future firmware releases without any obligation to notify or compensate users of this program. EXAMPLES The following example adds a temporary stream to device 00:b0:52:BA:BE:01 which will then manage the bandwidth for that stream until removed with program coqos_rel. # coqos_add CAP2 15 5000 200000 any ethda is 192.168.105 00:B0:52:BA:BE:01 This adds a stream to the bandwidth manager that sets all traffic to destination address of <IP_ADDRESS> as priority 15 (the highest priority). This would then need to also be sent to each device on the network. Refer to int6krule for more details on how to specify conditions. SEE ALSO coqos_info(1), coqos_man(1), coqos_mod(1), coqos_rel(1) CREDITS Bill Wike<EMAIL_ADDRESS>Nathaniel Houghton<EMAIL_ADDRESS>Charles Maier<EMAIL_ADDRESS>open-plc-utils-0.0.3 November 2013 coqos_add(1)


propmitra is a new rental platform that makes it easier to find your new Rentals without paying any brokerage. Use our verified listing to ensure you find your dream Flat by contacting the owners directly. propmitra is a new Sale platform that makes it easier to Sale your Flats without paying any brokerage. please post a requirement and we'll send you email notification with properties matching your requirements.


Sextant provides an explore functionality that allows the exploration of a SPARQL endpoint. This feature supports three basic objectives:
To use the explore functionality we go to the Explore panel where we can provide the URI of a SPARQL endpoint and the Port it listens to, as shown in the figure below.
When we Connect to the endpoint we get a tree structure of the ontology Classes. Each class is represented with a button where we show the name of the class and the number of sub-classes it has, as shown in the figure below.
When we click on a class button, the class expands and we can view the button that can be used to retrieve all the properties of the class along with their range, the URI of the class and the sub-classes. In the figures below we show an example of these features. When the properties of a class are retrieved, the class button color changes to green, and the button is disabled.
Each of the URIs that appear in the explore panel can be resolved. When we click on a URI we will get a pop-up that describes the URI and presents all the triples in the endpoint that have this URI in the subject, predicate or object position, as shown in the figure below. Each of the URIs that appear in the describe pop-up are also resolvable and will update the window with the description of the chosen URI. In this manner we can explore our data using the links of the URIs.
In some cases we can also use the explore panel to create layers on the map by applying filters to the properties of a class. If a class in the explore panel has a geometry property, then Sextant is able to create layers out of the data of this class. When we chose to retrieve the properties of a class, Sextant looks for properties with the names asWKT, asGML and hasGeometry that are used to represent geometries. If one or more of these properties are available for the class then a new set of buttons appear, as shown in the following figure.
Each property of the class can have a button that allows the creation of filters over this property. The appears under the range URI of a property if that is one of the following:
When we click on of these buttons, a pop-up appears, depending on the range of the property, to allow the creation of filters. Each of these pop-ups can lead to the creation of up-to three filters, but we can click the same again to apply more filters on this property if needed. In the following figures we can see the forms to create spatial filters and numeric filters on properties.
Each filter has three attributes which are explaned below:
When a filter is created on a property, the button changes into to indicate that filters are applied on this property. We can view all the filters that are applied on the class by clicking the button and remove all the filters from a class using the button. When we have applied all the desired filters, we can create a layer from this class using the button. We then get a pup-up where we provide a name for the layer and create it on the map.


unixism
`Prev `__
U
`Next `__
--------------
**unixism**: n.
A piece of code or a coding technique that depends on the protected
multi-tasking environment with relatively low process-spawn overhead
that exists on virtual-memory Unix systems. Common
`*unixism* `__\ s include: gratuitous use of fork(2); the
assumption that certain undocumented but well-known features of Unix
libraries such as stdio(3) are supported elsewhere; reliance on
`*obscure* <../O/obscure.html>`__ side-effects of system calls (use of
sleep(2) with a 0 argument to clue the scheduler that you're willing to
give up your time-slice, for example); the assumption that freshly
allocated memory is zeroed; and the assumption that fragmentation
problems won't arise from never free()ing memory. Compare
`*vaxocentrism* <../V/vaxocentrism.html>`__; see also `*New
Jersey* <../N/New-Jersey.html>`__.
--------------
+--------------------------------+----------------------------+------------------------------+
| `Prev `__ | `Up <../U.html>`__ | `Next `__ |
+--------------------------------+----------------------------+------------------------------+
| Unix weenie | `Home <../index.html>`__ | unswizzle |
+--------------------------------+----------------------------+------------------------------+


--- layout: default ---
Ray provides a simple, universal API for building distributed applications.
Ray is packaged with the following libraries for accelerating machine learning workloads:
To get started, visit the Ray Project web site, documentation, GitHub project, or Tutorials.


|
Yangzi Zhao
|
Trouble is a friend |
|
Weiping Huang
|
Trouble is a friend |
|
Ruiqiong Tian
|
Trouble is a friend |


@(c: lila.coach.Coach.WithUser)(implicit ctx: Context) @layout(title = c.user.titleUsername, active = "coach") {


Gifts are the most beautiful things that any one can recieve,
especially when you know what your recipient loves, likes and
interested in. So, give them a gift that will really speak to them.
especially when you know what your recipient loves, likes and
interested in. So, give them a gift that will really speak to them.


RendererR demo
(for testing
glf
)
Your Browser Doesn't Support HTML5's Canvas.
Duration (ms) of update function:
Duration (ms) of main loop:
Log


Website Template
All Allwebco templates include plain text global menus for quick website updates when adding new pages. This template model includes CSS drop menus so you can comfortably expand this site to about 50 pages. The included site map allows you to expand your website to an unlimited number of pages. You can edit all menu titles and links with any plain text editor to customize this template for your own project.  All colors and fonts can be changed by editing the global CSS style sheet. Every Allwebco site includes a comprehensive help page with step by step instructions.
Learn MoreFeatures
The image slideshow on this page is mobile compatible and displays standard .jpg images. You can optionally replace the five standard .jpg images and update them with your own images. This template is built using standard HTML code for the highest compatibility in all web browsers and computer operating systems. The menu, header and footer are global javascript .js include files for easy website updates. All text formatting uses a global css style sheet for quick color and font editing. You can replace the graphic logo in the header with your own .jpg image. View this page with the optional no animation homepage.
Learn More


The Jorge Luis Borges Hotel
The Jorge Luis Borges Hotel is located at the frontier between Argentina and the Dominican Republic. Each room at the JLB Hotel is named after a short story by the literary master. In said room there are televisions where the story which the room is named after, is read 24 hours, 7 days a week.
The price for each room is measured in how many letters its namesake story contains.
Go to the Dominican Republic and drive South.


distance module¶
Available methods:
calc_point_to_point_distance: calculates distances between all points in the given array,
calc_block_to_block_distance: calculates distances between blocks based on the population points within the block.
calc_point_to_point_distance()
¶
pyinterpolate.distance.calc_point_to_point_distance(
points_a,
points_b=None)
Function calculates distances between all points in the given array.
INPUT:
points_a: (numpy array) points coordinates,
points_b: (numpy array) points coordinates, default is
None
. IfNone
is given then distances between all points withinpoints_a
is calculated.
OUTPUT:
numpy array
of distances between all coordinates.
calc_block_to_block_distance()
¶
pyinterpolate.distance.calc_block_to_block_distance(areas)
Function calculates distances between blocks based on the population points within the block.
INPUT:
areas: (numpy array or Python list of lists) area ids and coordinates per each id. Single input row:
[
area_id,
[x, y, val]
]
OUTPUT:
areal distances:
tuple of arrays
with matrix with areal distances and ids of each row of distances:
(
[
[dist(id0:id0), ..., dist(id0:id99)],
...,
[dist(id99:id0), ..., dist(id99:id99)]
],
[id0, id1, ..., id999]
)


--- layout: post title: Must issue sudo alsa force-reload on reboot (Ubuntu) date: 2014-10-10 16:04:51.000000000 +08:00 type: post published: true status: publish categories: - "应用技巧" tags: [] meta: _edit_last: '1' views: '137' mzw_ding: '1' author: login: lanbing email<EMAIL_ADDRESS>display_name: lanbing first_name: '' last_name: '' ---
I have a problem, I have got sound working...
But only when I issue the Code:
sudo alsa force-reload
It will when play the sound that was queued to play, like the login sound.
Everytime when I restart, I have to do Code:
sudo alsa force-reload
in order for sound to work.
Solution :
sudo gedit /etc/default/acpi-support # Add modules to this list to have them removed before suspend and reloaded
# on resume. An example would be MODULES="em8300 yenta_socket"
#
# Note that network cards and USB controllers will automatically be unloaded
# unless they're listed in MODULES_WHITELIST
MODULES="soundcore"


Sutorimu
Home
Anime List
Movie
Genre
Request
Request Anime
Title
Description
This is optional. If you not know the title of the anime, write something related to the anime.
Send!
Recomended
N/A
Josee to Tora to Sakana-tachi
Genre : Action, Sci-Fi, Supernatural, Magic, Romance, School


Toggle vertical component
Flip vertical component
Create/Delete canvas
Blue
Horizontal Distance
Vertical Distance
Distance between intersections:
Auto-straighten plane


class: center, middle, inverse, title-slide # Prediction ### Machine Learning with R
The R Bootcamp @ DHLab
### November 2020 --- layout: true
        www.therbootcamp.com      Machine Learning with R | November 2020
 --- # Prediction is... .pull-left45[
 Prediction is very difficult, especially if it's about the future.

 Nils Bohr, Nobel Laureate in Physics

 An economist is an expert who will know tomorrow why the things he predicted yesterday didn't happen today.

 Evan Esar, Humorist
 ] .pull-right45[

 from futurism.com
 ] --- # Hold-out data .pull-left45[

Model performance must be evaluated as true prediction on an <high>unseen data set</high>.

The unseen data set can be <high>naturally</high> occurring.

e.g. using 2019 stock prizes to evaluate a model fit using 2018 stock prizes

More commonly unseen data is created by <high>splitting the available data</high> into a training set and a test set..

 ] .pull-right45[

 ] --- # Training

 --- # Test

 --- .pull-left4[

 # Overfitting

Occurs when a model <high>fits data too closely</high> and therefore fails to reliably predict future observations.

Overfitting occurs when a model 'mistakes' random <high>noise</high> for a predictable <high>signal</high>.

More <high>complex models</high> are more prone to overfitting.

 ] .pull-right5[

 ] --- # Overfitting  --- class: center, middle
Regression
 <high>
Decision Trees
</high>
Random Forests
 --- # CART .pull-left45[

CART is short for <high>Classification and Regression Trees</high>, which are often simply called Decision trees.

Models criterion is modeled as a sequence of <high>logical TRUE or FALSE questions</high>.

 ] .pull-right45[

 ] --- # Classificiation trees .pull-left45[

Classification trees (and regression trees) are created using a relatively simple <high>three-step algorithm</high>:

1 - <high>Split</high> nodes to maximize purity gain (e.g., Gini gain).

2 - <high>Repeat</high> until splits are no longer possible.

3 - <high>Prune</high> tree to reasonable size.</mono>

 ] .pull-right45[

 ] --- # Node splitting .pull-left45[

Classification trees attempt to <high>minize node impurity</high> using, e.g., the <high>Gini coefficient</high>.

 `$$\large Gini(S) = 1 - \sum_j^kp_j^2$$`

Nodes are <high>split</high> using the variable and split value that <high>maximizes Gini gain</high>.

 `$$Gini \; gain = Gini(S) - Gini(A,S)$$` with `$$Gini(A, S) = \sum \frac{n_i}{n}Gini(S_i)$$` ] .pull-right45[

 ] --- # Pruning trees .pull-left45[

CClassification trees are <high>pruned</high> back such that every split has a purity gain of at least <high><mono>cp</mono></high>.

 $$ \large `\begin{split} Loss = & Impurity\,+\\ &cp*(n\:terminal\:nodes)\\ \end{split}` $$ ] .pull-right45[

 ] --- # Regression trees .pull-left45[

Trees can also be used to perform regression tasks. Instead of impurity, regression trees attempt to <high>minimize within-node variance</high> (or maximize node homogeneity):

 `$$\large SSE = \sum_{i \in S_1}(y_i - \bar{y}_1)^2+\sum_{i \in S_2}(y_i - \bar{y}_2)^2$$`

Algorithm:

1 - <high>Split</high> nodes to maximize homogeneity gain.

2 - <high>Repeat</high> until splits are no longe possible.

3 - <high>Prune</high> tree to reasonable size.

 ] .pull-right45[

 ] --- # CART in <mono>caret</mono> .pull-left4[

Fit <high>decision trees</high> in <mono>caret</mono> using <mono>method = "rpart"</mono>.

<mono>caret</mono> will <high>choose automatically</high> whether to use classification or regression trees depending on whether the criterion is a <mono>factor</mono> or not.

 ] .pull-right45[ ```r # Fit a decision tree predicting default train(form = default ~ ., # factor data = Loans, method = "rpart", # Decision Tree trControl = ctrl) # Fit a decision tree predicting income train(form = income ~ ., # continuous data = basel, method = "rpart", # Decision Tree trControl = ctrl) ``` ] --- class: center, middle
Regression

Decision Trees
 <high>
Random Forests
</high> --- .pull-left45[ # Random Forest

In Random Forests the criterion is modeled as the <high>aggregate prediction of <high>many decision trees</high> each based on different features.

Algorithmus:

1 - <high>Repeat</high> <mono>n</mono> times.

1 - <high>Resample</high> data.

2 - Each split <high>consider m features</high>.

2 - <high>Average</high> predictions.

 ] .pull-right45[

 ] --- # Random Forest .pull-left45[

Random forests make use of <high>bagging</high>, which consists of <high>resampling</high> and <high>averaging</high>.

 <col width="30%"> <col width="70%">
  Element 	  Description

  Resampling 	  Creates new data sets that vary in their composition thereby <high>deemphasizing idiosyncracies</high> of the available data.

  Averaging 	  Combining predictions typically <high>evens out idiosyncracies</high> of the models created from single data sets.

 ] .pull-right45[

 ] --- # Random forests in <mono>caret</mono> .pull-left4[

Fit a Random Forest in <mono>caret</mono> with <highm>method = "rf"</highm>.

<mono>caret</mono> will <high>choose automatically</high> whether to use classification or regression trees for the Random Forest depending on whether the criterion is a <mono>factor</mono> or not.

 ] .pull-right45[ ```r # Fit a decision tree predicting default train(form = default ~ ., data = Loans, method = "rf", # Decision Tree trControl = ctrl) # Fit a decision tree predicting income train(form = income ~ ., data = basel, method = "rf", # Decision Tree trControl = ctrl) ``` ] --- class: center, middle
Evaluating model predictions with <mono>caret</mono>
  --- # <mono>predict(, newdata)</mono> .pull-left4[

To <high>test model predictions</high>, you nee to compute a vector of predictions from a the test data (<mono>newdata</mono> using the <mono>predict()</mono> function:

 <col width="30%"> <col width="70%">
  Argument 	  Description

  <mono>object</mono> 	  <mono>caret</mono> fit object.

  <mono>newdata</mono> 	  Test data sest. Must contain same features as provided in <mono>object</mono>.

 ] .pull-right5[ ```r # Fit model to training data mod <- train(form = income ~ ., method = "glm", data = basel_train) # Get fitted values (for training data) mod_fit <- predict(mod) # Predictions for NEW data_test data! mod_pred <- predict(mod, newdata = basel_test) # Evaluate prediction results postResample(pred = mod_pred, obs = basel_test$income) ``` ] --- class: middle, center
Practical


|
ReactPhysics3D
0.6.0
Physics engine library
|
This class represents a set of one or several contact manifolds. More...
#include <ContactManifoldSet.h>
Public Member Functions | |
| ContactManifoldSet (ProxyShape *shape1, ProxyShape *shape2, MemoryAllocator &memoryAllocator, int nbMaxManifolds) | |
| Constructor. | |
| ~ContactManifoldSet () | |
| Destructor. | |
| ProxyShape * | getShape1 () const |
| Return the first proxy shape. | |
| ProxyShape * | getShape2 () const |
| Return the second proxy shape. | |
| void | addContactPoint (ContactPoint *contact) |
| Add a contact point to the manifold set. | |
| void | update () |
| Update the contact manifolds. | |
| void | clear () |
| Clear the contact manifold set. | |
| int | getNbContactManifolds () const |
| Return the number of manifolds in the set. | |
| ContactManifold * | getContactManifold (int index) const |
| Return a given contact manifold. | |
| int | getTotalNbContactPoints () const |
| Return the total number of contact points in the set of manifolds. | |
This class represents a set of one or several contact manifolds.
Typically a convex/convex collision will have a set with a single manifold and a convex-concave collision can have more than one manifolds. Note that a contact manifold can contains several contact points.


gameanalysis.agggen module¶
-
gameanalysis.agggen.
congestion
(num_players, num_facilities, num_required, *, degree=2)[source]¶ Generate a congestion game
A congestion game is a symmetric game, where there are a given number of facilities, and each player must choose to use some amount of them. The payoff for each facility decreases as more players use it, and a players utility is the sum of the utilities for every facility.
In this formulation, facility payoffs are random polynomials of the number of people using said facility.
Parameters: - num_players (int > 1) – The number of players.
- num_facilities (int > 1) – The number of facilities.
- num_required (0 < int < num_facilities) – The number of required facilities.
- degree (int > 0, optional) – Degree of payoff polynomials.
-
gameanalysis.agggen.
local_effect
(num_players, num_strategies, *, edge_prob=0.2)[source]¶ Generate a local effect game
In a local effect game, strategies are connected by a graph, and utilities are a function of the number of players playing our strategy and the number of players playing a neighboring strategy, hence local effect.
In this formulation, payoffs for others playing our strategy are negative quadratics, and payoffs for playing other strategies are positive cubics.
Parameters: - num_players (int > 1) – The number of players.
- num_strategies (int > 1) – The number of strategies.
- edge_prob (float, optional) – The probability that one strategy affects another.
-
gameanalysis.agggen.
normal_aggfn
(role_players, role_strats, functions, *, input_prob=0.2, weight_prob=0.2)[source]¶ Generate a random normal AgfnGame
Each function value is an i.i.d Gaussian random walk.
Parameters: - role_players (int or ndarray) – The number of players per role.
- role_strats (int or ndarray) – The number of strategies per role.
- functions (int) – The number of functions to generate.
- input_prob (float, optional) – The probability of a strategy counting towards a function value.
- weight_prob (float, optional) – The probability of a function producing non-zero payoffs to a strategy.
-
gameanalysis.agggen.
poly_aggfn
(role_players, role_strats, functions, *, input_prob=0.2, weight_prob=0.2, degree=4)[source]¶ Generate a random polynomial AgfnGame
Functions are generated by generating degree zeros in [0, num_players] to serve as a polynomial functions.
Parameters: - role_players (int or ndarray) – The number of players per role.
- role_strats (int or ndarray) – The number of strategies per role.
- functions (int) – The number of functions to generate.
- input_prob (float, optional) – The probability of a strategy counting towards a function value.
- weight_prob (float, optional) – The probability of a function producing non-zero payoffs to a strategy.
- degree (int or [float], optional) – Either an integer specifying the degree or a list of the probabilities of degrees starting from one, e.g. 3 is the same as [0, 0, 1].
-
gameanalysis.agggen.
sine_aggfn
(role_players, role_strats, functions, *, input_prob=0.2, weight_prob=0.2, period=4)[source]¶ Generate a random sinusodial AgfnGame
Functions are generated by generating sinusoids with uniform random shifts and n periods in 0 to num_players, where n is chosen randomle between min_period and max_period.
Parameters: - role_players (int or ndarray) – The number of players per role.
- role_strats (int or ndarray) – The number of strategies per role.
- functions (int) – The number of functions to generate.
- input_prob (float, optional) – The probability of a strategy counting towards a function value.
- weight_prob (float, optional) – The probability of a function producing non-zero payoffs to a strategy.
- period (float, optional) – The loose number of periods in the payoff for each function.


[[#{login.headline}]]
Invalid username or password
Successfully logged out
Username
Password
[[#{login.rememberMe}]]


The ability to chain together different transformers and predictors is an important feature for any Machine Learning (ML) library. In FlinkML we wanted to provide an intuitive API, and at the same time utilize the capabilities of the Scala language to provide type-safe implementations of our pipelines. What we hope to achieve then is an easy to use API, that protects users from type errors at pre-flight (before the job is launched) time, thereby eliminating cases where long running jobs are submitted to the cluster only to see them fail due to some error in the series of data transformations that commonly happen in an ML pipeline.
In this guide then we will describe the choices we made during the implementation of chainable transformers and predictors in FlinkML, and provide guidelines on how developers can create their own algorithms that make use of these capabilities.
So what do we mean by “ML pipelines”? Pipelines in the ML context can be thought of as chains of operations that have some data as input, perform a number of transformations to that data, and then output the transformed data, either to be used as the input (features) of a predictor function, such as a learning model, or just output the transformed data themselves, to be used in some other task. The end learner can of course be a part of the pipeline as well. ML pipelines can often be complicated sets of operations (in-depth explanation) and can become sources of errors for end-to-end learning systems.
The purpose of ML pipelines is then to create a framework that can be used to manage the complexity introduced by these chains of operations. Pipelines should make it easy for developers to define chained transformations that can be applied to the training data, in order to create the end features that will be used to train a learning model, and then perform the same set of transformations just as easily to unlabeled (test) data. Pipelines should also simplify cross-validation and model selection on these chains of operations.
Finally, by ensuring that the consecutive links in the pipeline chain “fit together” we also avoid costly type errors. Since each step in a pipeline can be a computationally-heavy operation, we want to avoid running a pipelined job, unless we are sure that all the input/output pairs in a pipeline “fit”.
The building blocks for pipelines in FlinkML can be found in the ml.pipeline
package.
FlinkML follows an API inspired by sklearn which means that we have
Estimator
, Transformer
and Predictor
interfaces. For an in-depth look at the design of the
sklearn API the interested reader is referred to this paper.
In short, the Estimator
is the base class from which Transformer
and Predictor
inherit.
Estimator
defines a fit
method, and Transformer
also defines a transform
method and
Predictor
defines a predict
method.
The fit
method of the Estimator
performs the actual training of the model, for example
finding the correct weights in a linear regression task, or the mean and standard deviation of
the data in a feature scaler.
As evident by the naming, classes that implement
Transformer
are transform operations like scaling the input and
Predictor
implementations are learning algorithms such as Multiple Linear Regression.
Pipelines can be created by chaining together a number of Transformers, and the final link in a pipeline can be a Predictor or another Transformer.
Pipelines that end with Predictor cannot be chained any further.
Below is an example of how a pipeline can be formed:
As we mentioned, FlinkML pipelines are type-safe.
If we tried to chain a transformer with output of type A
to another with input of type B
we
would get an error at pre-flight time if A
!= B
. FlinkML achieves this kind of type-safety
through the use of Scala’s implicits.
If you are not familiar with Scala’s implicits we can recommend this excerpt from Martin Odersky’s “Programming in Scala”. In short, implicit conversions allow for ad-hoc polymorphism in Scala by providing conversions from one type to another, and implicit values provide the compiler with default values that can be supplied to function calls through implicit parameters. The combination of implicit conversions and implicit parameters is what allows us to chain transform and predict operations together in a type-safe manner.
As we mentioned, the trait (abstract class) Estimator
defines a fit
method. The method has two
parameter lists
(i.e. is a curried function). The
first parameter list
takes the input (training) DataSet
and the parameters for the estimator. The second parameter
list takes one implicit
parameter, of type FitOperation
. FitOperation
is a class that also
defines a fit
method, and this is where the actual logic of training the concrete Estimators
should be implemented. The fit
method of Estimator
is essentially a wrapper around the fit
method of FitOperation
. The predict
method of Predictor
and the transform
method of
Transform
are designed in a similar manner, with a respective operation class.
In these methods the operation object is provided as an implicit parameter. Scala will look for implicits in the companion object of a type, so classes that implement these interfaces should provide these objects as implicit objects inside the companion object.
As an example we can look at the StandardScaler
class. StandardScaler
extends Transformer
, so it has access to its fit
and transform
functions.
These two functions expect objects of FitOperation
and TransformOperation
as implicit parameters,
for the fit
and transform
methods respectively, which StandardScaler
provides in its companion
object, through transformVectors
and fitVectorStandardScaler
:
Note that StandardScaler
does not override the fit
method of Estimator
or the transform
method of Transformer
. Rather, its implementations of FitOperation
and TransformOperation
override their respective fit
and transform
methods, which are then called by the fit
and
transform
methods of Estimator
and Transformer
. Similarly, a class that implements
Predictor
should define an implicit PredictOperation
object inside its companion object.
Apart from the fit
and transform
operations that we listed above, the StandardScaler
also
provides fit
and transform
operations for input of type LabeledVector
.
This allows us to use the algorithm for input that is labeled or unlabeled, and this happens
automatically, depending on the type of the input that we give to the fit and transform
operations. The correct implicit operation is chosen by the compiler, depending on the input type.
If we try to call the fit
or transform
methods with types that are not supported we will get a
runtime error before the job is launched.
While it would be possible to catch these kinds of errors at compile time as well, the error
messages that we are able to provide the user would be much less informative, which is why we chose
to throw runtime exceptions instead.
Chaining is achieved by calling chainTransformer
or chainPredictor
on an object
of a class that implements Transformer
. These methods return a ChainedTransformer
or
ChainedPredictor
object respectively. As we mentioned, ChainedTransformer
objects can be
chained further, while ChainedPredictor
objects cannot. These classes take care of applying
fit, transform, and predict operations for a pair of successive transformers or
a transformer and a predictor. They also act recursively if the length of the
chain is larger than two, since every ChainedTransformer
defines a transform
and fit
operation that can be further chained with more transformers or a predictor.
It is important to note that developers and users do not need to worry about chaining when implementing their algorithms, all this is handled automatically by FlinkML.
In order to support FlinkML’s pipelining, algorithms have to adhere to a certain design pattern, which we will describe in this section.
Let’s assume that we want to implement a pipeline operator which changes the mean of your data.
Since centering data is a common pre-processing step in many analysis pipelines, we will implement it as a Transformer
.
Therefore, we first create a MeanTransformer
class which inherits from Transformer
Since we want to be able to configure the mean of the resulting data, we have to add a configuration parameter.
Parameters are defined in the companion object of the transformer class and extend the Parameter
class.
Since the parameter instances are supposed to act as immutable keys for a parameter map, they should be implemented as case objects
.
The default value will be used if no other value has been set by the user of this component.
If no default value has been specified, meaning that defaultValue = None
, then the algorithm has to handle this situation accordingly.
We can now instantiate a MeanTransformer
object and set the mean value of the transformed data.
But we still have to implement how the transformation works.
The workflow can be separated into two phases.
Within the first phase, the transformer learns the mean of the given training data.
This knowledge can then be used in the second phase to transform the provided data with respect to the configured resulting mean value.
The learning of the mean can be implemented within the fit
operation of our Transformer
, which it inherited from Estimator
.
Within the fit
operation, a pipeline component is trained with respect to the given training data.
The algorithm is, however, not implemented by overriding the fit
method but by providing an implementation of a corresponding FitOperation
for the correct type.
Taking a look at the definition of the fit
method in Estimator
, which is the parent class of Transformer
, reveals what why this is the case.
We see that the fit
method is called with an input data set of type Training
, an optional parameter list and in the second parameter list with an implicit parameter of type FitOperation
.
Within the body of the function, first some machine learning types are registered and then the fit
method of the FitOperation
parameter is called.
The instance gives itself, the parameter map and the training data set as a parameters to the method.
Thus, all the program logic takes place within the FitOperation
.
The FitOperation
has two type parameters.
The first defines the pipeline operator type for which this FitOperation
shall work and the second type parameter defines the type of the data set elements.
If we first wanted to implement the MeanTransformer
to work on DenseVector
, we would, thus, have to provide an implementation for FitOperation[MeanTransformer, DenseVector]
.
A FitOperation[T, I]
has a fit
method which is called with an instance of type T
, a parameter map and an input DataSet[I]
.
In our case T=MeanTransformer
and I=DenseVector
.
The parameter map is necessary if our fit step depends on some parameter values which were not given directly at creation time of the Transformer
.
The FitOperation
of the MeanTransformer
sums the DenseVector
instances of the given input data set up and divides the result by the total number of vectors.
That way, we obtain a DataSet[DenseVector]
with a single element which is the mean value.
But if we look closely at the implementation, we see that the result of the mean computation is never stored anywhere.
If we want to use this knowledge in a later step to adjust the mean of some other input, we have to keep it around.
And here is where the parameter of type MeanTransformer
which is given to the fit
method comes into play.
We can use this instance to store state, which is used by a subsequent transform
operation which works on the same object.
But first we have to extend MeanTransformer
by a member field and then adjust the FitOperation
implementation.
If we look at the transform
method in Transformer
, we will see that we also need an implementation of TransformOperation
.
A possible mean transforming implementation could look like the following.
Now we have everything implemented to fit our MeanTransformer
to a training data set of DenseVector
instances and to transform them.
However, when we execute the fit
operation
we receive the following error at runtime: "There is no FitOperation defined for class MeanTransformer which trains on a DataSet[org.apache.flink.ml.math.DenseVector]"
.
The reason is that the Scala compiler could not find a fitting FitOperation
value with the right type parameters for the implicit parameter of the fit
method.
Therefore, it chose a fallback implicit value which gives you this error message at runtime.
In order to make the compiler aware of our implementation, we have to define it as an implicit value and put it in the scope of the MeanTransformer's
companion object.
Now we can call fit
and transform
of our MeanTransformer
with DataSet[DenseVector]
as input.
Furthermore, we can now use this transformer as part of an analysis pipeline where we have a DenseVector
as input and expected output.
It is noteworthy that there is no additional code needed to enable chaining. The system automatically constructs the pipeline logic using the operations of the individual components.
So far everything works fine with DenseVector
.
But what happens, if we call our transformer with LabeledVector
instead?
As before we see the following exception upon execution of the program: "There is no FitOperation defined for class MeanTransformer which trains on a DataSet[org.apache.flink.ml.common.LabeledVector]"
.
It is noteworthy, that this exception is thrown in the pre-flight phase, which means that the job has not been submitted to the runtime system.
This has the advantage that you won’t see a job which runs for a couple of days and then fails because of an incompatible pipeline component.
Type compatibility is, thus, checked at the very beginning for the complete job.
In order to make the MeanTransformer
work on LabeledVector
as well, we have to provide the corresponding operations.
Consequently, we have to define a FitOperation[MeanTransformer, LabeledVector]
and TransformOperation[MeanTransformer, LabeledVector, LabeledVector]
as implicit values in the scope of MeanTransformer
’s companion object.
If we wanted to implement a Predictor
instead of a Transformer
, then we would have to provide a FitOperation
, too.
Moreover, a Predictor
requires a PredictOperation
which implements how predictions are calculated from testing data.


x1
x2
x3
x5
MAX
Based on Open Source Project Flappy Learning
Modded GitHub Repository
Original GitHub Repository


-
Useful Commands - Image manipulation
I often work with images to go onto e-commerce sites, so getting them as small as possbile (file size wise) is what I aim for, for performance There are plenty of good, paid tools out there such as Kraken or ImageOptim and there are even some good, free (web based)...
-
Cross compiling Litecoin Core
I’ve had a plan of being a good guy and contributing to the litecoin network by being a full node. I was able to do this when I got around to buying a raspberry pi 3B+ and a 2TB external hard drive. There isn’t many up-to-date guides out there on...
-
Moving Magento
So I was asked to help finish moving a magento (1.9) installation to a new server the other day. To sum it up, it was not fun They had already moved the files and had everything installed and updated the database connection string, however it was still throwing an error....
-
Useful Commands - MSSQL
Here is a start of a regular posting, “useful commands” Over the years I have saved snippets, commands and notes of things that have been useful or saved alot of time. I start off with a gathering of T-SQL commands to do useful things within a windows database. Some of...
-
PiHole and OpenHAB
Recently I installed pihole on my network because I was sick of ads, and wanted an added layer of security on my network against nasty malware and the like There are plenty of install guides out there for pihole (see official website) so thats not what I am covering today....
-
Ubuntu Live USB with persistence
Creating a live USB is easy, adding persistence seems to be quite hard. After lots of research, there was alot of ways to do it, but most of these tutorials were out of date so some things weren’t relevant anymore or just didn’t work Here are some hopefully simple steps...
-
RuuviTag
I backed Ruuvi sometime late last year for a RuuviTag, a battery powered Bluetooth LE microcontroller with an onboard temperature and humidity sensor. As soon as I saw this project I had several ideas. And because I run openHAB at home, naturally, I’d want to collate this date into here...
-
Node and systemd
For a while now I’ve had my dashboard combo tv and dashboard combo, which runs on dashing and dashkiosk, running in screen sessions. This , of course, is not very managable. If something breaks, you have to ssh in and then find the screen session, re-run the command. In comes...


authorization steps
on first bounce
should save state
should save current step
should receive a redirect
on return from github
issues api
post issue
returns correct response
get issues
patch issue
get repositories
returns public and private repositories
webhook api
create a webhook
creates the webhook
list webhook
returns the webhook
delete webhook
default settings
exposes defaultSettings method


Complete the following rhymes. (Example: William the Conqueror played
cruel tricks on the Saxons in... ten sixty-six.)
- Columbus sailed the ocean blue in...
- The Spanish Armada met its fate in...
- London burnt like rotten sticks in...
Check Your Answers!


Label
Something else
Label
Something else
Label
Something else
Label
Something else
| UID |
Label 1 |
Label 2 |
Label 3 |
Label 4 |
Label 5 |
| 1,001 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,002 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,003 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,003 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,004 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,005 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,006 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,007 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,008 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,009 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,010 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,011 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,012 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,013 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,014 |
Mountains |
Sky |
Flying |
Driving |
Falling |
| 1,015 |
Mountains |
Sky |
Flying |
Driving |
Falling |