See the full list of Kata Seeds at github.com/kata-seeds
Tips for making a Kata Seed
Use the template
Copy kata-seed-template (don't fork it) and start from there. If there's something you think would benefit all Kata Seeds, open a pull request on the template.
Name your Kata Seed
If you're only using the core language and standard library, the name should be language-seed
. If you have to use/install a dependency to run the tests, the name should be language-framework-seed
instead.
Write the code
The code in the seed should implement a simple way to greet a person, plus a test that it works. Implement that functionality in whatever way is most natural in your language. To get an idea of how small the implementation should be, you should read the implementations in a few seeds that use similar languages to yours.
make
Just run Makefiles are executable documentation. Someone can run make
to run the tests, but also read the Makefile
and see how the tests are run and dependencies are installed.
Try your best to ensure someone can run make
and get the tests running. The less someone has to do to get up and running, the more time they can spend learning the language instead of the tooling.
Ideally, the behavior would be:
- Run
make
the first time: Dependencies are installed, and the tests run. - Run
make
subsequent times: Dependencies are checked, and the tests run. The dependency checking should be near-instantaneous.
Commit exact dependency versions
The last thing someone wants to deal with when practicing a kata is bugs in dependencies. Pin the the dependencies to exact versions, or commit a dependency lock file if your language has one.


{% extends '_main.html' %} {% block page_title %}Sorry, there is a problem with the service - {{ block.super }}{% endblock %} {% block content %}
{{ message }}
{% endif %}Please try again.
If the problem continues, please contact the Data Workspace Support Team.


Warrie Usenobong is a student of the University of Uyo. A computer Engineering Student in his finals, future software developer with immerse interest in Artificial Intelligence, Andriod development and networking cable installation.


<<< Back
Submit >>>
Welcome to my Hotel!
Joe manages an apartment in KW. Being a businessman, he’d like to get the most amount of people in his hotel, so he can make a lot of money! Unfortunately, some of the customers have special requests. Each customer has a room size request, the size of the room (from 1 to S inclusive) that they want in the hotel. Joe would like to keep them all happy, so giving a customer a room bigger than they asked for is fine. However, Joe cannot give them a smaller room, so at some point he might run out of rooms. Tell Joe how many people he can service.
Input Specifications
The first line will contain three integers, N(N<=100 000), M(M<=100 000) and S(S<=100 000) the number of people, the numbers of rooms and the maximum room size.
The second line will contain N integers, the size requests of the N people.
The third line will contain M integers, the sizes of all the rooms.
Output Specifications
Output the number of people that can be serviced a room at least as large as they requested.
Subtasks
For 20% of the available 100 marks, N,M,S <= 100
For another 20% of the available 100 marks, S<=10
For another 20% of the available 100 marks, N,M <= 1000
For another 20% of the available 100 marks, S <= 100
Sample Input
Sample Output


Question
Design a Parking Lot.
Solution
Class hierarchy:
- A parking lot has multiple Levels.
- A Level has multiple Parking Spot.
- A Spot can park motorcycle, car or bus, which all belongs to Vehicle.
Implement methods:
- Vehicle.parkInSpot(Spot s)
- Vehicle.leaveSpot(Spot s)
- Vehicle.canFitIn(Spot s)
- ParkingLot.parkVehicle(Vehicle v)
- Level.parkVehicle(Vehicle v)
- Level.parkVehicleAtSpot(Vehicle v, Spot s)
- Level.findAvailableSpot(VehicleType vt)
ParkingLot Class is just a wrapper class of Levels. By doing this, we seperated out parking logic from other broader actions (like Spot management).
The code below is from CC150v5. Its design is a bit strange (a car can occupy multiple spots), so just use this code as a guide but not a reference.
Code
ParkingLot.java
public class ParkingLot {
private Level[] levels;
private final int NUM_LEVELS = 5;
public ParkingLot() {
levels = new Level[NUM_LEVELS];
for (int i = 0; i < NUM_LEVELS; i++) {
levels[i] = new Level(i, 30);
}
}
/* Park the vehicle in a spot (or multiple spots). Return false if failed. */
public boolean parkVehicle(Vehicle vehicle) {
for (int i = 0; i < levels.length; i++) {
if (levels[i].parkVehicle(vehicle)) {
return true;
}
}
return false;
}
public void print() {
for (int i = 0; i < levels.length; i++) {
System.out.print("Level" + i + ": ");
levels[i].print();
System.out.println("");
}
System.out.println("");
}
}
Level.java
/* Represents a level in a parking garage */
public class Level {
private int floor;
private ParkingSpot[] spots;
private int availableSpots = 0; // number of free spots
private static final int SPOTS_PER_ROW = 10;
public Level(int flr, int numberSpots) {
floor = flr;
spots = new ParkingSpot[numberSpots];
int largeSpots = numberSpots / 4;
int bikeSpots = numberSpots / 4;
int compactSpots = numberSpots - largeSpots - bikeSpots;
for (int i = 0; i < numberSpots; i++) {
VehicleSize sz = VehicleSize.Motorcycle;
if (i < largeSpots) {
sz = VehicleSize.Large;
} else if (i < largeSpots + compactSpots) {
sz = VehicleSize.Compact;
}
int row = i / SPOTS_PER_ROW;
spots[i] = new ParkingSpot(this, row, i, sz);
}
availableSpots = numberSpots;
}
public int availableSpots() {
return availableSpots;
}
/* Try to find a place to park this vehicle. Return false if failed. */
public boolean parkVehicle(Vehicle vehicle) {
if (availableSpots() < vehicle.getSpotsNeeded()) {
return false;
}
int spotNumber = findAvailableSpots(vehicle);
if (spotNumber < 0) {
return false;
}
return parkStartingAtSpot(spotNumber, vehicle);
}
/* Park a vehicle starting at the spot spotNumber, and continuing until vehicle.spotsNeeded. */
private boolean parkStartingAtSpot(int spotNumber, Vehicle vehicle) {
vehicle.clearSpots();
boolean success = true;
for (int i = spotNumber; i < spotNumber + vehicle.spotsNeeded; i++) {
success &= spots[i].park(vehicle);
}
availableSpots -= vehicle.spotsNeeded;
return success;
}
/* find a spot to park this vehicle. Return index of spot, or -1 on failure. */
private int findAvailableSpots(Vehicle vehicle) {
int spotsNeeded = vehicle.getSpotsNeeded();
int lastRow = -1;
int spotsFound = 0;
for (int i = 0; i < spots.length; i++) {
ParkingSpot spot = spots[i];
if (lastRow != spot.getRow()) {
spotsFound = 0;
lastRow = spot.getRow();
}
if (spot.canFitVehicle(vehicle)) {
spotsFound++;
} else {
spotsFound = 0;
}
if (spotsFound == spotsNeeded) {
return i - (spotsNeeded - 1);
}
}
return -1;
}
public void print() {
int lastRow = -1;
for (int i = 0; i < spots.length; i++) {
ParkingSpot spot = spots[i];
if (spot.getRow() != lastRow) {
System.out.print(" ");
lastRow = spot.getRow();
}
spot.print();
}
}
/* When a car was removed from the spot, increment availableSpots */
public void spotFreed() {
availableSpots++;
}
}


PickTabs PRO
Are you looking for more features? Please check our Premium Version
| Free | PRO | On Demand Tabs |
|---|---|---|
| Download Tabs | ||
| Various versions of Tracks | ||
| Backing Tracks | ||
| Free | Just ₹49/month | |
| Current Version | Upgrade to PRO |
Are you looking for more features? Please check our Premium Version
| Free | PRO | On Demand Tabs |
|---|---|---|
| Download Tabs | ||
| Various versions of Tracks | ||
| Backing Tracks | ||
| Free | Just ₹49/month | |
| Current Version | Upgrade to PRO |


| 接口 | 说明 |
|---|---|
| DocValueFormat |
A formatter for values as returned by the fielddata/doc-values APIs.
|
| SearchPhase |
Represents a phase of a search request e.g. query, fetch etc.
|
| 类 | 说明 |
|---|---|
| DocValueFormat.DateTime | |
| DocValueFormat.Decimal | |
| Scroll |
A scroll enables scrolling of search request.
|
| SearchExtBuilder |
Intermediate serializable representation of a search ext section.
|
| SearchHit |
A single search hit.
|
| SearchHit.Fields | |
| SearchHit.NestedIdentity |
Encapsulates the nested identity of a hit.
|
| SearchHits | |
| SearchHits.Fields | |
| SearchModule |
Sets up things that can be done at search time like queries, aggregations, and suggesters.
|
| SearchPhaseResult |
This class is a base class for all search releated results.
|
| SearchService | |
| SearchShardTarget |
The target that the search request was executed on.
|
| SearchSortValues |
| 枚举 | 说明 |
|---|---|
| MultiValueMode |
Defines what values to pick in the case a document contains multiple values for a particular field.
|
| 异常错误 | 说明 |
|---|---|
| SearchContextException | |
| SearchContextMissingException | |
| SearchException | |
| SearchParseException |


001/* 002 * Copyright (c) 2014 RobotsByTheC. All rights reserved. 003 * 004 * Open Source Software - may be modified and shared by FRC teams. The code must 005 * be accompanied by the BSD license file in the root directory of the project. 006 */ 007package org.usfirst.frc2084.CMonster2014.drive; 008 009/** 010 * Drive controller for robots with four wheels. Allows control over each side 011 * together or each wheel independently. 012 * 013 * @author Ben Wolsieffer 014 */ 015public class FourWheelDriveController extends DriveController { 016 017 protected WheelController frontLeftWheel; 018 protected WheelController frontRightWheel; 019 protected WheelController rearLeftWheel; 020 protected WheelController rearRightWheel; 021 022 /** 023 * Creates a new {@link FourWheelDriveController} with the specified 024 * {@link WheelController}s. 025 * 026 * @param frontLeftWheel the front left {@link WheelController} 027 * @param frontRightWheel the front right {@link WheelController} 028 * @param rearLeftWheel the rear left {@link WheelController} 029 * @param rearRightWheel the rear right {@link WheelController} 030 */ 031 public FourWheelDriveController(WheelController frontLeftWheel, WheelController frontRightWheel, WheelController rearLeftWheel, WheelController rearRightWheel) { 032 this.frontLeftWheel = frontLeftWheel; 033 this.frontRightWheel = frontRightWheel; 034 this.rearLeftWheel = rearLeftWheel; 035 this.rearRightWheel = rearRightWheel; 036 } 037 038 /** 039 * Set the left and right speeds of the robot using the specified values. 040 * For the {@link FourWheelDriveController}, {@code leftSpeed} sets both 041 * left {@link WheelController}s and {@code rightSpeed} sets both right 042 * {@link WheelController}s. 043 * 044 * @param leftSpeed {@inheritDoc} 045 * @param rightSpeed {@inheritDoc} 046 */ 047 public void drive(double leftSpeed, double rightSpeed) { 048 frontLeftWheel.set(leftSpeed); 049 rearLeftWheel.set(leftSpeed); 050 frontRightWheel.set(rightSpeed); 051 rearRightWheel.set(rightSpeed); 052 053 // Make sure to feed the watchdog! 054 safetyHelper.feed(); 055 } 056 057 /** 058 * Sets the speeds of all four {@link WheelController}s independently. 059 * 060 * @param frontLeftSpeed the speed of the front left wheel 061 * @param frontRightSpeed the speed of the front right wheel 062 * @param rearLeftSpeed the speed of the rear left wheel 063 * @param rearRightSpeed the speed of the rear right wheel 064 */ 065 public void drive(double frontLeftSpeed, double frontRightSpeed, double rearLeftSpeed, double rearRightSpeed) { 066 frontLeftWheel.set(frontLeftSpeed); 067 frontRightWheel.set(frontRightSpeed); 068 rearLeftWheel.set(rearLeftSpeed); 069 rearRightWheel.set(rearRightSpeed); 070 071 // Make sure to feed the watchdog! 072 safetyHelper.feed(); 073 } 074 075 /** 076 * Stops the robot. 077 */ 078 public void stopMotor() { 079 frontLeftWheel.set(0); 080 rearLeftWheel.set(0); 081 frontRightWheel.set(0); 082 rearRightWheel.set(0); 083 } 084 085 public String getDescription() { 086 return "Four Wheel Drive Controller"; 087 } 088}


So now we have our cool header with a custom paint background, let's expand on it.
We'll update the paint()
function to draw a more funky background and wouldn't it be great if we could choose the colour of the background whenever we wanted to use it? Another feature of the Paint API is the ability to access custom properties available to the element.
Let's take a look:
My Cool Header
My Cool Header
We add a custom property in our CSS:
.example {
--highColour: hsla(55, 90%, 60%, 1.0);
background-image: paint(headerHighlight);
}
Now we can use the inputProperties()
method in the registerPaint()
class, grab that property and use it within our paint()
function:
static get inputProperties() { return ['--highColour']; }
Note: The inputProperties()
method returns all properties affecting the element, not just custom properties.
paint(ctx, size, props) {
// Paint uses Typed OM to retrieve the custom property value, so, as with the Typed OM API, we have to use the get()
method to access the value
ctx.fillStyle = props.get('--highColour');
...
}
Back in our CSS, on elements that have this paint()
function generating their backgound, we can reset the --highColour
custom property to change its color:
.example {
--highColour: hsla(55, 90%, 60%, 1.0);
background-image: paint(headerHighlight);
}
.example:nth-of-type(2) {
--highColour: hsla(155, 90%, 60%, 1.0);
}
You can check out the entire registerPaint()
function in header-highlight.js here. Not only can we pass in custom properties, but also custom arguments when we call the paint()
function in our css. Let's take a look in part 4.


Vanguard - May 2019
At vanguard, I'm a full stack web developer. This means I'm well versed in both end of the stack (Back-end and Front-end). For the front-end of the stack, I'm currently using the Angular framework with spectator a wrapper for jest to run unit test, scss for styling our web components and a container pattern for the development of my components.
ADP - Mar 2018 to May 2019
At ADP, I worked as a team leader. The majority of my time was spend implementing new features for one of the company's main products (Workforce now). The rest of my time I was helping junior developers solve any blocking problems and guide them towards better code implementation. I was my team team scrum master, helping the team prioritize our tasks during the sprints.
Combustion Group - Jun 2016 to Mar 2018
As a Web Developer at Combustion group my job was to make sure that all web applications that were produced by the firm are well-maintained and scalable in a way that any developer in my team is able to contribute without any issues. Some of my responsibilities included meetings with teammates and stakeholders to collect requirements, talk about strategy and the overall goals of the product to increase product success.
Direct Market Designs - Jan 2016 to Oct 2016
At Direct Market Designs I was an intern responsible for the development and deployment of all websites for the different marketing campaigns created by the company. I worked with a team of graphic designers implementing their designs into the web. Moreover, I was in charge of organizing and developing all the multi-channel campaigns using a marketing automatization software created by a third-party vendor, which I was in constant communication with.


Toggle navigation
About
Projects
Resume
Blog
Project Portfolio
A/B Testing with Google Analytics
- (2016)
Python
Flask
HTML
CSS
Google Analytics
D3 Visualizations
- (2016)
D3.js
Python
Jupyter Notebook
HITS Algorithm with PySpark
- (2016)
PySpark
Python
Jupyter Notebook
Naive Bayes with PySpark's MLlib vs. from scratch
- (2016)
PySpark
Python
Jupyter Notebook
Amazon Review Helpfulness Prediction
- (2016)
PySpark
Python
Collaborative Filtering - Netflix
- (2016)
Python
Kaggle - What's Cooking?
- (2015)
Python
TensorFlow
Restful Web Service
- (2015)
Python
Case Study - Times Series
- (2015)
R
Case Study - Nils Baker
- (2015)
R
Case Study - Milk & Money
- (2015)
R
YouTube Trend Analysis
- (2015)
Python
SQL
Plotly
Naïve Bayes Sentiment Analysis
- (2015)
Python
Los Angeles Crime Analysis
- (2014)
Python
Pandas


A few months before, I was taking Zoloft (SSRI), and it worked but it was keeping me up at night, and while I felt decent mentally, I did not have any energy. The fact that I was taking Xanax along with Zoloft to sleep was not helping. I eventually quit taking the drug, but my depression gradually returned within about two months.
Unable to bear it, I wanted to try another anti-depressant. After some research I chose Remeron. Off topic but in the country I'm currently in (Pakistan), this med is pretty expensive. Anyway, I planned to take 30 mg for a week and then increase to 45 mg a day.
I began at 11:00 PM, by orally taking a 30 mg tab, with very little if any water, and about 30 minutes after dinner. Within 20 minutes, I was feeling exhausted. My little cousin was in my room drawing on herself with my wife's eye-liner and normally I would snatch away the eye-liner and put it out of reach of the child. However, while mentally I wanted to do this, it proved to be extremely taxing on my body. I didn't feel like doing anything other than sitting in bed. Even putting my hands up proved too much work. I recognized this feeling, this is how I feel on a few milligrams of Xanax.
After about 30 minutes, I became very agitated and restless. However, physically I was pretty much disabled. It's as if I was on a large dose of Xanax but only experiencing the physical effects, mentally I wasn't relaxed or tranquil like I normally am on Xanax. Mentally I was irritable and REALLY wanted to sleep. The most annoying thing was that breathing felt voluntary. I would try to relax and go to sleep, but after a few seconds I would notice that I have not taken a breath and would take a few quick deep breaths to compensate. This kept happening for what seemed forever, but I eventually fell asleep.
 For the first time, I was in a very deep sleep and I did not awake all night. Upon waking up, I was extremely exhausted and just wanted to lay in bed. I was unable to sleep again however. One strange thing that would keep happening everyday on this med is that I would wake up in the morning very abruptly. No noise, nothing happens in the room to disturb my sleep. After waking up, I would never be able to sleep again, for some reason. It's as if the med is programmed to wake me up at a certain time.
I've been on this med for about 4 days, and it has not done too much for my depression. One thing I want to talk about is the effect this has had on my dreams. Zoloft also did the same thing but there was a difference between Remeron and Zoloft in regard to dreams. Zoloft would give me very similar dreams but I would always wake up at night frightened and sweaty. Upon returning to sleep. Sometimes I was unable to tell if I was waking up to reality or to another dream.
The dreams on Zoloft were recursive, for example I would have a dream, and then wake up literally wet with sweat, and then I would realize that I've woken up into another dream, and this would keep happening. I was probably waking up into reality and just falling asleep again shortly after, putting me instantly back into another dream.
Remeron would give me the same dreams but it would be one long dream throughout the night. Sometimes if I wake up and go back to sleep fast enough, the dream continues. With Remeron, I feel like I'm never really awake until an hour or so after I wake up. My eyes are open and I can see/hear but I feel mentally brain dead. As if half my brain is still asleep. With both meds, if I take a nap during the day, I would also have another dream.
Now the dreams I've had on anti-depressants are VERY VERY weird. They aren't nightmares, and they aren't really scary in the sense of death/ghosts/etc. They are very believable and they contain so much detail. Also, they seem to have nothing at all to do with what I've experienced during the day before going to sleep. They seem so random and wacky, but when I wake up in the morning, I usually spend 30 minutes thinking about the dream and trying to replay or continue it in my head.
The dreams are not much different than tripping on a recreational drug. They seem to last long in my head, they are vivid and they make me think after the experience is over. Normally in a dream I wake up and just go about my day. After waking up from one of the dreams I've had on anti-depressants, I would spend hours trying to make sense of what the dream meant.
With Remeron I had the experience with the first dose, and with Zoloft I experienced it a few days after taking the first dose (25 mg) and during withdrawal. After a few weeks on the drugs, the vivid dreams seem to subside or become very weak. I noticed that the dreams sometimes would intersect with other dreams I've had on the meds. Parts of the previous dreams would show up in the new dreams.
I would love to share the dreams but they would make no sense. It's like a DMT trip, the dreams are very hard to describe in words, and I feel like if I do, they would lose too much detail. I can't comprehend how weird the dreams are. For example, I woke up this morning from a dream and I started asking myself questions about the dream, weird questions that only make sense to me, such as:
'How can a whole county. as well as a natural disaster, happen in a building in the middle of Times Square?'
'Instead of trying to save ourselves by building wooden wheels so we can escape from the toxic, why was everyone using the roller-coaster?'
'Why was the roller-coaster covered with sand? was it even a roller-coaster?'
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Make sure you refresh both the extensions page (chrome://extensions/) and the gmail tab after updating the settings.
Save


Aspect is a web-based nodal editor, built upon Typescript, Vue and Three.js. Its goal is to provide a graphical means of constructing Directed Acyclic Graphs (DAGs) which map to RPC APIs and map-reduce systems, defined elsewhere. In the broadest sense, Aspect can be thought of as a stateless function, which takes in a scene defintion and returns a new one.
Intended targets for Aspect-js are:
After having worked years with several nodal systems: Nuke, Houdini, Maya's hypershade, Softimage, Fabric Engine, Modo's MeshOps, MeVisab, etc. And some time with several map reduce frameworks: Geode, Apache Spark, Apache Beam, and Apache Hadoop. And attempting to build custom dataflow oriented frameworks: Axon and interogrador, a custom map-reduce framework for mesh construction inside Modo. I have come to the conclusion that visual, DAG-oriented programming can be a very poweful paradigm for performing and comprehending complicated work, but that is bedevilled by its universal implementation as part of the context of solving problems related to, and only to, specific data structures, rather than as a general utility. This is especially so in the realm of data science, particularly computer vision.
Good nodal editors, say those popular in visual effects, have shallow learning curves, low technical barriers to entry and are incrediby useful. They are also proprietary, tied to proprietary formats and designed to run one a single machine, even though they are often found in render farms. Good data science libraries, can efficiently exploit large distributed systems, are made incredibly powerful through the use of machine learning, and can do things at a scale that no render farm and army of humans can. They also have no decent nodal editors, large technical barriers to entry and aren't easily accessible across locations.
Aspect-js is meant to combine these two worlds in a declarative manner, with predifined extensibility and careful attention paid towards how it maps to frameworks that solve hard problems at scale, rather than trying to compete with them.
A scene is a collection of graphs which may or may not connect to eachother. Graphs are comprized of nodes and edges. Nodes should be thought of as abstract, graphical representations of singular remote procedure calls. Nodes connect to eachother via ports. The outport of one node connects to the inport of another, and thus a graph network of computation becomes defined. Inports to a node, represent the singular parameters of the RPC function it abstracts. Outports represent what the RPC function returns. Edges are defined as an ordered pair of outport and inport.
The scene and all its components are represented within a single JSON object which represents the entire state of the DAG at one time. All other parts of Aspect; the Three.js wrapper classes, the Params class, the NodePane component, serve to manipulate this underlying data structure, as an aspect of it. For instance, the class Node serves as the graphical, 3D aspect of a node as defined within some graph of some scene. You can change its size, color, 3D position, etc. In the NodePane, a different aspect of this underlying structure is represented: its ports and their values. In the nodepane, you can alter the constant values values supplied to specific ports of a node, you can alter the GUI widgets used to represent each port, etc.
npm install
conda create -n aspect-js --file requirements.txt
npm run serve
Alternatively, I would recommend
npm install -g @vue/cli
vue ui
and then click serve on the resulting vue ui page.
npm run build
or click build in the vue ui page.
npm run lint
or click lint in the vue ui page.
npm run test
or click test in the vue ui page.
bin/build-docs.sh


Listen for the WebViewJavascriptBridgeReady event, ensuring that the "earlier triggered" event takes effect
Use callHandler send request to the Android side
setMenu
clearMenu
Use registerHandler to receive events send from the Android side
When the menu of the title bar is clicked, the corresponding click event will be received.


{% extends 'base.html' %} {% load i18n %} {% load bootstrap3 %} {% block content %}
{{ network.network_description }} {% if request.user.organization == network.owner_organization %}{% endif %}
Managing Organization: {{ network.owner_organization.name }}
Member Organizations: {% for organization in network.organizations.all %}{{ organization.name }}, {% endfor %}


CHAPTER 58 — Adding Buttons to a Frame
The previous chapters have introduced
event-driven programming
and the three parts of a GUI application:
- The Graphical User Interface:
- Container objects--JFrame
- Other objects--buttons, text fields, others.
- Listener methods:
- Each GUI object has a listener object registered for it
for each type of event it generates for which a response is
expected.
- Application code.
- The purpose of the program.
This chapter discusses how to add a button
to a frame and how to register a
listener for its events.
Chapter Topics:
- Adding a button to a frame.
- The content pane of a frame.
- Layout managers.
- Action listeners.
- Registering a listener with a GUI component.
- The
actionPerformed()
method.
- Changing the background color of a frame.


Thank you for your interest.
We’re thrilled you’re here and believe in the power and beauty of what we’re building at Green Stone.
While we’re not interviewing new candidates at this time you can keep up with our latest by signing up to our monthly #ModernLoyalty newsletter, follow us on Instagram and Twitter .
Any other inquiries can be directed to our Operator<EMAIL_ADDRESS>See what we're up to


FAQs
The YAMLyzer is aimed to make rendered yaml files from Airship Projects into a more readable form.
1. Use the render command to generate a rendered yaml file
2. Use the Upload button above to upload the rendered yaml file
3. View your visualized yaml file
This visualizer is powered by python3-django and the PyYAML library.


Basic Information
Job Title
Category
Location
Work Type
Job Description
Salary Settings
Salary Type
Income


My name is Young Joon Oh, without a middle name.
In my case, Young Joon, including the space, is considered my first name.
Initially, when I created my passport, it was common for many Koreans to include a space or dash in their first names when written in English.
Nowadays it is more common to write the first name without a space or dash, such as Youngjoon.
However, due to path dependence, there is still a space in my first name when written in English.
I am currently actively seeking opportunities in the job market.
I was born and raised in South Korea, where I pursued a major in Political Science and a minor in Economics during my college years. My focus for my master's thesis revolved around studying rational choice modeling in voting behaviors.
In 2015, I successfully obtained my Ph.D. in Public Policy and Political Economy from the University of Texas at Dallas. My doctoral dissertation involved analyzing bank failures, building resilient banking systems, and investigating sluggish recovery using agent-based network simulation modeling.
Following the completion of my Master's program, I gained valuable experience working for about 7 years in the National Assembly of Korea. Additionally, I actively participated in various campaign teams for significant elections in South Korea, including the Presidential election in 2007, Seoul Mayoral election in 2006, and General election in 2004.
After completing my Ph.D., I had the opportunity to contribute as a postdoctoral research associate at the Julie Ann Wrigley Global Institute of Sustainability at Arizona State University.
I can be reached at :


| 855 | (A) | witħ-owttyn weme or wounde or any wo ełłs |
| 859 | (C) | witħ-oute wemme or wounde . or any wo ellys |
| 845 | (D) | with-out wound oþer werke witħ wantyng of food |
| 822 | (E) | with-owte wounde or eny hurt . with wantyng of foode |
| (Ex) | ---- no text ---- | |
| (L) | ---- no text ---- | |
| (P) | ---- no text ---- | |
| 830 | (U) | With outen wounde or wek / with want of her fode |
| (V) | ---- no text ---- |


We are building a welcoming and diverse global community of R software users, developers, and research software engineers who want to make their research more open and reproducible. We aim to build capacity of novices, experts, and those in between. Participants come from across academia, government, industry, and non-profits. We welcome participation that adheres to our code of conduct. The rOpenSci Community Contributing Guide outlines many ways to get involved.
Our quarterly community calls are open to everyone. They're an opportunity to connect with rOpenSci community members around the world. Join us for lively discussions with experts on both technical and social topics, like development, review, security and maintenance of R packages, applications of our packages in open science, or developing a code of conduct. Every Community Call becomes a rich resource with video and collaborative notes.
Catch up with past calls


--- layout: post title: "Understanding The Recurrent Neural Network" subtitle: "RNN - The Recurrent Neural Network" date: 2018-04-14 10:00:00 -0000 background: '/img/posts/06.jpg' tags: [Machine Learning, ML, AI, Deep Learning, Neural Network, Artificial Intelligence, RNN, Recurrent Neural Network, LSTM] ---
As per Wikipedia, a recurrent neural network (RNN) is a class of artificial neural network where connections between units form a directed graph along a sequence. This allows it to exhibit dynamic temporal behavior for a time sequence. Unlike feedforward neural networks, RNNs can use their internal state (memory) to process sequences of inputs. This makes them applicable to tasks such as unsegmented, connected handwriting recognition or speech recognition.
Recurrent Neural Network comes into the picture when any model needs context to be able to provide the output based on the input.
Sometimes the context is the single most important thing for the model to predict the most appropriate output.
Let's understand this by an analogy. Suppose you are watching a movie, you keep watching the movie as at any point in time, you have the context because you have seen the movie until that point, then only you are able to relate everything correctly. It means that you remember everything that you have watched.
Similarly, RNN remembers everything. In other neural networks, all the inputs are independent of each other. But in RNN, all the inputs are related to each other. Let's say you have to predict the next word in a given sentence, in that case, the relation among all the previous words helps in predicting the better output. The RNN remembers all these relations while training itself.
In order to achieve it, the RNN creates the networks with loops in them, which allows it to persist the information.
This loop structure allows the neural network to take the sequence of input. If you see the unrolled version, you will understand it better.
As you can see in the unrolled version. First, it takes the x(0) from the sequence of input and then it outputs h(0) which together with x(1) is the input for the next step. So, the h(0) and x(1) is the input for the next step. Similarly, h(1) from the next is the input with x(2) for the next step and so on. This way, it keeps remembering the context while training.
This way the RNN works.
RNN helps wherever we need the context from the previous input.
The following are the few applications of the RNN:
Now a days, RNN has become very popular as it helps in solving many real-life problems which the industries are facing.
That's it for now.


File: Small_Office.aps Full path: C:\Users\cvskf\OneDrive - Loughborough University\_Git\building-energy\IES_analysis_notebooks\IES_model\Small_Office\vista\Small_Office.aps Time when simulation was finished: 07:20.12, Saturday, September 21 Weather file: C:\Program Files (x86)\IES\Shared Content\Weather\KEW.FWT Output interval: 60 minutes Simulation period: Wed, January 01, to Wed, December 31 Rooms with surface data recorded = 0 Simulation variables recorded: System nat. gas CE System elec. CE Total system CE Total lights CE Total equip CE Total nat. gas CE Total elec. CE Total CE Total CE ex equip Boilers energy Ap Sys boilers energy Ap Sys boilers space cond'g energy Ap Sys boilers DHW energy Chillers energy Ap Sys chillers energy Ap Sys aux + DHW/solar pumps energy Ap Sys heat rej fans/pumps energy System natural gas System electricity Total system energy Total lights energy Total equip energy Total nat. gas Total electricity Total energy Boiler energy Boiler space heating energy Boiler space cooling energy Boiler space cond'g energy Boiler DHW energy Chiller energy Chiller heat rej fans/pumps energy System auxiliary energy DHW & solar heating pump energy Lights energy Boiler process energy Chiller process energy Room heating plant sens. load Room hum. plant load System air heating load Aux vent heating load Boilers load Ap Sys boilers load Ap Sys boilers space cond'g load Ap Sys boilers DHW load Room cooling plant sens. load Room dehum. plant load System air sens. clg. load System air lat. clg. load Aux vent sens. clg. load Aux vent lat. clg. load Chillers load Ap Sys chillers load DHW heating demand Boiler CE Boiler space heating CE Boiler space cooling CE Boiler space cond'g CE Boiler DHW CE Chiller CE Chiller heat rej. pump CE System auxiliary energy CE DHW & solar heating pump CE Lights CE Sys Boiler process CE Sys Chiller process CE Room heating plant sens. load Room hum. plant load System air heating load Aux vent heating load DHW heating demand Solar heating system input Boiler load Boiler space heating load Boiler space cooling load Boiler space cond'g load Boiler DHW load CH[C]P heat contribution Room cooling plant sens. load Room dehum. plant load System air sens. clg. load System air lat. clg. load Aux vent sens. clg. load Aux vent lat. clg. load Chiller load System air flow rate System air heat recovery temp System air supply temperature System air supply moisture content Aux vent flow rate Boiler process load Chiller process load Process heat removal Process heat available for recovery Process heat recovered Process heat recovery heat pump Air temperature Dry resultant temperature Mean radiant temperature Heating set point Cooling set point Plant profile HVAC zone cooling setpoint HVAC zone heating setpoint Heating occupied and available Cooling occupied and available Room CO2 concentration Space conditioning sensible Heating plant sensible load Cooling plant sensible load Internal gain Lighting gain Equipment gain People gain Solar gain External conduction gain Internal conduction gain Air system input sensible Aux vent gain Natural vent gain Infiltration gain Free cooling vent gain Duct conduction gain Duct leakage sensible gain ApSys air supply ApHVAC air supply Auxiliary vent Auxiliary vent temperature Natural vent Infiltration Free cooling vent Duct leakage inflow Space conditioning latent Humidification plant load Dehumidification plant load Cooling + dehum plant load Internal latent gain Number of people DHW demand load DHW demand flow DHW target supply temperature DHW supply temperature Daylight illuminance 1 Daylight illuminance 2 Air system input latent Vent/infiltr. latent gain Duct leakage lat gain Process simulation latent gain Process simulation sensible gain Air & furniture dynamics gain System occupied and available System operation and available _________________________________________


Miami University Libraries: Classic Catalog
OhioLINK
Telnet version
Login as
library
New Catalog
Search for:
Keywords
Author
Title
Subject Heading
Advanced keyword search
All search options
Your search:
Limit results to:


"""The simplest mixin for creating and submiting tasks to task pool."""
import copy
import warnings
import asyncio
from typing import (Callable, Dict, Any, List, Union)
from aio_parallel_tools.aio_task_pool.core.exception import NotAvailable
from aio_parallel_tools.aio_task_pool.core.task import Task
[docs]class SimpleProducerMixin:
"""Simple Producer Mixin.
Requirement:
queue (Property): message queue.
loop (Property): event loop.
size (Property): worker pool's size.
waiting_tasks_number (Property): Waiting task size in queue.
make_message (Method): make task to message
close_workers (Asynchronous Method): Send worker pool size's close signal to the queue.
close_workers_nowait_soft (Method): Send worker pool size's close signal to the queue with no wait.
close_workers_hard (Method): Cancel worker hardlly.
Support:
paused (Property): Check if user can submit tasks.
closed (Property): Check if the pool is closed.
start_accept (Method): Start Accept tasks.
pause (Method): Pause the task pool.
submit (Asynchronous Method): Submit task to the task pool.
submit_nowait (Method): Submit task to the task pool with no wait.
close_pool (Asynchronous Method): Send close signal to all worker.
close_pool_nowait (Method): Send close signal to all workers with no waiting.
"""
def __init__(self):
"""Initialize Simple Producer Mixin."""
self._paused = True
@property
def paused(self) -> bool:
"""Check if user can submit tasks.
If the task pool can accept new tasks,the result is False; else it's True.
Returns:
bool: can submit or not.
"""
return self._paused
@property
def closed(self) -> bool:
"""Check if the pool is closed."""
return self.pause is True and self.size == 0
[docs] def start_accept(self):
"""Start Accept tasks."""
self._paused = False
[docs] def pause(self) -> bool:
"""Pause the task pool.
Returns:
bool: Check if The task pool is paused
"""
self._paused = not self._paused
return self.paused
def _make_task(self,
task_func: Callable[[Any], Any],
args: List[Any] = [],
kwargs: Dict[str, Any] = {}) -> Task:
fut = self._loop.create_future()
args = copy.deepcopy(args)
kwargs = copy.deepcopy(kwargs)
task = Task(fut, task_func, args, kwargs)
return task
[docs] async def submit(self,
task_func: Callable[[Any], Any], *,
func_args: List[Any] = [],
func_kwargs: Dict[str, Any] = {},
blocking: bool = True, **kwargs) -> Union[asyncio.Future, Any]:
"""Submit task to the task pool.
Args:
task_func (Callable[[Any], Any]): The task function which will be called by the workers.
func_args (List[Any], optional): The positional parameters for the task function. Defaults to [].
func_kwargs (Dict[str, Any], optional): The keyword parameters for the task function. Defaults to {}.
blocking (bool, optional): Set if waiting for the task's result. Defaults to True.
Raises:
NotAvailable: The task pool is paused
Returns:
Union[asyncio.Future, Any]: if blocking is True, submit will return the result of the task;
else it will return a future which you can await it to get the result.
"""
if not self.paused:
task = self._make_task(task_func, func_args, func_kwargs)
fut = task.fut
message = self.make_message(task, **kwargs)
if blocking:
await self.queue.put(message)
return await fut
else:
asyncio.create_task(self.queue.put(message))
return fut
else:
raise NotAvailable("task pool is paused")
[docs] def submit_nowait(self,
task_func: Callable[[Any], Any], *,
func_args: List[Any] = [],
func_kwargs: Dict[str, Any] = {},
**kwargs) -> asyncio.Future:
"""Submit task to the task pool with no wait.
Args:
task_func (Callable[[Any], Any]): The task function which will be called by the workers.
func_args (List[Any], optional): The positional parameters for the task function. Defaults to [].
func_kwargs (Dict[str, Any], optional): The keyword parameters for the task function. Defaults to {}.
Raises:
NotAvailable: The task pool is paused or
e: other exception
NotAvailable: task pool is full, can not put task any more
Returns:
asyncio.Future: a future which you can await it to get the result.
"""
if not self.paused:
task = self._make_task(task_func, func_args, func_kwargs)
fut = task.fut
message = self.make_message(task, **kwargs)
try:
self.queue.put_nowait(message)
except asyncio.QueueFull as qfe:
raise NotAvailable("task pool can not put task any more")
except Exception as e:
raise e
else:
return fut
else:
raise NotAvailable("task pool is paused")
async def _waiting_all_task_done(self):
while self.waiting_tasks_number > 0:
await asyncio.sleep(0.1)
[docs] async def close_pool(self,
close_worker_timeout: Union[int, float, None] = None,
close_pool_timeout: int = 3,
safe: bool = True) -> None:
"""Close all workers and paused the task pool.
Args:
close_worker_timeout (Union[int, float, None], optional): Timeout for closing all workers. Defaults to None.
close_pool_timeout (int, optional): Timeout for join left tasks. Defaults to 3.
safe (bool, optional): when getting exceptions, raise it or warning it. Defaults to True.
Raises:
te: close workers timeout.
e: unknown error when closing workers.
te: waiting for left tasks done timeout
e: unknown error when waiting for left tasks done
"""
self._paused = True
if close_worker_timeout and isinstance(close_worker_timeout, (int, float)):
await asyncio.wait_for(self._waiting_all_task_done(), timeout=close_worker_timeout)
else:
await self._waiting_all_task_done()
try:
await self.close_workers()
except asyncio.TimeoutError as te:
if safe:
warnings.warn("close workers timeout")
else:
raise te
except Exception as e:
if safe:
warnings.warn(f"unknown error {e} when closing workers")
else:
raise e
finally:
try:
await asyncio.wait_for(self.queue.join(), timeout=close_pool_timeout)
except asyncio.TimeoutError as te:
if safe:
warnings.warn(f"waiting for left tasks done timeout, {self.waiting_tasks_number}")
else:
raise te
except Exception as e:
if safe:
warnings.warn(f"unknown error {e} when waiting for left tasks done")
else:
raise e
[docs] def close_pool_nowait(self, soft: bool = True) -> None:
"""Close all workers and paused the task pool without waiting.
Args:
soft (bool, optional): if True, this interface will send Signal to task pool to close workers;
else all workers will be cancel. Defaults to True.
"""
self._paused = True
if soft:
self.close_workers_nowait_soft()
else:
self.close_workers_hard()


Until recently, OBO-Edit did not strictly enfore the OBO format restrictions on dbxrefs. Many ontologies now contain dbxrefs that are not OBO compatible. The Dbxref Check will display a warning if a dbxref is not OBO-compatible. It checks for:
A dbxref can be configured to only perform some of the checks above by clicking the "configure" button in the Verification Plugin:
Deselect a sub-check to disable it.


Liam Sweeney
About
Portfolio
Contact
Portfolio
Print Design
Broadcast Design
Crystal Collector
The Office Trivia
Froogle
watchIndex
Connect with Me


Command Line Interface
Options
Options can have an unlimited number of long-form aliases and single-character shortcuts: --option
, -o
.
Options can have string, integer, or floating-point values.
Option values can be separated by either a space, --opt 123
, or an equals symbol, --opt=123
. Either syntax can be used with shortcuts: -o 123
, -o=123
.
Multiple shortcuts can be condensed into a single block, e.g. -abc foo bar
. Trailing arguments are consumed in sequence as required by the options.
Multivalued Options
Options can be treated as singular or multivalued as circumstances require. Each option maintains an internal list to which newly parsed values are appended; the (singular) value of the option is the final value in the list or the default value if the list is empty.
For example, in the command below:
$ myapp --foo 123 --foo 456
the value of the option foo
is 456
but the list [123, 456]
is also available for use if required.
Flags
Flags are valueless options — they're either present or absent, but take no arguments. Like options, flags can have an unlimited number of long-form aliases and single-character shortcuts: --flag
, -f
.
Positional Arguments
Options and flags can be preceded by, followed by, or interspaced with positional arguments.
Argslib supports the standard --
switch for turning off option-parsing. All arguments following a --
will be treated as positional arguments, even if they begin with a single or double dash.
Commands
Argslib supports git-style command interfaces with arbitrarily-nested commands. Commands have builtin support for an automatic --help
flag and an automatic help <cmd>
command, i.e. the commands
$ myapp <cmd> --help
and
$ myapp help <cmd>
are functionally identical and will both print the help text registered with the command.


Data from the Web to R
12 May 2014Much of the behind-the-scenes of my research work and side projects have to do with the so-called Web Technologies. Consequently, questions like how to read/import data sets?, or how to preprocess data? become more relevant with data coming from the Web.
How do I parse XML / HTML documents in R? How do I scrape those pieces of valuable information? How do I use R to interact with my browser and make the right requests? These are some of the frequently asked questions I've been constantly coming across with when trying to get data from the Web.
Web Technologies for R
It's no secret or news that the Web is a vast source of data and information. The amount of content and its exponential growth surpasses our capacity to handle it analytically. We hardly know what to do with it, not to mention how to make sense of it. Most of us —statisticians, analysts, data scientists, data miners— are in the same quest for our holy grails: gaining insight and learning from data. That's where most of us are focusing our energies. However, in order to start crunching numbers, building models, and training machines to learn, we must first have access to the data itself.
For those of us who primarily work with R, there are various packages that can help us get access to our precious data sources. In addition, there are various resources that can guide us on how to use the tools and functions in those packages.
Deborah Nolan and Duncan Temple Lang have written an awesome book recently published at the beginning of this year.
XML and Web Technologies for Data Sciences with R is one of those books that I've been dreaming about for so long. It is THE compendium of reference for anyone interested in how to use R for interacting with Web Technologies.
(Parenthesis: I tip my hat to Duncan for all his amazing work, and his titanic effort leading the omegahat project. Bravo!)
Before Deb and Duncan's book, the closest thing was Paul Murrell's excellent book Introduction to Data Technologies (ItDT).
You are probably more familiar with Paul's work around plots and data visualization with his famous book R Graphics, but his ItDT ebook is one of those rare jewels that most of my closest colleagues have highly ignored. If you haven't taken a look at it before, stop reading this post and come back after you've checked Paul's ItDT.
Also recently this year, a new Task View for Web Technologies has been added to CRAN. This only reflects the trending topic status that those Web tools have in the R community.
Getting Data from the Web with R
I'm way behind the experience and expertise of Deb, Duncan, Paul and many other R leading figures. But still I want to contribute with my own take on how to use R for getting data from the Web. After some delays due to my design hesitations, I've finished a set of slides focused on: How to get data from the Web with R.
In a nutshell, you'll find the following content:
- Introduction
- Reading files from the Web
- Basics of XML
- Parsing XML and HTML Documents
- Handling JSON data
- Basics of HTTP and RCurl
- Getting Data via Web Forms
- Getting Data via Web APIs
PS
Inspired by some friends' inquiry, I thought this could also be a nice opportunity for me to talk about some of the creative process I went through to design and prepare the material of these slides.


--- title: Expectation Propagation - The Essential Minimum author: Mauro Camara Escudero date: '2020-03-09' slug: expectation-propagation-the-essential-minimum categories: - expectation-propagation tags: - expectation-propagation - variational-inference subtitle: '' summary: 'The bare practical minimum to understand Expectation Propagation' authors: [] lastmod: '2020-03-09T22:52:13Z' featured: no image: caption: '' focal_point: '' preview_only: no projects: [] bibliography: bibliography.bib ---
Taken from Vehtari et al. (2014). Assume that you can factorize your target distribution \[ f(\theta) \propto \prod_{k=0}^K f_k(\theta) \] Approximate target distribution using a distribution with a similar factorization, called the global approximation \[ g(\theta) \propto \prod_{k=0}^K g_k(\theta) \] At each iteration of the algorithm, and for every factor \(k=1, \ldots, K\) form the cavity distribution by removing \(k^{\text{th}}\) term from the global approximation \[ g_{-k} \propto \frac{g(\theta)}{g_k(\theta)} \] also form the tilted distribution by including \(f_k(\theta)\) to the cavity distribution (in place of \(g_k(\theta)\)) \[ g_{\backslash k}(\theta) \propto f_k(\theta) g_{-k}(\theta) \] The algorithm updates the site approximation \(g_k(\theta)\) so that the new global approximation approximates the tilted distribution \[ g_k(\theta)^{\text{new}}g_{-k}(\theta) \approx f_k(\theta)g_{-k}(\theta) \]
Vehtari, Aki, Andrew Gelman, Tuomas Sivula, Pasi Jylänki, Dustin Tran, Swupnil Sahai, Paul Blomstedt, John P. Cunningham, David Schiminovich, and Christian Robert. 2014. “Expectation Propagation as a Way of Life: A Framework for Bayesian Inference on Partitioned Data.”


Number of Worms:
Set
Cells Per X and Y:
Set
Generate!
Elapsed Time:
0
Download as Image
Return to games


Gecode::CpltSetVar Class Reference
[Set variables with complete domain representation]
#include <cpltset.hh>
Inherits Gecode::VarBase< Gecode::CpltSet::CpltSetVarImp >.
Detailed Description
Finite set variable with complete domain representation.Definition at line 97 of file cpltset.hh.
Value access | |
| unsigned int | glbSize (void) const |
| Return the size of the greatest lower bound. | |
| unsigned int | lubSize (void) const |
| Return the size of the least upper bound. | |
| unsigned int | unknownSize (void) const |
| Return the size of lub-glb. | |
| unsigned int | cardMin (void) const |
| Return current cardinality minimum. | |
| unsigned int | cardMax (void) const |
| Return current cardinality maximum. | |
| int | lubMin (void) const |
| Return minimum of the least upper bound. | |
| int | lubMax (void) const |
| Return maximum of the least upper bound. | |
| int | glbMin (void) const |
| Return minimum of the greatest lower bound. | |
| int | glbMax (void) const |
| Return maximum of the greatest lower bound. | |
Domain tests | |
| bool | contains (int i) const |
| Test whether i is in greatest lower bound. | |
| bool | notContains (int i) const |
| Test whether i is not in the least upper bound. | |
| bool | assigned (void) const |
| Test whether this variable is assigned. | |
Cloning | |
| void | update (Space *home, bool share, CpltSetVar &x) |
| Update this variable to be a clone of variable x. | |
Public Member Functions | |
| CpltSetVar (void) | |
| Default constructor. | |
| void | dispose (Space *home) |
| Deallocate memory. | |
| GECODE_CPLTSET_EXPORT | CpltSetVar (Space *home, int glbMin, int glbMax, int lubMin, int lubMax, unsigned int cardMin=0, unsigned int cardMax=Set::Limits::card) |
| Initialize variable with given bounds and cardinality. | |
| void | init (Space *home, int glbMin, int glbMax, int lubMin, int lubMax, unsigned int cardMin=0, unsigned int cardMax=Set::Limits::card) |
| Initialize variable with given bounds and cardinality. | |
| GECODE_CPLTSET_EXPORT | CpltSetVar (Space *home, const IntSet &glbD, int lubMin, int lubMax, unsigned int cardMin=0, unsigned int cardMax=Set::Limits::card) |
| Initialize variable with given bounds and cardinality. | |
| void | init (Space *home, const IntSet &glbD, int lubMin, int lubMax, unsigned int cardMin=0, unsigned int cardMax=Set::Limits::card) |
| Initialize variable with given bounds and cardinality. | |
| GECODE_CPLTSET_EXPORT | CpltSetVar (Space *home, int glbMin, int glbMax, const IntSet &lubD, unsigned int cardMin=0, unsigned int cardMax=Set::Limits::card) |
| Initialize variable with given bounds and cardinality. | |
| void | init (Space *home, int glbMin, int glbMax, const IntSet &lubD, unsigned int cardMin=0, unsigned int cardMax=Set::Limits::card) |
| Initialize variable with given bounds and cardinality. | |
| GECODE_CPLTSET_EXPORT | CpltSetVar (Space *home, const IntSet &glbD, const IntSet &lubD, unsigned int cardMin=0, unsigned int cardMax=Set::Limits::card) |
| Initialize variable with given bounds and cardinality. | |
| void | init (Space *home, const IntSet &glbD, const IntSet &lubD, unsigned int cardMin=0, unsigned int cardMax=Set::Limits::card) |
| Initialize variable with given bounds and cardinality. | |
Related Functions | |
| (Note that these are not member functions.) | |
| GECODE_CPLTSET_EXPORT std::ostream & | operator<< (std::ostream &, const Gecode::CpltSetVar &x) |
| Print bdd variable x. |
Constructor & Destructor Documentation
| Gecode::CpltSetVar::CpltSetVar | ( | void | ) | [inline] |
| Gecode::CpltSetVar::CpltSetVar | ( | Space * | home, | |
| int | glbMin, | |||
| int | glbMax, | |||
| int | lubMin, | |||
| int | lubMax, | |||
| unsigned int | cardMin = 0 , |
|||
| unsigned int | cardMax = Set::Limits::card | |||
| ) |
Initialize variable with given bounds and cardinality.
The variable is created with greatest lower bound , least upper bound , and cardinality minimum cardMin and maximum cardMax. The following exceptions might be thrown:
- If the bounds are no legal set bounds (between Set::Limits::min and Set::Limits::max), an exception of type Gecode::Set::VariableOutOfRangeDomain is thrown.
- If the cardinality is greater than Set::Limits::max_set_size, an exception of type Gecode::Set::VariableOutOfRangeCardinality is thrown.
- If minCard > maxCard, an exception of type Gecode::Set::VariableFailedDomain is thrown.
Definition at line 42 of file cpltset.cc.
| Gecode::CpltSetVar::CpltSetVar | ( | Space * | home, | |
| const IntSet & | glbD, | |||
| int | lubMin, | |||
| int | lubMax, | |||
| unsigned int | cardMin = 0 , |
|||
| unsigned int | cardMax = Set::Limits::card | |||
| ) |
Initialize variable with given bounds and cardinality.
The variable is created with greatest lower bound glbD, least upper bound , and cardinality minimum cardMin and maximum cardMax. The following exceptions might be thrown:
- If the bounds are no legal set bounds (between Set::Limits::min and Set::Limits::max), an exception of type Gecode::Set::VariableOutOfRangeDomain is thrown.
- If the cardinality is greater than Set::Limits::max_set_size, an exception of type Gecode::Set::VariableOutOfRangeCardinality is thrown.
- If minCard > maxCard, an exception of type Gecode::Set::VariableFailedDomain is thrown.
Definition at line 58 of file cpltset.cc.
| Gecode::CpltSetVar::CpltSetVar | ( | Space * | home, | |
| int | glbMin, | |||
| int | glbMax, | |||
| const IntSet & | lubD, | |||
| unsigned int | cardMin = 0 , |
|||
| unsigned int | cardMax = Set::Limits::card | |||
| ) |
Initialize variable with given bounds and cardinality.
The variable is created with greatest lower bound , least upper bound lubD, and cardinality minimum cardMin and maximum cardMax. The following exceptions might be thrown:
- If the bounds are no legal set bounds (between Set::Limits::min and Set::Limits::max), an exception of type Gecode::Set::VariableOutOfRangeDomain is thrown.
- If the cardinality is greater than Set::Limits::max_set_size, an exception of type Gecode::Set::VariableOutOfRangeCardinality is thrown.
- If minCard > maxCard, an exception of type Gecode::Set::VariableFailedDomain is thrown.
Definition at line 73 of file cpltset.cc.
| Gecode::CpltSetVar::CpltSetVar | ( | Space * | home, | |
| const IntSet & | glbD, | |||
| const IntSet & | lubD, | |||
| unsigned int | cardMin = 0 , |
|||
| unsigned int | cardMax = Set::Limits::card | |||
| ) |
Initialize variable with given bounds and cardinality.
The variable is created with greatest lower bound glbD, least upper bound lubD, and cardinality minimum cardMin and maximum cardMax. The following exceptions might be thrown:
- If the bounds are no legal set bounds (between Set::Limits::min and Set::Limits::max), an exception of type Gecode::Set::VariableOutOfRangeDomain is thrown.
- If the cardinality is greater than Set::Limits::max_set_size, an exception of type Gecode::Set::VariableOutOfRangeCardinality is thrown.
- If minCard > maxCard, an exception of type Gecode::Set::VariableFailedDomain is thrown.
Definition at line 86 of file cpltset.cc.
Member Function Documentation
| void Gecode::CpltSetVar::dispose | ( | Space * | home | ) | [inline] |
| void Gecode::CpltSetVar::init | ( | Space * | home, | |
| int | glbMin, | |||
| int | glbMax, | |||
| int | lubMin, | |||
| int | lubMax, | |||
| unsigned int | cardMin = 0 , |
|||
| unsigned int | cardMax = Set::Limits::card | |||
| ) | [inline] |
Initialize variable with given bounds and cardinality.
The variable is created with greatest lower bound , least upper bound , and cardinality minimum cardMin and maximum cardMax. The following exceptions might be thrown:
- If the bounds are no legal set bounds (between Set::Limits::min and Set::Limits::max), an exception of type Gecode::Set::VariableOutOfRangeDomain is thrown.
- If the cardinality is greater than Set::Limits::max_set_size, an exception of type Gecode::Set::VariableOutOfRangeCardinality is thrown.
- If minCard > maxCard, an exception of type Gecode::Set::VariableFailedDomain is thrown.
Definition at line 45 of file cpltset.icc.
| void Gecode::CpltSetVar::init | ( | Space * | home, | |
| const IntSet & | glbD, | |||
| int | lubMin, | |||
| int | lubMax, | |||
| unsigned int | cardMin = 0 , |
|||
| unsigned int | cardMax = Set::Limits::card | |||
| ) | [inline] |
Initialize variable with given bounds and cardinality.
The variable is created with greatest lower bound glbD, least upper bound , and cardinality minimum cardMin and maximum cardMax. The following exceptions might be thrown:
- If the bounds are no legal set bounds (between Set::Limits::min and Set::Limits::max), an exception of type Gecode::Set::VariableOutOfRangeDomain is thrown.
- If the cardinality is greater than Set::Limits::max_set_size, an exception of type Gecode::Set::VariableOutOfRangeCardinality is thrown.
- If minCard > maxCard, an exception of type Gecode::Set::VariableFailedDomain is thrown.
Definition at line 65 of file cpltset.icc.
| void Gecode::CpltSetVar::init | ( | Space * | home, | |
| int | glbMin, | |||
| int | glbMax, | |||
| const IntSet & | lubD, | |||
| unsigned int | cardMin = 0 , |
|||
| unsigned int | cardMax = Set::Limits::card | |||
| ) | [inline] |
Initialize variable with given bounds and cardinality.
The variable is created with greatest lower bound , least upper bound lubD, and cardinality minimum cardMin and maximum cardMax. The following exceptions might be thrown:
- If the bounds are no legal set bounds (between Set::Limits::min and Set::Limits::max), an exception of type Gecode::Set::VariableOutOfRangeDomain is thrown.
- If the cardinality is greater than Set::Limits::max_set_size, an exception of type Gecode::Set::VariableOutOfRangeCardinality is thrown.
- If minCard > maxCard, an exception of type Gecode::Set::VariableFailedDomain is thrown.
Definition at line 56 of file cpltset.icc.
| void Gecode::CpltSetVar::init | ( | Space * | home, | |
| const IntSet & | glbD, | |||
| const IntSet & | lubD, | |||
| unsigned int | cardMin = 0 , |
|||
| unsigned int | cardMax = Set::Limits::card | |||
| ) | [inline] |
Initialize variable with given bounds and cardinality.
The variable is created with greatest lower bound glbD, least upper bound lubD, and cardinality minimum cardMin and maximum cardMax. The following exceptions might be thrown:
- If the bounds are no legal set bounds (between Set::Limits::min and Set::Limits::max), an exception of type Gecode::Set::VariableOutOfRangeDomain is thrown.
- If the cardinality is greater than Set::Limits::max_set_size, an exception of type Gecode::Set::VariableOutOfRangeCardinality is thrown.
- If minCard > maxCard, an exception of type Gecode::Set::VariableFailedDomain is thrown.
Definition at line 74 of file cpltset.icc.
| unsigned int Gecode::CpltSetVar::glbSize | ( | void | ) | const [inline] |
| unsigned int Gecode::CpltSetVar::lubSize | ( | void | ) | const [inline] |
| unsigned int Gecode::CpltSetVar::unknownSize | ( | void | ) | const [inline] |
| unsigned int Gecode::CpltSetVar::cardMin | ( | void | ) | const [inline] |
| unsigned int Gecode::CpltSetVar::cardMax | ( | void | ) | const [inline] |
| int Gecode::CpltSetVar::lubMin | ( | void | ) | const [inline] |
| int Gecode::CpltSetVar::lubMax | ( | void | ) | const [inline] |
| int Gecode::CpltSetVar::glbMin | ( | void | ) | const [inline] |
| int Gecode::CpltSetVar::glbMax | ( | void | ) | const [inline] |
| bool Gecode::CpltSetVar::contains | ( | int | i | ) | const [inline] |
| bool Gecode::CpltSetVar::notContains | ( | int | i | ) | const [inline] |
| bool Gecode::CpltSetVar::assigned | ( | void | ) | const [inline] |
| void Gecode::CpltSetVar::update | ( | Space * | home, | |
| bool | share, | |||
| CpltSetVar & | x | |||
| ) | [inline] |
Friends And Related Function Documentation
| GECODE_CPLTSET_EXPORT std::ostream & operator<< | ( | std::ostream & | , | |
| const Gecode::CpltSetVar & | x | |||
| ) | [related] |
The documentation for this class was generated from the following files:
- gecode/cpltset.hh (Revision: 7494)
- gecode/cpltset/var/cpltset.cc (Revision: 6038)
- gecode/cpltset/var/cpltset.icc (Revision: 6274)


The Barber Shop started in Erie, PA, all the way back in 1975. Our business is built on the nostalgic principle that the relationship we have with our customers is the most important thing we have to offer, followed closely by our outstanding haircuts. It is our sincere honor to grow alongside you and your family. Our desire is to create a relationship with you that will last a lifetime. We have kept that tradition at the heart of our mission all these years, and it has become our driving force and our guiding principle.
When you walk into our Salon to start your day, we are dedicated to providing you with friendly service, a welcoming atmosphere, and above all else, excellent products made with the highest quality ingredients. If you are not satisfied, please let us know and we will do whatever we can to make things right!


Create nested values and any intermediaries using dot notation (
'a.b.c'
) paths.
Install with npm:
$ npm install --save set-value
var set = require('set-value');
set(object, prop, value);
object
{object}: The object to set value
onprop
{string}: The property to set. Dot-notation may be used.value
{any}: The value to set on object[prop]
Updates and returns the given object:
var obj = {};
set(obj, 'a.b.c', 'd');
console.log(obj);
//=> { a: { b: { c: 'd' } } }
Escaping with backslashes
Prevent set-value from splitting on a dot by prefixing it with backslashes:
console.log(set({}, 'a\\.b.c', 'd'));
//=> { 'a.b': { c: 'd' } }
console.log(set({}, 'a\\.b\\.c', 'd'));
//=> { 'a.b.c': 'd' }
Escaping with double-quotes or single-quotes
Wrap double or single quotes around the string, or part of the string, that should not be split by set-value:
console.log(set({}, '"a.b".c', 'd'));
//=> { 'a.b': { c: 'd' } }
console.log(set({}, "'a.b'.c", "d"));
//=> { 'a.b': { c: 'd' } }
console.log(set({}, '"this/is/a/.file.path"', 'd'));
//=> { 'this/is/a/file.path': 'd' }
set-value does not split inside brackets or braces:
console.log(set({}, '[a.b].c', 'd'));
//=> { '[a.b]': { c: 'd' } }
console.log(set({}, "(a.b).c", "d"));
//=> { '(a.b)': { c: 'd' } }
console.log(set({}, "<a.b>.c", "d"));
//=> { '<a.b>': { c: 'd' } }
console.log(set({}, "{a..b}.c", "d"));
//=> { '{a..b}': { c: 'd' } }
If there are any regressions please create a bug report. Thanks!
a.b.c
) to get a nested value from an object. | homepage'a.b.c'
) paths. | homepagePull requests and stars are always welcome. For bugs and feature requests, please create an issue.
| Commits | Contributor |
|---|---|
| 59 | jonschlinkert |
| 1 | vadimdemedes |
| 1 | wtgtybhertgeghgtwtg |
(This project's readme.md is generated by verb, please don't edit the readme directly. Any changes to the readme must be made in the .verb.md readme template.)
To generate the readme, run the following command:
$ npm install -g verbose/verb#dev verb-generate-readme && verb
Running and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
$ npm install && npm test
Jon Schlinkert
Copyright © 2017, Jon Schlinkert. Released under the MIT License.
This file was generated by verb-generate-readme, v0.6.0, on June 21, 2017.


last revised: 2020-07-17
In the Content Fabric, ingesting video for streaming involves two kinds of objects, Production Masters and ABR Mezzanines:
default
The ingest process consists of the following steps:
NOTE: Currently caption/subtitle files are added to ABR Mezzanines separately after creation. In the near future this will be changed so that they are part of the original Production Master instead.
If you do not have them already, install git and node.js / npm
Navigate to the directory where you would like to install elv-client-js
git clone https://github.com/eluv-io/elv-client-js
cd elv-client-js
npm install
npm audit fix
At this point, you may still see some warnings about package vulnerabilities. As we are only running local command line scripts (rather than using node.js to run a web app that accepts input from the outside world) these are safe to disregard.
Edit the file elv-client-js/TestConfiguration.json
To connect to our demo network, this file should be set to contain the following:
{
"config-url": "https://demov3.net955210.contentfabric.io/config"
}
To connect to our production network, the file should be set to contain the following:
{
"config-url": "https://main.net955305.contentfabric.io/config"
}
Configure the private key environment variable:
export PRIVATE_KEY=0x...
(your Content Fabric private key)If your media files are hosted on AWS S3, also set the following environment variables:
export AWS_REGION=
(your AWS region)export AWS_BUCKET=
(your AWS bucket name)export AWS_KEY=AK...
(your AWS S3 key)export AWS_SECRET=...
(your AWS S3 secret)If you need to update to the latest version of elv-client-js, you can do so with:
cd elv-client-js
git pull
npm install
The Production Master object contains links to your original source material. It is not directly playable, but is used to generate a playable Mezzanine object.
To create a Production Master, you will need the following:
Each tenant of the Content Fabric has a number Content Types created for them. These provide a way of customizing the structure of your fabric objects.
If you click on Content Types on the left side you will see a list of these types, among which should be one named "TENANT_NAME - Title Master".
If you click on this item, you will see a detail screen where you can select and copy the Name and Object ID for this Content Type. When you run commands to create Production Masters, you will need to supply either the name or the ID of this content type, e.g.:
--type "TENANT_NAME - Title Master"
or
--type iq__...
(your 'Title Master' content type ID - content type IDs start with "iq__")
NOTE: In the instructions below there are a number of operations done via browser. These can be done programmatically as well and we can provide code samples as needed.
Click on Content in the left sidebar to get to your list of libraries.
Each tenant also has a number of libraries created for them, including one to hold Production Masters - it should be labeled "TENANT_NAME - Title Masters". Click on this item to see a list of objects currently in the library (initially it may be empty).
On the next screen, click on the Library Info tab to find the Library ID. When you run commands to create Production Masters, you will need to supply this ID, e.g.:
--library ilib...
(your 'Title Masters' library ID - library IDs start with "ilib")
Here is a sample command line to generate a Production Master using a file on AWS S3. Once you have the required information, substitute it into the sample below (if you do not need to attach an asset ID, you can omit the --ip-title-id
line):
cd elv-client-js
node testScripts/CreateProductionMaster.js \
--library ilib3xDQU7yDgZZQsmMwUrHTwzAEbbdu \
--title "Big Buck Bunny (master)" \
--s3-reference \
--type "TENANT_NAME - Title Master" \
--ip-title-id "YOUR_INTERNAL_ASSET_ID" \
--files bbb_sunflower_1080p_60fps_stereo_abl.mp4
NOTE: Our convention in this case is to omit the "s3://" prefix and bucket name from the start of file path, i.e. use bbb_sunflower_1080p_60fps_stereo_abl.mp4
instead of s3://BUCKET_NAME/bbb_sunflower_1080p_60fps_stereo_abl.mp4
. If the file is in a subdirectory, start with the name of the subdirectory, without any leading slash character (/)
Here is a sample command line to generate a Production Master using a local file. Once you have the required information, substitute it into the sample below (if you do not need to attach an asset ID, you can omit the --ip-title-id
line):
cd elv-client-js
node testScripts/CreateProductionMaster.js \
--library ilib3xDQU7yDgZZQsmMwUrHTwzAEbbdu \
--title "Big Buck Bunny (master)" \
--type "TENANT_NAME - Title Master" \
--ip-title-id "YOUR_INTERNAL_ASSET_ID" \
--files PATH_TO_YOUR_DIRECTORY/bbb_sunflower_1080p_60fps_stereo_abl.mp4
When you run the CreateProductionMaster.js
script, the server examines the file(s) for audio and video streams, then makes a best guess about what should be included in the mezzanine.
You should see output like the following:
Creating Production Master
Production Master
{ done: true, uploadedFiles: 1, totalFiles: 1 }
Production master object created:
Object ID: iq__2QEH2nqrLkwZpkNoguw1RGW7hFK4
Version Hash: hq__9v2JY21ESnsvNdwWwgJrjiw7jHWv5nXik6quVn6FUgDxbgTgJT8toxBVb1ShZZH4mcFSFcJUJJ
If you included any non-media files in the --files list, you will also see warnings at the end of the output complaining Failed to create media.Source from file
. These can be ignored as long as you included at least one media file.
In your browser, if you click on Content in the left sidebar, then click on your Title Masters library, you should see your new Production Master object.
(If you are already on the page that lists objects in the library you may need to click the refresh icon to see the new object)
Clicking on the object will show you details about the object. For the next step (generating a mezzanine) you will need the Latest Version Hash for the object. This value (hq__9v2JY2… for this example) can be copied by clicking on the clipboard icon as shown below. It is also listed in the output from the CreateProductionMaster.js
script.
A Production Master contains one or more Variants. A Variant is one version of the original title (this allows you to create different content versions for particular countries or distribution channels). The CreateProductionMaster.js
script creates a single Variant named default
.
Clicking on the Show Metadata button and drilling down into production_master → variants → default → streams will reveal what files and stream indexes the server has chosen to include in this "default" Variant.
In order to let other users work with your object, you must grant permissions to an Access Group.
From the object details page, click the blue Groups button at top - you should see a screen with the Access Group field already chosen for you, set to "TENANT_NAME Content Admins".
Check all 3 boxes (See, Access, and Manage), then click Submit.
In order to grant permissions via the command line, you will need to know the following:
You can find the Address of your group by clicking on the blue Groups button at top when you are browsing the details of any object. You can choose a group from the Access Group dropdown, then double-click the Address field to select it and copy to your clipboard.
The command to add permissions is then:
node testScripts/AddGroupPermissions.js \
--objectId YOUR_OBJECT_ID \
--groupAddress YOUR_GROUP_ADDRESS \
--permissions see access manage
A Mezzanine object contains transcoded media optimized for adaptive bitrate (ABR) streaming. Depending on the ABR profile you choose, it is playable via HLS and/or DASH with DRM (you also have the option to offer playout in the clear).
To create a Mezzanine, you will need the following:
NOTE: In the instructions below there are a number of operations done via browser. These can be done programmatically as well and we can provide code samples as needed.
Click on Content Types on the left side and click on the one named "TENANT_NAME - Title".
You will see a detail screen where you can select and copy the Name and Object ID for this Content Type. When you run commands to create Mezzanines, you will need to supply either the name or the ID of this content type, e.g.:
--type "TENANT_NAME - Title"
or
--type iq__...
(your 'Title' content type ID - content type IDs start with "iq__")
Click on Content in the left sidebar to get to your list of libraries.
Click on the one labeled "TENANT_NAME - Titles", then click on the Library Info tab to find the Library ID. When you run commands to create Mezzanines, you will need to supply this ID, e.g.:
--library ilib...
(your 'Titles' library ID - library IDs start with "ilib")
An ABR Profile contains information on what formats, resolutions and bitrates to offer for streaming playout, as well as any DRM and/or watermarking information.
There are JSON files containing commonly used profiles in elv-client-js/testScripts/
abr_profile_4k_clear.json
abr_profile_4k_drm.json
abr_profile_clear.json
abr_profile_drm.json
The 4k files are specifically for offering 16:9 material at 3840x2160 resolution.
For most content we recommend using the abr_profile_drm.json
file, which contains resolution ladders for a variety of aspect ratios. (For material with 16:9 aspect ratio, this file's top ladder rung is 1920x1080 @ 9.5 mbps)
The *_clear
files are for publishing without DRM.
Once you have the required information, substitute it into the sample command below (if you do not need to attach an asset ID, you can omit the --ip-title-id
line):
node testScripts/CreateABRMezzanine.js --library ilib4JFY7hontNKJJmM4XnZaweTbH9tq \
--masterHash hq__9v2JY21ESnsvNdwWwgJrjiw7jHWv5nXik6quVn6FUgDxbgTgJT8toxBVb1ShZZH4mcFSFcJUJJ \
--title "Big Buck Bunny" \
--type "TENANT_NAME - Title" \
--ip-title-id "YOUR_INTERNAL_ASSET_ID" \
--abr-profile testScripts/abr_profile_drm.json
Note in particular that the --library
and --type
parameters will be different from your commands to create Production Masters.
Once the object is created, transcoding will begin on the server.
Your output from the previous command should look something like this:
Creating ABR Mezzanine...
Starting Mezzanine Job(s)
Library ID ilib4JFY7hontNKJJmM4XnZaweTbH9tq
Object ID iq__4N1gG59cE1YzAL3NfRs39rFVTq8q
Offering: default
Write Token: tqw_4SiNg6kktmRGmAjLXjeFzt8s8C2Lbo5Bo
Write Node: https://host-38-142-50-110.contentfabric.io/
The Object ID identifies your new Mezzanine, you will need this value for subsequent commands.
In your browser, if you click on Content in the left sidebar, then click on your Titles library, you should see your new Mezzanine object. (If you are already on the page that lists objects in the library you may need to click the refresh icon to see the new object)
If you go into the "TENANT_NAME - Title Mezzanines" library in your browser you should see the new mezzanine object.
(If you are already on the object list page you may need to click the refresh icon to see the new object)
Drilling down into it, you should see some information about transcoding progress (you will not be able to play it until transcoding has finished and you have finalized the object):
In most cases, the percentage value shown is an average of 2 values (audio percent done and video percent done). The audio generally processes much more quickly, so you will see the value climb quickly to just above 50%, then progress more slowly.
You can get detailed progress info with the following command:
node testScripts/MezzanineStatus.js --objectId YOUR_NEW_MEZ_OBJECT_ID
Your output should look something like this, listing 2 jobs (1 for audio, 1 for video):
{
"63fe3cbf-4660-44b2-8d93-415d97e4bd88": {
"duration":<PHONE_NUMBER>11,
"duration_ms": 485986,
"progress": {
"percentage": 68.9119170984456
},
"run_state": "running",
"start": "2020-03-26T18:49:28Z"
},
"f39c9de1-4c29-49cf-bcf9-f173bc114e73": {
"duration":<PHONE_NUMBER>27,
"duration_ms": 482414,
"progress": {
"percentage": 3.6269430051813467
},
"run_state": "running",
"start": "2020-03-26T18:49:28Z"
}
}
The "start" field is in UTC time.
Divide the "duration_ms" field by 1000 to get seconds elapsed.
Depending on the format, bitrate and complexity of the original source material, and the speed of transfer between your S3 bucket and the Content Fabric node, it can take anywhere from 1x to 8x the actual duration of the program to complete transcoding.
Once both jobs show a "run_state" of "finished", you are ready for the next step, finalization.
Finalizing the Mezzanine makes the transcoded media available for viewing and distributes it to other nodes in the Content Fabric.
The command to finalize is the same as for checking progress, but with an additional --finalize parameter:
node testScripts/MezzanineStatus.js --objectId YOUR_NEW_MEZ_OBJECT_ID --finalize
While the command itself should complete quickly, it can take 2-3 minutes for the finalized content to become visible in the browser. (Behind the scenes, the nodes in the fabric are distributing parts among themselves)
In the browser, click the refresh icon to update your view, then click on the Display tab to see the finalized content.
(Identical process as for the Production Master object)
From the object details page, click the blue Groups button at top - you should see a screen with the Access Group field already chosen for you, set to "TENANT_NAME Content Admins".
Check all 3 boxes (See, Access, and Manage), then click Submit.
A Mezzanine object contains one or more Offerings. Each Offering specifies the following information:
When the CreateABRMezzanine.js
script is run, it creates a single Offering named default
.
The OfferingCopy.js
script allows you to duplicate an existing Offering, after which you can modify the copy to change the playout options (see "Adding / removing playout options from an Offering" section below):
node testScripts/OfferingCopy.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey default \
--targetOfferingKey YOUR_NEW_OFFERING_NAME
(if you want to copy an Offering other than the one named default
then change the end of the --offeringKey
line)
In the Fabric Browser, when you are on the Display tab for your Mezzanine, click on the Advanced Controls button to access additional options. The Offering pulldown menu will allow you to choose other Offerings besides "default".
You can make changes to an Offering (either the default
, or one you have created via the OfferingCopy.js
script) to modify playout options.
The OfferingAddClear.js
script will add a DRM-free playout option to one Offering within your Mezzanine:
node testScripts/OfferingAddClear.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey THE_OFFERING_NAME
The OfferingRemoveClear.js
script will remove DRM-free playout options from one Offering within your Mezzanine:
node testScripts/OfferingRemoveClear.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey THE_OFFERING_NAME
The OfferingRemoveDRM.js
script will remove DRM-protected playout options from one Offering within your Mezzanine:
node testScripts/OfferingRemoveDRM.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey THE_OFFERING_NAME
The OfferingListRungs.js
script will display the resolution ladder for an existing Offering:
node testScripts/OfferingListRungs.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey THE_OFFERING_NAME
If --offeringKey
is omitted then default
will be assumed.
Sample output:
Listing resolution ladder rungs for all streams in offering 'default'
{
"audio": {
"representations": {
"audio@128000": {
"bit_rate": 128000,
"media_struct_stream_key": "audio",
"type": "RepAudio"
}
}
},
"video": {
"representations": {
"video_1452x1080@4900000": {
"bit_rate": 4900000,
"crf": 0,
"height": 1080,
"media_struct_stream_key": "video",
"type": "RepVideo",
"width": 1452
}
"video_726x540@1500000": {
"bit_rate": 1500000,
"crf": 0,
"height": 540,
"media_struct_stream_key": "video",
"type": "RepVideo",
"width": 726
},
"video_968x720@3375000": {
"bit_rate": 3375000,
"crf": 0,
"height": 720,
"media_struct_stream_key": "video",
"type": "RepVideo",
"width": 968
}
}
}
}
The OfferingAddVideoRung.js
script will allow you to add a new rung to an Offering's video resolution ladder:
node testScripts/OfferingAddVideoRung.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey THE_OFFERING_NAME \
--width THE_NEW_WIDTH \
--height THE_NEW_HEIGHT \
--bitrate THE_NEW_BITRATE
If you omit --offeringKey
then default
will be assumed.
Optionally, the --width
and/or --bitrate
options can be omitted, and the script will scale the existing top rung based on --height
.
Note that if you supply both --width
and --height
but the resulting aspect ratio would differ more than 5% from the existing top rung's aspect ratio the script will halt with an error. If you would like to add anyway, add --ignoreAspectRatio
to the command.
Note also that only lower quality rungs can be added to an existing Offering. The new rung's bitrate must be lower than the existing top rung, and height and width must be less than or equal to the existing top rung.
For example, if your top rung is 1920x1080 @ 9,500,000 bps:
OK:
1920x1080 @ 7,000,000 bps
1280x720 @ 7,000,000 bps
Not OK:
1920x1080 @ 12,000,000 bps (bitrate must be less than top rung)
3840x2160 @ 7,000,000 bps (height and width must be equal to or smaller than top rung)
1280x720 @ 9,500,000 bps (bitrate must be less than top rung)
Note that in special cases, your Offering's video stream may not be named video
- if this is the case, use --streamKey STREAM_NAME
to specify the actual name of the stream. (You can use the OfferingListRungs.js
script to see the names of your Offering's streams)
The OfferingRemoveVideoRung.js
script will allow you to remove an existing rung from an Offering's video resolution ladder:
node testScripts/OfferingRemoveVideoRung.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey THE_OFFERING_NAME \
--rungKey THE_RUNG_NAME
If you omit --offeringKey
then default
will be assumed.
To look up the value of --rungKey
, use the OfferingListRungs.js
script (see above). Video rungs are generally named "video_WIDTHxHEIGHT@BITRATE", e.g.: video_1280x720@4500000
, but this is not guaranteed - use the OfferingListRungs.js
script to show all the rung names.
You are not allowed to remove the top rung from the ladder, if you try the script will halt with an error.
Note that in special cases, your Offering's video stream may not be named video
- if this is the case, use --streamKey STREAM_NAME
to specify the actual name of the stream. (You can use the OfferingListRungs.js
script to see the names of your Offering's streams)
The following assumes that you created your Mezzanine using the abr_profile_drm.json
profile, which will result in a default
Offering that only offers DRM playback:
node testScripts/OfferingCopy.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey default \
--targetOfferingKey clear-playout
node testScripts/OfferingAddClear.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey clear-playout
node testScripts/OfferingRemoveDRM.js \
--libraryId YOUR_TITLE_LIBRARY_ID \
--objectId YOUR_MEZ_OBJECT_ID \
--offeringKey clear-playout
After running the above commands, you will have an additional clear-playout
Offering that has only DRM-free playout options.


RASC Robots
Robotics and Autonomous Systems Center
RASC members are an interdisciplinary mix of USC faculty, research staff, and students at all levels, as well as interdisciplinary affiliates from USC and elsewhere. To find out more about our members, please follow the links below:
Faculty
Professor
Department
Email
Ayanian, Nora
Computer Science
<EMAIL_ADDRESS>Bekey, George (emeritus)
Computer Science
<EMAIL_ADDRESS>Culbertson, Heather
Computer Science
<EMAIL_ADDRESS>Gupta, SK
Aerospace and Mechanical Engineering
<EMAIL_ADDRESS>Itti, Laurent
Computer Science
<EMAIL_ADDRESS>Lim, Joseph
Computer Science
<EMAIL_ADDRESS>Loeb, Gerald
Biomedical Engineering
<EMAIL_ADDRESS>Matarić, Maja
Computer Science
<EMAIL_ADDRESS>Nikolaidis, Stefanos
Computer Science
<EMAIL_ADDRESS>Perez-Arancibia, Nestor
Aerospace and Mechanical Engineering
<EMAIL_ADDRESS>Requicha, Aristides (emeritus)
Computer Science
<EMAIL_ADDRESS>Savla, Ketan
Civil and Environmental Engineering
<EMAIL_ADDRESS>Sha, Fei
Computer Science
<EMAIL_ADDRESS>Shen, Wei-Min
Computer Science and ISI
<EMAIL_ADDRESS>Sukhatme, Gaurav
Computer Science
<EMAIL_ADDRESS>Valero-Cuevas, Francisco
Biomedical Engineering
<EMAIL_ADDRESS>Affiliates


[More examples are referenced from the main RTOS task notifications page] This example demonstrates how to use xTaskNotifyFromISR() with the eSetBits action. See the xTaskNotify() API documentation page for examples showing how to use the eNoAction, eSetValueWithOverwrite and eSetValueWithoutOverwrite actions. /* The interrupt handler does not perform any processing itself. Instead it it unblocks a high priority task in which the events that generated the interrupt are processed. If the priority of the task is high enough then the interrupt will return directly to the task (so it will interrupt one task but return to a different task), so the processing will occur contiguously in time - just as if all the processing had been done in the interrupt handler itself. The status of the interrupting peripheral is sent to the task using an RTOS task notification. */ void vANInterruptHandler( void ) { BaseType_t xHigherPriorityTaskWoken; uint32_t ulStatusRegister; /* Read the interrupt status register which has a bit for each interrupt source (for example, maybe an Rx bit, a Tx bit, a buffer overrun bit, etc. */ ulStatusRegister = ulReadPeripheralInterruptStatus(); /* Clear the interrupts. */ vClearPeripheralInterruptStatus( ulStatusRegister ); /* xHigherPriorityTaskWoken must be initialised to pdFALSE. If calling xTaskNotifyFromISR() unblocks the handling task, and the priority of the handling task is higher than the priority of the currently running task, then xHigherPriorityTaskWoken will automatically get set to pdTRUE. */ xHigherPriorityTaskWoken = pdFALSE; /* Unblock the handling task so the task can perform any processing necessitated by the interrupt. xHandlingTask is the task's handle, which was obtained when the task was created. The handling task's notification value is bitwise ORed with the interrupt status - ensuring bits that are already set are not overwritten. */ xTaskNotifyFromISR( xHandlingTask, ulStatusRegister, eSetBits, &xHigherPriorityTaskWoken ); /* Force a context switch if xHigherPriorityTaskWoken is now set to pdTRUE. The macro used to do this is dependent on the port and may be called portEND_SWITCHING_ISR. */ portYIELD_FROM_ISR( xHigherPriorityTaskWoken ); } /* ----------------------------------------------------------- */ /* A task that blocks waiting to be notified that the peripheral needs servicing, processing all the events pending in the peripheral each time it is notified to do so. */ void vHandlingTask( void *pvParameters ) { uint32_t ulInterruptStatus; for( ;; ) { /* Block indefinitely (without a timeout, so no need to check the function's return value) to wait for a notification. NOTE! Real applications should not block indefinitely, but instead time out occasionally in order to handle error conditions that may prevent the interrupt from sending any more notifications. */ xTaskNotifyWait( 0x00, /* Don't clear any bits on entry. */ ULONG_MAX, /* Clear all bits on exit. */ &ulInterruptStatus, /* Receives the notification value. */ portMAX_DELAY ); /* Block indefinitely. */ /* Process any bits set in the received notification value. This assumes the peripheral sets bit 1 for an Rx interrupt, bit 2 for a Tx interrupt, and bit 3 for a buffer overrun interrupt. */ if( ( ulInterruptStatus & 0x01 ) != 0x00 ) { prvProcessRxInterrupt(); } if( ( ulInterruptStatus & 0x02 ) != 0x00 ) { prvProcessTxInterrupt(); } if( ( ulInterruptStatus & 0x04 ) != 0x00 ) { prvClearBufferOverrun(); } } }
[
Back to the top ] [ About FreeRTOS
] [ Sitemap
] [
Report an error on this page (with anti-spam) ]
Copyright (C) 2004-2010 Richard Barry. Copyright
(C) 2010-2016 Real Time Engineers Ltd.
Any and all data, files, source code, html content and documentation included in the FreeRTOSTM distribution or available on this site are the exclusive property of Real Time Engineers Ltd.. See the files license.txt (included in the distribution) and this copyright notice for more information. FreeRTOSTM and FreeRTOS.orgTM are trade marks of Real Time Engineers Ltd. |


Ford's Mach E Electric SUV Spied Looking...Interesting
by Joey Capparella- This is our best look yet at Ford's upcoming electric crossover, likely to be called Mach E.
- Its styling is said to draw inspiration from the Mustang, and that's in full display here.
- The Mach E will make its debut November 17 just before the L.A. auto show.
Ford wasn't kidding around when it said its new electric crossover would look like a Mustang. These spy photos of the new model, said to be called Mach E, clearly display several classic Mustang styling cues—although we're not sure how we feel about how they look applied to a vehicle like this.
There's a fair amount of Jaguar I-Pace in the Mach E's overall shape, as it's similarly long and low with smooth surfacing along the sides. But the slim headlights, familiarly shaped "grille" cutout, and three-bar taillights clearly identify it as a member of the Mustang family, at least in terms of looks.
Mechanically, it won't share anything at all with Ford's famed pony car, as it is slated to ride on Ford's new architecture engineered specifically for EVs. That will mean a floor-mounted battery pack said to provide 300 miles of range, and a likely setup of both front- and rear-mounted electric motors that will provide all-wheel-drive capability.
Ford will share lots more information about the Mach E when it formally debuts November 17. But in the meantime, you can sow your excitement (or discontent) by looking at these spy photos.
You Might Also Like


All routines in the Time unit are exported qualified (and thus must be prefaced with "Time.").
| Sec | Returns the number of seconds since 1/1/1970 00:00:00 GMT. | |
| Date | Returns the current date and time as a string. | |
| SecDate | Converts a number of seconds into a date / time string. | |
| DateSec | Converts a date / time string to a number of seconds. | |
| SecParts | Converts the number of seconds since 1/1/1970 00:00:00 GMT into a day of month, month, year, day of week, hour, minute and second integers. | |
| PartsSec | Converts a day of month, month, year, hour, minute and second integers into the number of seconds since 1/1/1970 00:00:00 GMT. | |
| SecStr | Converts the number of seconds since 1/1/1970 00:00:00 GMT into a user specified formatted string representing the date. | |
| Elapsed | Returns the number of milliseconds elapsed since the program started to run. | |
| ElapsedCPU | Returns the number of milliseconds of CPU time elapsed since the program started to run. | |
| Delay | Sleeps for a specified number of milliseconds. | |
| DelaySinceLast | Sleeps until a specified number of milliseconds since the last call to Time.DelaySinceLast. |