User Guide¶
About application¶
The app allows you to create collages from photos. You can add photos interactively: you can add a photo from any of the four sides of the rectangle, but it will take up half of the image, and the rest of the collage will be scaled automatically. The basic functions are creating a canvas of any size, adding photos, automatically zooming and cropping them, and saving the resulting collage. As additional functions, you can change the parameters of the image borders (size, padding, corner type), implement control of elements on the canvas: the ability to move the borders, change the cropping window of the photo (zoom and change the position).
Installation¶
To install the app clone repository https://github.com/1alexandra/collage and in collage root directory execute:
python3 -m pip install setuptools==46.0.0 wheel==0.34.2
python3 setup.py sdist bdist_wheel
pip3 install dist/collage-0.0.1-py3-none-any.whl
Localisation¶
The application is adapted for two languages: English and Russian. Localization is selected based on system parameters.
How to use¶
After launching the app, you see a window divided into two areas: the menu and the workspace.
Use the input fields in the menu to configure collage settings.
Make sure that you have entered numbers that match the input format:
the values in pixels must be natural numbers,
and the real values must be real numbers.
After completing the changes, click the Change settings
button.
You can also change the parameters while editing the collage.
Use one of the +
buttons on the right side of the screen to add the first
photo to the collage. The app supports adding photos in JPEG, PNG, GIF, TIFF,
and BMP formats.
After adding the first photo to the collage, you can update layout by 3 types of operations:
- Adding a photo from one side of the collage border.
In this case, the new cell appears on this side of the collage and takes up half of the collage regardless of size. All previously existing cells are compressed to make room for a new cell.
- The division of the photo cell.
After right-clicking on a photo, a drop-down menu appears with the options: add photo on the left, add photo on the right, add photo on the top, add photo on the bottom. If you click on one of them, the selected photo cell is divided into two cells, one of which is placed a new photo, according to your side choice, and the second remains the old photo.
- Movement of the border between photos.
Hold down the left mouse button on boarder part and drag the border between cells moving the mouse.
Initially, middle part of the photo appears in the cell. You can change the position:
select photo cell using mouse click and use keyboard arrows to move photo inside
the cell or simply use mouse.
Also, you can change photo scale using mouse wheel or [
and ]
keyboard buttons.
You can dump and load collage project using menu buttons. Use Save as...
menu button to save collage image file to file system.
After saving the file, you can open it in any graphics editor and do whatever you want with it.


5$
Starter Plan
- Introduction of your startup
- Profile allocation for 2 team mates
- Request for 2 skills
- Rate mentors and be rated by mentors
- -
- -
- -
- -
20$
Seed Plan
- Introduction of your startup
- Profile allocation for 4 team mates
- Request for 4 skills
- Upload 2 medias (1 video + 1 photo)
- Rate mentors and be rated by mentors
- -
- -
- -
50$
Growing Plan
- Introduction of your startup
- Profile allocation for 6 team mates
- Request for 6 skills
- Upload 6 medias (2 video + 4 photo)
- Startup statistics (visits, followers, clicked links)
- Don't wait for mentors to contact you! Contact them directly!


NAVBAR
Input Form
Age :
Gender :
Male
Female
Chest Pain Type :
Typical Angina
Atypical Angina
Non-anginal Pain
Asymptotic
Resting Blood Pressure :
Serum Cholestrol :
Fasting Blood Sugar > 120 mg/dl :
True
False
Resting ECG :
Normal
Having ST-T wave abnormality
Left Ventricular Hyperthrophy
Max heart rate achieved :
Exercise induced angina :
Yes
No
ST depression induced by exercise relative to rest :
Peak exercise ST segment :
Upsloping
Flat
Downsloping
Number of major vessels (0-3) colored by flourosopy
Thal :
Normal
Fixed Defect
Reversable Defect
Submit


java.sql.Statement.execute()
or any
of its variants which take a dynamically-constructed string as the query to execute.
Constructed SQL statements are a common source of security breaches. By default, this inspection ignores compile-time constants.
Example:
ResultSet execute(Statement statement, String name) throws SQLException {
return statement.executeQuery("select * from " + name); // reports warning
}
Use the inspection options to consider any static
final
fields as constant.
Be careful, because strings like the following will be ignored when the option is enabled:
private static final String SQL = "SELECT * FROM user WHERE name='" + getUserInput() + "'";


public class Peer
extends java.lang.Object
| Modifier and Type | Method and Description |
|---|---|
java.lang.String |
getName()
gets this peer's name.
|
static Peer |
getPeer(LacewingClient lc,
int id)
Gets a peer from the client's pool
|
int |
getPeerID()
Gets this peer's id
|
boolean |
isMaster()
Gets if this peer is the channel master
|
static Peer |
readPeerFromJoinChannel(LacewingClient lc,
java.io.InputStream is)
Reads a peer from an InputStream
|
void |
sendBinaryMessage(LacewingClient lc,
int subchannel,
Channel channel,
byte[] data)
Attempts to send a binary message to this peer
|
void |
setIsMaster(boolean isMaster)
Sets if the peer is the channel master; can cause errors if set manually
|
void |
setName(java.lang.String newName)
Sets this peer's name; can cause errors if set manually
|
java.lang.String |
toString() |
public int getPeerID()
public java.lang.String getName()
public void setName(java.lang.String newName)
newName
- the name to set topublic boolean isMaster()
public void setIsMaster(boolean isMaster)
isMaster
- to set isMasterpublic java.lang.String toString()
toString
in class java.lang.Object
public void sendBinaryMessage(LacewingClient lc, int subchannel, Channel channel, byte[] data) throws LacewingException
lc
- the client to send onsubchannel
- the subchannel to send onchannel
- the channel to send on; the peer must be a member of this channeldata
- the data to sendLacewingException
- thrown if sending fails or is impossiblepublic static Peer getPeer(LacewingClient lc, int id)
lc
- the client to retrieve fromid
- the peer's idpublic static Peer readPeerFromJoinChannel(LacewingClient lc, java.io.InputStream is) throws java.io.IOException
lc
- the client to read intois
- the stream to read fromjava.io.IOException
- thrown on a stream error


Download button manager
flask_download_btn.DownloadBtnManager
class flask_download_btn.DownloadBtnManager(app=None, **kwargs) [source]
The manager has two responsibilities:
- Register download button classes.
- Register routes used by the download button.
| Parameters: | app : flask.app.Flask or None, default=None
Flask application with which download buttons are associated. **kwargs :You can set the download button manager's attributes by passing them as keyword arguments. |
|---|---|
| Attributes: | db : flask_sqlalchemy.SQLAlchemy or None, default=None
SQLAlchemy database associated with the Flask app. btn_template : str, default='download_btn/button.html'Path to the default button template. progress_template : str, default='download_btn/progress.html'Path to the default progress bar template. |
Notes
If app
and db
are not set on initialization, they must be set using
the init_app
method before the app is run.
Examples
from flask import Flask
from flask_download_btn import DownloadBtnManager
from flask_sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)
download_btn_manager = DownloadBtnManager(app, db)
Methods
register(cls, btn_cls) [source]
Decorator for updating the download button class registry.
| Parameters: | btn_cls : class
Class of the registered button. |
|---|---|
| Returns: | btn_cls :
|
Examples
from flask_download_btn import DownloadBtnMixin
@DownloadBtnManager.register
class DownloadBtn(DownloadBtnMixin, db.Model):
...
init_app(self, app, **kwargs) [source]
Initialize the download button manager with the application.
| Parameters: | app : flask.app.Flask
Application with which the download button manager is associated. **kwargs :You can set the download button manager's attributes by passing them as keyword arguments. |
|---|


Coming soon!
We will be adding this brand new features to our web soon:
Comment section
Forum Posts
Account creation
Back to Homepage


Esa's Google Maps
API examples
Shape the polyline
Conclusion
- CPU goes hot but:
- SVG makes real time polyline editing possible
- SVG is much more powerful than VML
- Polyline animations are fully applicable
- I did not put an SVG on/off switch on page. It would be wasting bandwidth.
Recommended


WITNESS LIST
Appropriations - S/C on Article III Committee
February 13, 2019 - 7:30 AM
LBB Overview Testimony for General Academics and A&M Agencies
On:
Brock, Colin (Legislative Budget Board)
Hernandez, Demetrio (LBB)
Schmidt, Emily (Legislative Budget Board)
Texas A&M University System
On:
Arenaz, Pablo (Texas A&M International University)
Bradford, Corey (Pvamu)
Cutrer, Emily (Texas A&M Texarkana)
Dottavio, Dominic (Tarleton State University)
Fossum, Michael (Texas A&M Univ at Galveston)
Hussey, Mark (Texas A&M Kingsville)
Matson, Cynthia (Texas A&M San Antonio)
Nigliazzo, Marc (Texas A&M University Central Texas)
Quintanilla, Kelly (TAMUCC)
Rudin, Mark (Texas A&M Commerce)
Sharp, John (Texas A&M University System)
Simmons, Ruth (Prairie View A and M)
Wendler, Walter (Wtamu)
Young, Michael (Texas A&M University)
Registering, but not testifying:
On:
Castillo, Juan (Texas A&M International University)
Hamilton, Billy (Texas A&M University System)
Hinton, Jeff (Texas A&M texarkana)
Lunt, David (Texas A&M AgriLife Research)
Rikel, Randy (WTAMU)
Texas A&M University System Agencies
On:
Akey, Bruce (Texas A&M Veterinary Medical Diagnostic Laboratory)
Banks (Dr.), Kathy (Texas A&M Engineering Experiment Station)
Boggus, Tom (Texas A&M Forest Service)
Coatney, David (TEEX)
Rosson, Parr (Texas A&M AgriLife Extension)
Stover, Patrick (Texas A&M System)
Winfree, Greg (Texas A&M Transportation Institute)
Winfree, Gregory (Texas A&M Transportation Institute)
1
WITNESS LIST
Registering, but not testifying:
On:
Alexander, Donna (Texas A&M Agrilife Extension Service)
Ballabna, Susan (Texas a&m agrilfe)
Crawford, John (Texas A&M Engineering Experiment Station)
Cummings, Debra (Texas A&m Agrilife Research)
DeWitt, Robby (Texas A&M Forest Service)
Dunn, Joe (Texas A&M Transportation Institute)
Dunn, Joseph (Texas A&M Transportation Institute)
Lunt, David (Texas A&M AgriLife Research)
Reed, Cyrus (Lone star chapter sierra club)
Todd, Charley (TEEX)
2


pragma solidity ^0.4.24;
import "zos-lib/contracts/Initializable.sol";
import "../token/ERC20/IERC20.sol";
import "../token/ERC20/ERC20Mintable.sol";
import "../token/ERC20/SafeERC20.sol";
import "../math/Math.sol";
/**
* @title ERC20Migrator
* @dev This contract can be used to migrate an ERC20 token from one
* contract to another, where each token holder has to opt-in to the migration.
* To opt-in, users must approve for this contract the number of tokens they
* want to migrate. Once the allowance is set up, anyone can trigger the
* migration to the new token contract. In this way, token holders "turn in"
* their old balance and will be minted an equal amount in the new token.
* The new token contract must be mintable. For the precise interface refer to
* OpenZeppelin's ERC20Mintable, but the only functions that are needed are
* `isMinter(address)` and `mint(address, amount)`. The migrator will check
* that it is a minter for the token.
* The balance from the legacy token will be transfered to the migrator, as it
* is migrated, and remain there forever.
* Although this contract can be used in many different scenarios, the main
* motivation was to provide a way to migrate ERC20 tokens into an upgradeable
* version of it using ZeppelinOS. To read more about how this can be done
* using this implementation, please follow the official documentation site of
* ZeppelinOS: https://docs.zeppelinos.org/docs/erc20_onboarding.html
* Example of usage:
* ```
* const migrator = await ERC20Migrator.new(legacyToken.address);
* await newToken.addMinter(migrator.address);
* await migrator.beginMigration(newToken.address);
* ```
*/
contract ERC20Migrator is Initializable {
using SafeERC20 for IERC20;
/// Address of the old token contract
IERC20 private _legacyToken;
/// Address of the new token contract
ERC20Mintable private _newToken;
/**
* @param legacyToken address of the old token contract
*/
function initialize(IERC20 legacyToken) public initializer {
require(legacyToken != address(0));
_legacyToken = legacyToken;
}
/**
* @dev Returns the legacy token that is being migrated.
*/
function legacyToken() public view returns (IERC20) {
return _legacyToken;
}
/**
* @dev Returns the new token to which we are migrating.
*/
function newToken() public view returns (IERC20) {
return _newToken;
}
/**
* @dev Begins the migration by setting which is the new token that will be
* minted. This contract must be a minter for the new token.
* @param newToken the token that will be minted
*/
function beginMigration(ERC20Mintable newToken) public {
require(_newToken == address(0));
require(newToken != address(0));
require(newToken.isMinter(this));
_newToken = newToken;
}
/**
* @dev Transfers part of an account's balance in the old token to this
* contract, and mints the same amount of new tokens for that account.
* @param account whose tokens will be migrated
* @param amount amount of tokens to be migrated
*/
function migrate(address account, uint256 amount) public {
_legacyToken.safeTransferFrom(account, this, amount);
_newToken.mint(account, amount);
}
/**
* @dev Transfers all of an account's allowed balance in the old token to
* this contract, and mints the same amount of new tokens for that account.
* @param account whose tokens will be migrated
*/
function migrateAll(address account) public {
uint256 balance = _legacyToken.balanceOf(account);
uint256 allowance = _legacyToken.allowance(account, this);
uint256 amount = Math.min(balance, allowance);
migrate(account, amount);
}
uint256[50] private ______gap;
}
|


---
title: SeaHUG - Category theory for programmers
layout: default
github_comments_issueid: 1
---
Instructor:
Bartosz Milewski
Category theory for programmers
A 10-week in-person course
This class will follow and expand upon Bartosz Milewski's blog. There will be lots of diagrams and programming on the whiteboard!
In Bartosz's own words:
I got the crazy idea, around 2014, to write a book about category theory for programmers. Mind you, not computer scientists but programmers—engineers rather than scientists. The idea evolved into a blog, and now into a course. I can't deny that there is a huge gap between science and engineering, because I have worked on both sides of the divide. But I've always felt a very strong compulsion to explain things. I have tremendous admiration for Richard Feynman who was the master of simple explanations. I know I'm no Feynman, but I will try my best.
To follow the course you don't need to know a lot of computer science or mathematics but you will need to be an experienced programmer. You should know what generic programming and polymorphism are.


Gain access to our full library of tutorials along with expert code reviews. Perfect for any developers who are serious about honing their skills.
$29 per month
full access for less than $1 a day


Hi, my name is
Dominik
and I create web pages. I study and live in Rzeszów, Poland. My hobbies are bridge (card game) and learning foreign languages. I also enjoy playing video games so if you want to play, leave something behide in the contact section 🙂


#include <NoiseGradientRenderer.h>
| void noisepp::utils::GradientRenderer::addGradient |
( |
Real |
value, |
|
|
const ColourValue & |
color |
|
) |
| |
Adds a gradient point.
- Parameters
-
| value | Position of the gradient point. |
| color | Color value of the gradient point. |
| void noisepp::utils::GradientRenderer::renderImage |
( |
Image & |
image, |
|
|
const Real * |
data, |
|
|
JobQueue * |
jobQueue = 0 |
|
) |
| |
Renders the data to an image.
- Parameters
-
| image | The image to render to. |
| data | The source data. |
| jobQueue | A pointer to a JobQueue. The JobQueue will be deleted after usage. Passing NULL will use an system optimal queue. |
The documentation for this class was generated from the following files:


Cover Template for Bootstrap
Home
Skillsets
Resume
Contact Me
About Me
Software Engineer
Resume
Contact Me


Please Enter Sequence Here
Requested Format : n1,n2,n3,n4
Constraints
Max len of any number is 10
Max len of Sequence is 400
All numbers should be seperated by comma( , )


{% extends 'base.html' %} {% load static from static %} {% block page_title %}Subscribe{% endblock %} {% block content %} JOIN PREMIUM SEND UNLIMITED MESSAGES SEE WHO'S VIEWED YOUR PROFILE ACCESS NEW FEATURES FIRST 1 MONTH £24.99 per month Billed as £24.99 every month SELECT 3 MONTHS MOST POPULAR £14.99 per month Billed as £44.99 every 3 months SELECT 6 MONTHS BEST VALUE £12.49 per month Billed as £74.99 every 6 months SELECT
SEND UNLIMITED MESSAGES
SEE WHO'S VIEWED YOUR PROFILE
ACCESS NEW FEATURES FIRST
Billed as £24.99 every month
Billed as £44.99 every 3 months
Billed as £74.99 every 6 months
{{ field.label }} {{ field }}
SELECTED PLAN: 3 MONTHS
TOTAL: £44.99
By clicking SUBMIT you are agreeing to our T&Cs and accepting our privacy policy. Subscriptions start on payment dates and are billed in 1 month, 3 month and 6 month increments. A month is regarded as a 30 day cycle. You are able to cancel your subscription at anytime and will not be charged for the subsequent renewal - provided the cancellation occurs before the payment date and time.


Fire breaks out in e-bike showroom in Vizag
by Staff ReporterA fire broke out at an e-bike showroom in Dondaparthy area on Friday night.
A short-circuit is suspected to have caused the blaze. Fire officials who rushed to the spot after receiving a distress call and doused the fire. They said that several bikes were gutted in the mishap. Authorities are yet to ascertain the extent of losses and the reason behind the mishap.


Freestyle snowboarding is any riding that includes performing tricks. In freestyle, the rider utilizes natural and man-made features such as rails, jumps, boxes, and innumerable others to perform tricks. It is a popular all-inclusive concept that distinguishes the creative aspects of snowboarding, in contrast to a style like alpine snowboarding.
Ice Skating
There are 2 types of ice skating: speed skating and figure skating. I am a figure skater, figure skating involves jumps and spins with transitions to a piece of music. There are 6 different types of jumps which can be performed with a single, double or triple rotations in the air and spins have many variations. It is scored on technical ability and performance.
A bit of history :-)
Snowboard tricks are aerials or maneuvers performed on snowboards for fun, or in competitions. Most often, these maneuvers are performed on obstacles such as jumps, halfpipes, quarterpipes, hips, handrails, funboxes, or ledges, or on the surface of the snow. Many have their origins in precursory board sports such as skateboarding and surfing.
The history of figure skating stretches back to prehistoric times. Primitive ice skates appear in the archaeological record from about 3000 BC. At the 1908 Summer Olympics in London, England, figure skating became the first winter sport to be included in the Olympics.


Fork / Join
In some cases you want to do multiple things in parallel to an incoming event/data, and then gather
back the results and do something with it. For example, in your login flow, you need to check the database
record on the login user, e.g. to see if they exist or their password matches, and also you would need to generate
a token for them that they could use, i.e. a
JWT token. For generating the token, you do not need
the data from database, so you can do these two actions in parallel, leading to a flow like this:
import { source, map, control } from '@connectv/core';
let loginReq = source(); //--> emulates incoming requests
let generateToken = map(user => `token for ${user}`); //--> generate a token for each user
let authenticate = map((user, done) => { //--> check if user is authenticated
/*!*/ if (user == 'john') //--> if the user is john ...
/*!*/ setTimeout(() => done(`auth for ${user}`), 100); //... it will take a bit to process it ...
/*!*/ else done(`auth for ${user}`); //... but not for others
});
loginReq
.to(generateToken, authenticate) //--> so check auth and generate token in parallel
.to(control()) //--> gather the results
.subscribe(console.log); //--> see what happened
loginReq.send('john'); //--> first john sends a login request
loginReq.send('jack'); //--> then jack does
If you run this code, you'll see that the output will look like this:
> ["token for john", "auth for jack"]
> ["token for jack", "auth for john"]
What happens is:
- generateToken first emits "token for john" and then "token for jack"
- authenticate first emits "auth for jack" and then "auth for john", as it
takes a bit longer for processing "john"
- control() just pairs the first emission of each pin and then the second emission of each pin,
which results in the wrong pairing.
fork() allows you to
stamp incoming emissions, so you can pair them later based on this stamp
using
join():
/*!*/import { source, map, fork, join, group } from '@connectv/core';
let loginReq = source(); //--> emulates incoming requests
let generateToken = map(user => `token for ${user}`); //--> generate a token for each user
let authenticate = map((user, done) => { //--> check if user is authenticated
if (user == 'john') //--> if the user is john ...
setTimeout(() => done(`auth for ${user}`), 100); //... it will take a bit to process it ...
else done(`auth for ${user}`); //... but not for others
});
loginReq
/*!*/.to(fork()) //--> stamp the request
.to(generateToken, authenticate) //--> so check auth and generate token in parallel
/*!*/.serialTo(join('token', 'auth')) //--> join the results in an object
//... with 'token' and 'auth' keys respectively
.subscribe(console.log); //--> log it
loginReq.send('john'); //--> first john sends a login request
loginReq.send('jack'); //--> then jack does
Now the result becomes:
> { token: "token for jack", auth: "auth for jack"}
> { token: "token for john", auth: "auth for john" }
Note that while
fork() is a
pin,
join()
is an
agent. Unlike
control()
or
pack(), it will generate an object with given fields,
and will have one input pin for each of those fields, named respectively. So if you wanted to connect
to the inputs and outputs of the
join() explicitly, it would look like this:
let j = join('token', 'auth');
group(generateToken, authenticate).serialTo(j.in('token'), j.in('auth'));
j.output.subscribe(console.log); //--> this is short-hand for `j.out('output')`
Chain forks
The stamp that
fork() puts on emissions is actually a
stack, so you can have multiple
forks and joins simultaenously. Each
fork() will push a new stamp onto this stack, and
each
join() will match emissions with equal values through-out the whole stack (not just the last stamp).
When
join() emits, it will also pop the last stamp.
If you want to join emissions without poping the stamp, for example for joining later on to emissions of the same fork,
then simply use
peekJoin() instead of
join().
Further reading


Bangalore FoodMap
Upload Data
×
Upload Scrape Data
Choose the JSON file to upload:
Please choose restaurant_data.json file


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| src | 100% | 6/6 | 100% | 3/3 | 100% | 2/2 | 100% | 6/6 | |
| src/action-sheet | 100% | 20/20 | 100% | 10/10 | 100% | 9/9 | 100% | 20/20 | |
| src/badge | 100% | 10/10 | 100% | 12/12 | 100% | 3/3 | 100% | 10/10 | |
| src/button | 60% | 12/20 | 25% | 2/8 | 33.33% | 3/9 | 60% | 12/20 | |
| src/checkbox | 8.33% | 2/24 | 0% | 0/12 | 0% | 0/6 | 8.33% | 2/24 | |
| src/checkbox-group | 40% | 2/5 | 100% | 0/0 | 0% | 0/3 | 40% | 2/5 | |
| src/col | 25% | 2/8 | 0% | 0/5 | 0% | 0/3 | 25% | 2/8 | |
| src/collapse | 25% | 2/8 | 0% | 0/4 | 0% | 0/3 | 25% | 2/8 | |
| src/collapse-item | 12.24% | 6/49 | 0% | 0/33 | 0% | 0/15 | 12.5% | 6/48 | |
| src/constant | 75% | 12/16 | 100% | 0/0 | 100% | 0/0 | 75% | 12/16 | |
| src/datetime-picker | 9.49% | 13/137 | 0% | 0/40 | 0% | 0/29 | 9.56% | 13/136 | |
| src/dialog | 28.57% | 16/56 | 0% | 0/25 | 7.69% | 2/26 | 29.09% | 16/55 | |
| src/directive | 0% | 0/34 | 0% | 0/26 | 0% | 0/4 | 0% | 0/31 | |
| src/divider | 66.67% | 2/3 | 100% | 0/0 | 0% | 0/1 | 66.67% | 2/3 | |
| src/dropdown-item | 13.95% | 6/43 | 0% | 0/16 | 0% | 0/15 | 13.95% | 6/43 | |
| src/dropdown-menu | 21.74% | 5/23 | 0% | 0/8 | 0% | 0/10 | 21.74% | 5/23 | |
| src/field | 8% | 6/75 | 0% | 0/46 | 0% | 0/29 | 8.22% | 6/73 | |
| src/grid | 42.86% | 3/7 | 0% | 0/4 | 0% | 0/2 | 42.86% | 3/7 | |
| src/grid-item | 15.38% | 4/26 | 0% | 0/12 | 0% | 0/7 | 15.38% | 4/26 | |
| src/icon | 22.58% | 14/62 | 17.39% | 8/46 | 17.39% | 4/23 | 21.31% | 13/61 | |
| src/image | 15% | 6/40 | 0% | 0/16 | 0% | 0/15 | 15% | 6/40 | |
| src/image-preview | 11.4% | 13/114 | 0% | 0/57 | 3.85% | 1/26 | 11.4% | 13/114 | |
| src/lazyload | 100% | 0/0 | 100% | 0/0 | 100% | 0/0 | 100% | 0/0 | |
| src/list | 60% | 3/5 | 100% | 0/0 | 50% | 2/4 | 60% | 3/5 | |
| src/list-item | 83.33% | 15/18 | 100% | 0/0 | 77.78% | 7/9 | 83.33% | 15/18 | |
| src/loading | 81.82% | 9/11 | 100% | 0/0 | 71.43% | 5/7 | 81.82% | 9/11 | |
| src/locale | 62.5% | 5/8 | 0% | 0/1 | 100% | 0/0 | 62.5% | 5/8 | |
| src/mixins | 13.73% | 7/51 | 6.98% | 3/43 | 66.67% | 4/6 | 10.42% | 5/48 | |
| src/mixins/popup | 69.14% | 56/81 | 50.85% | 30/59 | 85.71% | 6/7 | 69.62% | 55/79 | |
| src/nav-bar | 22.22% | 2/9 | 100% | 0/0 | 0% | 0/7 | 22.22% | 2/9 | |
| src/notice-bar | 5.88% | 2/34 | 0% | 0/20 | 0% | 0/15 | 6.06% | 2/33 | |
| src/notify | 37.14% | 13/35 | 0% | 0/17 | 22.22% | 2/9 | 37.14% | 13/35 | |
| src/overlay | 75% | 6/8 | 50% | 1/2 | 66.67% | 2/3 | 75% | 6/8 | |
| src/picker | 10.76% | 17/158 | 0% | 0/70 | 0% | 0/68 | 10.76% | 17/158 | |
| src/popover | 19.61% | 20/102 | 0% | 0/44 | 0% | 0/17 | 19.61% | 20/102 | |
| src/popover-item | 33.33% | 5/15 | 0% | 0/6 | 0% | 0/7 | 33.33% | 5/15 | |
| src/popup | 93.33% | 14/15 | 75% | 3/4 | 100% | 5/5 | 93.33% | 14/15 | |
| src/pull-refresh | 11.11% | 6/54 | 0% | 0/42 | 0% | 0/19 | 11.11% | 6/54 | |
| src/radio | 33.33% | 2/6 | 0% | 0/4 | 0% | 0/4 | 33.33% | 2/6 | |
| src/radio-group | 50% | 2/4 | 100% | 0/0 | 0% | 0/2 | 50% | 2/4 | |
| src/rate | 5.66% | 3/53 | 0% | 0/41 | 0% | 0/20 | 5.77% | 3/52 | |
| src/row | 28.57% | 2/7 | 0% | 0/4 | 0% | 0/3 | 28.57% | 2/7 | |
| src/search | 21.43% | 3/14 | 0% | 0/4 | 0% | 0/7 | 21.43% | 3/14 | |
| src/sidebar | 66.67% | 2/3 | 100% | 0/0 | 0% | 0/1 | 66.67% | 2/3 | |
| src/sidebar-item | 30.77% | 4/13 | 0% | 0/2 | 0% | 0/4 | 30.77% | 4/13 | |
| src/slider | 5.66% | 3/53 | 0% | 0/30 | 0% | 0/14 | 5.66% | 3/53 | |
| src/stepper | 5.68% | 5/88 | 0% | 0/38 | 0% | 0/27 | 5.68% | 5/88 | |
| src/sticky | 7.32% | 3/41 | 0% | 0/22 | 0% | 0/7 | 7.32% | 3/41 | |
| src/swipe | 5.08% | 6/118 | 0% | 0/82 | 0% | 0/36 | 5.08% | 6/118 | |
| src/swipe-action | 33.33% | 3/9 | 0% | 0/4 | 0% | 0/6 | 33.33% | 3/9 | |
| src/swipe-item | 14.29% | 1/7 | 0% | 0/4 | 0% | 0/5 | 14.29% | 1/7 | |
| src/switch | 25% | 5/20 | 0% | 0/10 | 0% | 0/8 | 25% | 5/20 | |
| src/tab | 16.67% | 2/12 | 0% | 0/8 | 0% | 0/9 | 16.67% | 2/12 | |
| src/tabbar | 22.22% | 2/9 | 0% | 0/4 | 0% | 0/4 | 22.22% | 2/9 | |
| src/tabbar-item | 25% | 5/20 | 0% | 0/16 | 0% | 0/8 | 25% | 5/20 | |
| src/tabs | 10.85% | 14/129 | 0% | 0/79 | 0% | 0/39 | 10.94% | 14/128 | |
| src/tag | 11.11% | 2/18 | 0% | 0/8 | 0% | 0/5 | 11.11% | 2/18 | |
| src/toast | 19.79% | 19/96 | 0% | 0/48 | 9.38% | 3/32 | 19.35% | 18/93 | |
| src/utils | 26.09% | 24/92 | 23.21% | 13/56 | 29.17% | 7/24 | 26.97% | 24/89 | |
| src/utils/comp/gesture | 5.02% | 11/219 | 0% | 0/125 | 0% | 0/13 | 5.05% | 11/218 | |
| src/utils/comp/swipeout | 3.19% | 3/94 | 0% | 0/79 | 0% | 0/27 | 3.19% | 3/94 | |
| src/utils/comp/tag | 100% | 2/2 | 100% | 0/0 | 100% | 0/0 | 100% | 2/2 | |
| src/utils/comp/touch-feedback | 48.65% | 18/37 | 50% | 9/18 | 100% | 1/1 | 47.22% | 17/36 | |
| src/utils/create | 52% | 13/25 | 26.67% | 4/15 | 40% | 4/10 | 54.17% | 13/24 | |
| src/utils/dom | 10.71% | 3/28 | 0% | 0/28 | 0% | 0/13 | 10.71% | 3/28 | |
| src/utils/format | 42.86% | 3/7 | 0% | 0/1 | 66.67% | 2/3 | 33.33% | 2/6 | |
| src/utils/validate | 0% | 0/5 | 0% | 0/4 | 0% | 0/3 | 0% | 0/5 | |
| src/white-space | 50% | 1/2 | 100% | 0/0 | 0% | 0/1 | 50% | 1/2 | |
| src/wing-blank | 50% | 1/2 | 100% | 0/0 | 0% | 0/1 | 50% | 1/2 |


Here is a list of all namespace members with links to the namespace documentation for each member:
- c -
- c : Test::Int::Arithmetic , Test::Int::Bool , Test::Int::Count , Test::Int::MiniModelBoolean , Test::Int::MiniModelCount , Test::Int::Element , Test::Int::MiniModelLin , Test::Int::MiniModel , Test::Int::Circuit , Test::Int::GCC , Test::Int::Rel , Test::Search , Test::Int::Linear , Test::Set::RelOpConst , Test::Set::RelOp
- c1 : Gecode::Int::Branch
- c10 : Gecode::Int::Branch
- c11 : Gecode::Int::Branch
- c12 : Gecode::Int::Branch
- c13 : Gecode::Int::Branch
- c1f1 : Test::Int::Scheduling
- c1f2 : Test::Int::Scheduling
- c1f3 : Test::Int::Scheduling
- c1t1 : Test::Int::Scheduling
- c1t2 : Test::Int::Scheduling
- c1t3 : Test::Int::Scheduling
- c2 : Gecode::Int::Branch
- c2f1 : Test::Int::Scheduling
- c2f2 : Test::Int::Scheduling
- c2f3 : Test::Int::Scheduling
- c2t1 : Test::Int::Scheduling
- c2t2 : Test::Int::Scheduling
- c2t3 : Test::Int::Scheduling
- c3 : Gecode::Int::Branch
- c3f1 : Test::Int::Scheduling
- c3f2 : Test::Int::Scheduling
- c3f3 : Test::Int::Scheduling
- c3f_1 : Test::Int::Scheduling
- c3f_2 : Test::Int::Scheduling
- c3f_3 : Test::Int::Scheduling
- c3t1 : Test::Int::Scheduling
- c3t2 : Test::Int::Scheduling
- c3t3 : Test::Int::Scheduling
- c3t_1 : Test::Int::Scheduling
- c3t_2 : Test::Int::Scheduling
- c3t_3 : Test::Int::Scheduling
- c4 : Gecode::Int::Branch
- c5 : Gecode::Int::Branch
- c6 : Gecode::Int::Branch
- c7 : Gecode::Int::Branch
- c8 : Gecode::Int::Branch
- c9 : Gecode::Int::Branch
- c_d : Gecode::Search::Config , Gecode::Int::Arithmetic
- c_d_p() : Gecode::Int::Arithmetic
- c_d_p< double >() : Gecode::Int::Arithmetic
- c_d_p< int >() : Gecode::Int::Arithmetic
- card : Gecode::Set::Limits
- card_cons() : Gecode::Int::GCC
- card_consistent() : Gecode::Int::GCC
- cardcheck() : Gecode::CpltSet
- cardConst() : Gecode::CpltSet
- cardeq() : Gecode::CpltSet
- cardinality() : Gecode
- cardlqgq() : Gecode::CpltSet
- cfd : Test::Int::Channel
- cfd11 : Test::Int::Channel
- cfd35 : Test::Int::Channel
- cfv : Test::Int::Channel
- cfv11 : Test::Int::Channel
- cfv35 : Test::Int::Channel
- channel() : Gecode , Gecode::Int::Sorted , Gecode
- chd : Test::Int::Channel
- check() : Test::Int::Bool , Gecode::Int::Limits , Gecode::Set::Limits
- check_alldiff() : Gecode::Int::GCC
- check_subsumption() : Gecode::Int::Sorted
- chv : Test::Int::Channel
- circuit() : Gecode
- clma : Test::Int::Channel
- clmb : Test::Int::Channel
- clmc : Test::Int::Channel
- cls : Test::Int::Channel
- cmp() : Test
- cn : Test::Set::RelOp
- codeScope() : Gecode
- codeToIterator() : Gecode
- computesccs() : Gecode::Int::Sorted
- conv_hull() : Gecode::CpltSet
- convex() : Gecode
- convexHull() : Gecode
- cost_hi() : Gecode
- cost_lo() : Gecode
- CostType : Gecode::Set::Int
- count() : Gecode
- count_bnd_d : Test::Int::Distinct
- count_bnd_s : Test::Int::Distinct
- count_dom_d : Test::Int::Distinct
- count_dom_s : Test::Int::Distinct
- count_val_d : Test::Int::Distinct
- count_val_s : Test::Int::Distinct
- CPLTSET_VAL_MAX_UNKNOWN : Gecode
- CPLTSET_VAL_MAX_UNKNOWN_EX_FIRST : Gecode
- CPLTSET_VAL_MIN_UNKNOWN : Gecode
- CPLTSET_VAL_MIN_UNKNOWN_EX_FIRST : Gecode
- CPLTSET_VAR_MAX_CARD : Gecode
- CPLTSET_VAR_MAX_UNKNOWN_ELEM : Gecode
- CPLTSET_VAR_MIN_CARD : Gecode
- CPLTSET_VAR_MIN_UNKNOWN_ELEM : Gecode
- CPLTSET_VAR_NONE : Gecode
- CpltSetOpType : Gecode
- CpltSetRelType : Gecode
- CpltSetValBranch : Gecode
- CpltSetVarArgs : Gecode
- CpltSetVarBranch : Gecode
- create() : Gecode::Int::Branch
- createBranch() : Gecode::Int::Branch
- csd : Test::Int::Channel
- csv : Test::Int::Channel
- cumulatives() : Gecode


|
AutoYams
Automatic Yams with OpenCV dice detection
|
Main game object. More...
#include <Game.h>
Public Slots | |
| void | clickDice (int index) |
| Processing selection on a dice when clicked. More... | |
Signals | |
| void | thrown () |
| Signal sent when a new throw occured. More... | |
| void | newPlayer (int index) |
| Signal sent when a new player has been chosen. More... | |
| void | newTurn (int val) |
| Signal sent when a new turn started. More... | |
| void | end () |
| Signal sent when the game should end. More... | |
Public Member Functions | |
| Game (QStringList players) | |
| Default constructor. More... | |
| ~Game () | |
| Default deconstructor. More... | |
| void | roll () |
| Roll every dices in members. More... | |
| Dice * | getDice (int index) |
| Access dice at a specified index. More... | |
| Player * | getCurrentPlayer () const |
| Access currently playing player. More... | |
| int | getCurrentThrow () const |
| Access counter value of the current throw. More... | |
| int | getCurrentTurn () const |
| Access current turn value. More... | |
| bool | Play (QString name) |
| Play move with currently specified name if possible. More... | |
| bool | isEnd () const |
| Verify if the game reached its end. More... | |
| bool | isLastTurn () const |
| Verify if the current player reached its last throw. More... | |
| void | NextThrow () |
| Increment next throw for the current player if possible. More... | |
| void | NextPlayer () |
| Increment current player index to change to the next player. More... | |
| void | NextTurn () |
| Increment turn counter if possible. More... | |
| QList< QPair< int, PlayableMove * > > | bestCurrentPlayerMoves () |
| Obtain every possible moves correctly ordered. More... | |
| int | currentScoreOf (QString move) |
| Compute the current score of a specified move name. More... | |
| void | setDices (QList< int > dices) |
| Change dices values to the specified data. More... | |
| Player * | winningPlayer () const |
| Search for the currently winning player. More... | |
Private Attributes | |
| int | turn |
| int | currentPlayerIndex |
| int | currentPlayerThrow |
| QList< Player * > | players |
| QList< Dice * > | dices |
| Scoring | scoreSystem |
Main game object.
Link every game objects to the game page.
| Game::Game | ( | QStringList | players | ) |
Default constructor.
| players | List of all player names |
Instantiate all Dices then Players according to the specified names, then specify each possible moves to the Scoring system instance.
| QList< QPair< int, PlayableMove * > > Game::bestCurrentPlayerMoves | ( | ) |
Obtain every possible moves correctly ordered.
For every possible moves, compute the current value on it's average possible result of any dice combination as a factor, then sort the list by the computed factor to return it correctly ordered.
|
slot |
Processing selection on a dice when clicked.
| index | Index of the clicked dice |
Currently useless, was meant for the user to select and unselect a dice on Manual Input methods.
| int Game::currentScoreOf | ( | QString | move | ) |
Compute the current score of a specified move name.
| move | Specific move name |
Compute the current score of a specific move then return its value/score.
|
signal |
Signal sent when the game should end.
Currently useless, was meant for a multiplayer implementation as a callback.
| Player * Game::getCurrentPlayer | ( | ) | const |
Access currently playing player.
Return the current player from members as the one currently playing.
| int Game::getCurrentThrow | ( | ) | const |
Access counter value of the current throw.
Get current throw, that's about it.
| int Game::getCurrentTurn | ( | ) | const |
Access current turn value.
Get current turn, that's all.
| Dice * Game::getDice | ( | int | index | ) |
Access dice at a specified index.
| index | Specific index |
Get dice from members at a specific index, allowing us to read its current value.
| bool Game::isEnd | ( | ) | const |
Verify if the game reached its end.
If more than 10 turns (included) have been played, the game should end.
| bool Game::isLastTurn | ( | ) | const |
Verify if the current player reached its last throw.
Return true if it is the player 3rd throw (or more). There's actually nothing turn related there.
|
signal |
Signal sent when a new player has been chosen.
| index | Index of the new player in propreties list |
Currently useless, was meant for a multiplayer implementation as a callback.
|
signal |
Signal sent when a new turn started.
| val | Value of the new turn counter |
Currently useless, was meant for a multiplayer implementation as a callback.
| void Game::NextPlayer | ( | ) |
Increment current player index to change to the next player.
Change to the following player and, if the index reached the end of the list, come back the first index and call Next Turn method. Reset dices values too.
| void Game::NextThrow | ( | ) |
Increment next throw for the current player if possible.
Change next throw if possible and requiered, cannot exceed 3 though.
| void Game::NextTurn | ( | ) |
Increment turn counter if possible.
Increase by one the turn counter if below 10.
| bool Game::Play | ( | QString | name | ) |
Play move with currently specified name if possible.
| name | Name of the current move to play |
Play specific move from name to the current player while updating its score accordingly.
| void Game::roll | ( | ) |
Roll every dices in members.
Every selected dices will be rolled for a new dice value.
| void Game::setDices | ( | QList< int > | dices | ) |
Change dices values to the specified data.
| dices | Specific data of new dices values |
Change every value when dices have been changed (ie. thrown).
|
signal |
Signal sent when a new throw occured.
Currently useless, was meant for a multiplayer implementation as a callback.
| Player * Game::winningPlayer | ( | ) | const |
Search for the currently winning player.
Used to declare the winning player at the end of the game.
|
private |
Current player index in player list.
|
private |
Current throw counter for current player.
|
private |
List of all 5 dices.
|
private |
List of all players currently in game.
|
private |
Instance of scoring system used to compute player moves.
|
private |
Current turn counter.


7.3 Implementation and Analysis of
Sets
The structure
Set is the set data structure. A good way to implement a set is as a
linked list. A simple way to do this
is to typedef Set to List (see
Example
7.1). In addition to simplicity, using a typedef has the
benefit of making the set somewhat polymorphic, just as was
described for stacks and queues (see Chapter
6). Thus, because the set is a linked list, we can use
linked list operations on it when we want it to act like one.
The biggest benefit of this with sets is that we can use list_next to traverse a set, and list_rem_next to remove members
without having to identify them by the data they store. Recall
that set_remove only removes
members keyed by their data, which can be a problem when we do
not know the members a set contains.
In general, the set operations presented here
are somewhat costly, primarily because many of them search for
members of one set in another by traversing each member.
However, we can improve the running times of these operations
by using a more efficient searching technique, such as hashing
(see Chapter
8). Nevertheless, the implementation provided here is a
general-purpose approach whose performance is adequate for
small to medium-sized sets of data.
Example 7.1.
Header for the Set Abstract Datatype /*****************************************************************************
* *
* -------------------------------- set.h --------------------------------- *
* *
*****************************************************************************/
#ifndef SET_H
#define SET_H
#include <stdlib.h>
#include "list.h"
/*****************************************************************************
* *
* Implement sets as linked lists. *
* *
*****************************************************************************/
typedef List Set;
/*****************************************************************************
* *
* --------------------------- Public Interface --------------------------- *
* *
*****************************************************************************/
void set_init(Set *set, int (*match)(const void *key1, const void *key2),
void (*destroy)(void *data));
#define set_destroy list_destroy
int set_insert(Set *set, const void *data);
int set_remove(Set *set, void **data);
int set_union(Set *setu, const Set *set1, const Set *set2);
int set_intersection(Set *seti, const Set *set1, const Set *set2);
int set_difference(Set *setd, const Set *set1, const Set *set2);
int set_is_member(const Set *set, const void *data);
int set_is_subset(const Set *set1, const Set *set2);
int set_is_equal(const Set *set1, const Set *set2);
#define set_size(set) ((set)->size)
#endif
7.3.1 set_init
The set_init operation initializes a set
so that it can be used in other operations (see Example
7.2). Since a set is a linked list, list_init is called to initialize it.
The match member is set to
match by hand because this member is not used
by linked lists and is therefore not set by list_init.
The runtime complexity of set_init is the same as list_init, or O (1).
7.3.2 set_destroy
The set_destroy operation destroys a set
(see Example
7.1). Since a set is a linked list and requires being
destroyed in the same manner, set_destroy is defined to list_destroy.
The runtime complexity of set_destroy is the same as list_destroy, or O (n), where n is the number of members in the
set.
7.3.3 set_insert
The set_insert operation inserts a member
into a set (see Example
7.2). Since a member must not occur more than once in a
set, set_is_member is called to
make sure that the set does not already contain the new
member. As long as the member does not already exist in the
set, list_ins_next is called to
insert the member.
The runtime complexity of set_insert is O (n)
because set_is_member runs in
O (n) time, and list_ins_next runs in O (1).
7.3.4 set_remove
The set_remove operation removes a member
from a set by traversing it using list_next until match
determines that the member to be removed has been found (see
Example
7.2). The pointer prev points just before
the member to be removed since this is required by list_rem_next. The list_rem_next operation sets
data to point to the data from the member
removed.
The runtime complexity of set_remove is O (n),
where n is the number of
elements in the set. This is because, in the worst case, the
entire set must be traversed in order to find the member to be
removed. This results in n
times O (1), the cost of the
statements within the loop, for a running time of O (n)
overall. Once the member is found, list_rem_next removes it in O (1) time.
7.3.5 set_union
The set_union operation builds a set,
setu, which is the union of the sets
set1 and set2 (see Example
7.2). First, setu is initialized by
calling set_init. Next, the
members of set1 are inserted into
setu by calling list_ins_next repeatedly for each
member of set1. Finally, the members of
set2 are inserted into setu in
a similar manner except that set_is_member is called before each
insertion to ensure that no members are duplicated in
setu.
The runtime complexity of set_union is O (mn), where m is the size of set1
and n is the size of
set2. In the first loop, each member of
set1 is traversed and inserted into
setu, which results in a running time of O (m).
In the second loop, each element of set2 is
traversed, which results in n
times the cost of the statements within this loop. This loop
contains the O (m) operation set_is_member. Therefore, the overall
complexity of the loop is O
(mn). Since the two loops are
executed one after another, the complexity of set_union is the more expensive of
the two, or O (mn).
7.3.6 set_intersection
The set_intersection operation builds a
set, seti, which is the intersection of the
sets set1 and set2 (see Example
7.2). First, seti is initialized by
calling set_init. Next, for
each member of set1, set_is_member is called to determine
whether the member is in set2. If so, the
member is inserted into seti.
The runtime complexity of set_intersection is O (mn), where m is the size of set1
and n is the size of
set2. This is because for each member in
set1, the O
(n) operation set_is_member is called to determine
whether the member is in set2.
7.3.7 set_difference
The set_difference operation builds a
set, setd, which is the difference of the sets
set1 and set2 (see Example
7.2). First, setd is initialized by
calling set_init. Next, for
each member of set1, set_is_member is called to determine
whether the member is in set2. If not, the
member is inserted into setd.
The runtime complexity of set_difference is O (mn), where m is the size of set1
and n is the size of
set2. This is because for each member in
set1, the O
(n) operation set_is_member is called to determine
whether the member is in set2.
7.3.8 set_is_member
The set_is_member operation determines
whether a particular member exists in a set (see Example
7.2). This is accomplished by traversing the set using
list_next until either a member
matching data is found or all members are
traversed.
The runtime complexity of set_is_member is O (n),
where n is the number of
members in the set. This is because, in the worst case, the
entire set must be traversed to find the member for which we
are searching.
7.3.9 set_is_subset
The set_is_subset operation determines
whether one set, set1, is a subset of another
set, set2 (see Example
7.2). Since a set that is a subset of another must be the
same size or smaller, we begin by comparing sizes. If this
test fails, then set1 is not a subset of
set2. Otherwise, set1 is
traversed using list_next until
either a member of set1 that is not in
set2 is found or all members are traversed. If
we find a member of set1 not in
set2, then set1 is not a
subset of set2. If we end up traversing all
members of set1, then set1 is
a subset of set2.
The runtime complexity of set_is_subset is O (mn), where m is the size of set1
and n is the size of
set2. This is because for each member in
set1, the O
(n) operation set_is_member is called to determine
whether the member is in set2.
7.3.10 set_is_equal
The set_is_equal operation determines
whether one set, set1, is equal to another
set, set2 (see Example
7.2). Since two sets that are equal must be the same size,
we begin by comparing sizes. If the two sets are not the same
size, then they are not equal. If the two sets are the same
size, we need only return the result of whether
set1 is a subset of set2. This
is determined by calling set_is_subset.
The runtime complexity of set_is_equal is O (mn), where m is the size of set1
and n is the size of
set2. This is because set_is_subset runs in O (mn)
time.
7.3.11 set_size
This macro evaluates to the size of a
set (see Example
7.1). It works by accessing the size
member of the Set structure.
The runtime complexity of set_size is O (1) because accessing a member of a
structure is a simple task that runs in a constant amount of
time.
Example 7.2.
Set Example: Set Covering/*****************************************************************************
* *
* -------------------------------- set.c --------------------------------- *
* *
*****************************************************************************/
#include <stdlib.h>
#include <string.h>
#include "list.h"
#include "set.h"
/*****************************************************************************
* *
* ------------------------------- set_init ------------------------------- *
* *
*****************************************************************************/
void set_init(Set *set, int (*match)(const void *key1, const void *key2),
void (*destroy)(void *data)) {
/*****************************************************************************
* *
* Initialize the set. *
* *
*****************************************************************************/
list_init(set, destroy);
set->match = match;
return;
}
/*****************************************************************************
* *
* ------------------------------ set_insert ------------------------------ *
* *
*****************************************************************************/
int set_insert(Set *set, const void *data) {
/*****************************************************************************
* *
* Do not allow the insertion of duplicates. *
* *
*****************************************************************************/
if (set_is_member(set, data))
return 1;
/*****************************************************************************
* *
* Insert the data. *
* *
*****************************************************************************/
return list_ins_next(set, list_tail(set), data);
}
/*****************************************************************************
* *
* ------------------------------ set_remove ------------------------------ *
* *
*****************************************************************************/
int set_remove(Set *set, void **data) {
ListElmt *member,
*prev;
/*****************************************************************************
* *
* Find the member to remove. *
* *
*****************************************************************************/
prev = NULL;
for (member = list_head(set); member != NULL; member = list_next(member)) {
if (set->match(*data, list_data(member)))
break;
prev = member;
}
/*****************************************************************************
* *
* Return if the member was not found. *
* *
*****************************************************************************/
if (member == NULL)
return -1;
/*****************************************************************************
* *
* Remove the member. *
* *
*****************************************************************************/
return list_rem_next(set, prev, data);
}
/*****************************************************************************
* *
* ------------------------------- set_union ------------------------------ *
* *
*****************************************************************************/
int set_union(Set *setu, const Set *set1, const Set *set2) {
ListElmt *member;
void *data;
/*****************************************************************************
* *
* Initialize the set for the union. *
* *
*****************************************************************************/
set_init(setu, set1->match, NULL);
/*****************************************************************************
* *
* Insert the members of the first set. *
* *
*****************************************************************************/
for (member = list_head(set1); member != NULL; member = list_next(member)) {
data = list_data(member);
if (list_ins_next(setu, list_tail(setu), data) != 0) {
set_destroy(setu);
return -1;
}
}
/*****************************************************************************
* *
* Insert the members of the second set. *
* *
*****************************************************************************/
for (member = list_head(set2); member != NULL; member = list_next(member)) {
if (set_is_member(set1, list_data(member))) {
/***********************************************************************
* *
* Do not allow the insertion of duplicates. *
* *
***********************************************************************/
continue;
}
else {
data = list_data(member);
if (list_ins_next(setu, list_tail(setu), data) != 0) {
set_destroy(setu);
return -1;
}
}
}
return 0;
}
/*****************************************************************************
* *
* --------------------------- set_intersection --------------------------- *
* *
*****************************************************************************/
int set_intersection(Set *seti, const Set *set1, const Set *set2) {
ListElmt *member;
void *data;
/*****************************************************************************
* *
* Initialize the set for the intersection. *
* *
*****************************************************************************/
set_init(seti, set1->match, NULL);
/*****************************************************************************
* *
* Insert the members present in both sets. *
* *
*****************************************************************************/
for (member = list_head(set1); member != NULL; member = list_next(member)) {
if (set_is_member(set2, list_data(member))) {
data = list_data(member);
if (list_ins_next(seti, list_tail(seti), data) != 0) {
set_destroy(seti);
return -1;
}
}
}
return 0;
}
/*****************************************************************************
* *
* ---------------------------- set_difference ---------------------------- *
* *
*****************************************************************************/
int set_difference(Set *setd, const Set *set1, const Set *set2) {
ListElmt *member;
void *data;
/*****************************************************************************
* *
* Initialize the set for the difference. *
* *
*****************************************************************************/
set_init(setd, set1->match, NULL);
/*****************************************************************************
* *
* Insert the members from set1 not in set2. *
* *
*****************************************************************************/
for (member = list_head(set1); member != NULL; member = list_next(member)) {
if (!set_is_member(set2, list_data(member))) {
data = list_data(member);
if (list_ins_next(setd, list_tail(setd), data) != 0) {
set_destroy(setd);
return -1;
}
}
}
return 0;
}
/*****************************************************************************
* *
* ----------------------------- set_is_member ---------------------------- *
* *
*****************************************************************************/
int set_is_member(const Set *set, const void *data) {
ListElmt *member;
/*****************************************************************************
* *
* Determine if the data is a member of the set. *
* *
*****************************************************************************/
for (member = list_head(set); member != NULL; member = list_next(member)) {
if (set->match(data, list_data(member)))
return 1;
}
return 0;
}
/*****************************************************************************
* *
* ----------------------------- set_is_subset ---------------------------- *
* *
*****************************************************************************/
int set_is_subset(const Set *set1, const Set *set2) {
ListElmt *member;
/*****************************************************************************
* *
* Do a quick test to rule out some cases. *
* *
*****************************************************************************/
if (set_size(set1) > set_size(set2))
return 0;
/*****************************************************************************
* *
* Determine if set1 is a subset of set2. *
* *
*****************************************************************************/
for (member = list_head(set1); member != NULL; member = list_next(member)) {
if (!set_is_member(set2, list_data(member)))
return 0;
}
return 1;
}
/*****************************************************************************
* *
* ------------------------------ set_is_equal ---------------------------- *
* *
*****************************************************************************/
int set_is_equal(const Set *set1, const Set *set2) {
/*****************************************************************************
* *
* Do a quick test to rule out some cases. *
* *
*****************************************************************************/
if (set_size(set1) != set_size(set2))
return 0;
/*****************************************************************************
* *
* Sets of the same size are equal if they are subsets. *
* *
*****************************************************************************/
return set_is_subset(set1, set2);
}
|


We enhance tables!
- iterate dot-com synergies
- reintermediate transparent synergies
- transition out-of-the-box schemas
- synergize transparent metrics
- recontextualize vertical ROI
- syndicate back-end networks
- reintermediate innovative e-services
- engineer enterprise portals
- utilize dynamic functionalities
- architect sticky supply-chains
- engage B2B vortals
- maximize open-source infrastructures


Latest data
Developers: start consuming the Web of Data
Add value and cool features to your application by using our restful APIs and JS widgets. Let us help you finding the right data and the way to access it!
How do I build my application? API documentation
Questions? Ideas? Sindice-dev group.
Sindice Blog Feed
-
Sindice migration
Nov 26, 2010This is mainly a test post to verify that the Sindice blog continues to work after migrating it to a new server. (More →)
-
So far semantic web search engines and semantic aggregation services have been inserting datasets by hand or have been based on “ran... (More →)
-
Sindice planned downtime this weekend
Jun 09, 2010HiDue to an expansion of one of our datacentres (and the electrical work that this implies), Sindice and related services such as sig.ma w... (More →)
-
Any23 v0.4.0 Released
May 27, 2010Dear All, the Sindice FBK team is proud to announce the Any23 0.4.0 release. (More →)
-
Any23 v0.3.0 Released
Apr 23, 2010Dear All, we’re pleased to announce the Any23 0.3.0 releasePlease keep in mind this is a beta, so everybody using Any23 in a develop... (More →)


cloud
Focado
- Student Dashboard
menu
Mr. Lorem Ipsum
Sign Out
more_vert
Sass
Components
Javascript
Mobile
ASK QUERY
Teacher's Name
Ask query
Submit
send


Evaluation Plan
The evaluation plan looks to meet all the requirements defined in early phases. Subjects representing each persona
will be selected as evaluators. An evaluation form will be provided to collect information (negative or positive)
for all subjects designated to evaluate the prototype. Information collected will be used as direct feedback on
improvements or areas needing to be corrected. The following requirements define the success criteria for all
subjects performing evaluations.
- Product design must integrate multiple common household activities reducing the need for them to be performed individually.
- Product design must incorporate economic and social factors introduced by the user groups.
- Product design must simplify a task by reducing the number of steps and effort needed to accomplish it.
- Product design results in energy/cost savings for the end user.
Assessment Feedback Results
Evaluator 1: Single Family Home (Working Mother)
Age: Mid-30’s
| Errors: During this evaluation, no errors were experienced. |
| Attention: I found a lot of detail in the application which made it visually understandable. |
| Fatigue: No fatigue experienced. The tasks were very direct and not prolonged. |
| Productivity: The application would have enabled my productivity just by allowing management of many devices from centralized mobile interface.
|
| Efficiency: The application seemed to provide results quickly and was very responsive. Overall, this will be allowing more efficiency in my day as a single parent.
|
| Ease of Use: The application and interface was very easy to use |
| Culture: The application had a very similar interface to many mobile applications. Was not different or anything new to learn.
|
| Emotion: I felt this is a new way for doing things. Much easier and pleasurable way for doing things – meaning was no discomfort in controls or way for managing home appliances. Great to know or gain insights into billing and usage of electricity.
|
| Experience: Great experience. Site was very responsive. Can see where this can be expanded upon to other devices and use cases.
|
| Convenience: By bringing the interfaces onto a mobile platform, I can see the state or access devices from anywhere. Do have concerns around security but overall was very easy to use. |
| Togetherness: The flow was very put together. Limited steps to access or navigate between windows.
|
| Empathy: How much will something like this be? Is it affordable for non-tech savvy families?
|
| Sociability: I can see this expanding into a social platform. Conservative, technology enthusiast’s groups |
| Entertainment: None at this point was connected. |
| Gamification: Great innovation. Can track trends for improvement. Would add functionality for some form of scoring around savings to make more game like.
|
Evaluator 2: College Student
Age: Early 20's
| Errors: None |
| Attention: Very easy to navigate. Very detailed and has everything I can think of. |
| Fatigue: Not slow |
| Productivity: I think the application would allow me to be productive. I can control everything through my phone or laptop anywhere/anytime. |
| Efficiency: Yes, this would allow me to be more efficient in my day. |
| Ease of Use: Very easy interface. |
| Culture:Not hard or different than many applications in the market today. |
| Emotion: Was good. No emotions but expected technology to solve problems like these. |
| Experience: Great experience. Very responsive. Overall great experience. |
| Convenience: Very convenient. |
| Togetherness: The flow was very put together. |
| Empathy: None. |
| Sociability: None. |
| Entertainment: Was prototype only. |
| Gamification: Can see where tech can be grown. |
Evaluator 3: Professional (Technology Industry)
Age: Late-30’s
| Errors: None |
| Attention: Very easy navigation. Properly structured and easy to follow. Functionally was very friendly to the end-user.
|
| Fatigue: None. Was very responsive. I can see where delays can be experienced when calling back-end systems that reside in a home network. |
| Productivity: I like the concept which builds on modern day trends of IoT. Love being able to gather data and insights into devices in the home. Enabling ability to manage monthly budgets and eliminate unnecessary spendings. |
| Efficiency: Yes of course. One less thing I need to worry about. Really like the ability to make routines. Can see where I would use for AM/PM scenarios.
|
| Ease of Use: Very easy interface. |
| Culture:Common theme. |
| Emotion: None. |
| Experience: Great experience. Very responsive. |
| Convenience: Very convenient. |
| Togetherness: Great flow. Nicely put together. |
| Empathy: None. |
| Sociability: None. |
| Entertainment: None. |
| Gamification: Technology can be greatly expanded on. |
Evaluator 4: Apartment Dweller, no prior home automation exposure
Age: Late-30’s
| Errors: Some confusion as to the back button on various pages. "Where is it supposed to go?" Was ultimately able to navigate with little difficulty.
|
| Attention: The fan control page did not indicate which fan was where. |
| Fatigue: Controls were sensible and easy to use with the exception of the back button comments already recorded. User did not experience fatigue. |
| Productivity: "This would probably save me time and money." |
| Efficiency: See fatigue and Productivity comments |
| Ease of Use: See fatigue comment |
| Culture:The user was not familiar with home automation but was accustomed to computer and smartphone interfaces. There were no additional hurdles to overcome in this regard. |
| Emotion: Was more interested in the potential of home automation after using the prototype interface. |
| Experience: Overall had a positive interaction with the prototype interface. Design idiom was familiar. |
| Convenience: Aspects of the "energy" prototype made the thought of easily saving money on utility bills without having to do lots of research appealing. |
| Togetherness: "Will more than one person have control?" Positives and negatives of shared (family, roommate, etc.) control came up. |
| Empathy: None observed or stated. |
| Sociability: see togetherness comment. |
| Entertainment: None. |
| Gamification: None. |


infrastructure package¶
Overview¶
Infrastructure package is used to model traffic signals, stop lights, pedestrian crossing boards. Currently, the infrastructure implemented are TrafficController and Traffic Signal. TrafficController is an attribute of a Intersection. It coordinates the switching of signals on the traffic signals on the corresponding intersection. TrafficSignal is an attribute on a Node which is controlled by a TrafficController of the Intersection which has the Node. Each Lane of the Road ending at the Node corresponds to a TrafficSignal on that Node.
infrastructure.traffic module¶
Traffic module contains classes and methods for controlling the traffic signals in the simulator.
-
class
core.lib.infrastructure.traffic.
TrafficController
¶ Controls and synchronizes all the traffic signals at an intersection.
The number of signals on a controller and the number of phases are coupled. In the current implementation, a fixed number of traffic signals is assumed (12) and the no of phases is fixed. The future implementation must include dynamically changing the “__no_phases” if a controller is instantiated with a different number of signals.
-
__no_phases
¶ int – indicates the number of phases (this depends on the functionality and no of signals)
-
__dt
¶ float – time between successive traffic state updates
-
__scale
¶ float – ten times of __dt
-
__cycle_length
¶ float – cycle length is the time taken for one complete cycle (a signal going from g-y-r-g)
-
__table
¶ dict – table defines the times at which the signals should switch. The entire control lies with this table
-
signals
¶ list – list of TrafficSignal objects
-
generate_table
()¶ Generates a table as described above with specified green time ratio, yellow time ratio and red time ratio. These ratios are coupled with the phase of the signal so care must be taken while changing these values.
Returns: keys as the traffic signal tcid, and the value as a list described in the above example Return type: dict
-
reset_signals
()¶ Resets all the signals to the beginning of the time cycle. This can be used to adaptively change the relative phase of the all the signals.
-
set_table
(table)¶ Currently a public method to enable the users to set a custom and phase timing (relative to the start of the cycle).
Parameters: table – A dict with keys as the indices to the traffic signals and values as a list containing the phase Example: Consider a TrafficController of cycle length 30. The entry for signal 0 in the self.__table looks like this.
table[0] = ['g', 10, 'y', 15, 'r', 30]
Traffic Signal at index 0 is green for the first 10 seconds, yellow for the next five seconds, and red for the next 15 seconds. The last entry should match with the cycle length of the TrafficController.
-
update_signals
()¶ This method is called every update step in the main simulation loop to update all the signal states and timings.
-
-
class
core.lib.infrastructure.traffic.
TrafficSignal
(tcid)¶ Traffic Signal is an interface for the vehicle to ‘see’ the states. It is controlled by a TrafficController.
-
color
¶ str – indicates the traffic state (red, green, yellow/amber)
-
time_remaining
¶ float – time after which the color changes
-
tcid
¶ int – unique identifier of the signal with respect to the controller
-
node
¶ Node – the node that has the traffic signal
-
tick
¶ int – counter/ time
-
x
¶ object – x coord of signal
-
y
¶ object – y coord of signal
-
get_state
()¶ Enables direct querying of the traffic signals’ states by the vehicles or any other object that has access to nodes. In the future implementation, communication module (v2x) should be interfaced with traffic signals.
Returns: [color, time remaining] Return type: list
-
set_coords
(x, y)¶ Sets the coordinates of the signal.
Parameters: - x (object) – x coord of signal
- y (object) – y coord of signal
-
set_node
(node)¶ Links the signal to a node object, to enable referencing nodes while accessing signals. It is used while creating a map and assigning traffic signals to end nodes of roads ending at intersections.
Parameters: node (Node) – the node object to which the signal is assigned
-
set_state
(color, time_remaining)¶ Sets the state of the signals regarding to the color and remaining time.
Parameters: - color (str) – ‘r’ for red, ‘g’ for green, ‘a’ for amber/yellow
- time_remaining (float) – time remaining in the current phase (time after which the color changes)
-


| Chairs | ||
|---|---|---|
| Árpád Beszédes | University of Szeged | Hungary |
| Miryung Kim | University of California, Los Angeles | United States | Members |
| Bram Adams | Polytechnique Montréal | Canada |
| Giuliano Antoniol | Polytechnique Montréal | Canada |
| Alberto Bachelli | University of Zurich | Switzerland |
| Hamid Bagheri | University of Nebraska Lincoln | United States |
| Gabriele Bavota | Università della Svizzera Italiana (USI) | Switzerland |
| Alexandre Bergel | University of Chile | Chile |
| Dave Binkley | Loyola University Maryland | United States |
| Christian Bird | Microsoft | United States |
| Tegawendé F. Bissyandé | SnT, University of Luxembourg | Luxembourg |
| Kelly Blincoe | University of Auckland | New Zealand |
| John Businge | Mbarara University of Science & Technology, Uganda | Uganda |
| Yuanfang Cai | Drexel University | United States |
| Andrea De Lucia | Department of Computer Science - University of Salerno | Italy |
| Serge Demeyer | Universiteit Antwerpen | Belgium |
| Massimiliano Di Penta | University of Sannio | Italy |
| Danny Dig | Oregon State University | United States |
| Wei Dong | National University of Defense Technology | China |
| Robert Feldt | Chalmers University of Technology | Sweden |
| Tamás Gergely | University of Szeged | Hungary |
| Rohit Gheyi | Federal University of Campina Grande | Brazil |
| Michael W. Godfrey | University of Waterloo | Canada |
| Jesus M. Gonzalez-Barahona | Universidad Rey Juan Carlos | Spain |
| Alessandra Gorla | IMDEA Software Institute | Spain |
| Mark Grechanik | University of Illinois at Chicago | United States |
| Dan Hao | Peking University | China |
| Shinpei Hayashi | Tokyo Institute of Technology | Japan |
| Abram Hindle | University of Alberta | Canada |
| Daqing Hou | Clarkson University | United States |
| Huzefa Kagdi | Wichita State University | United States |
| Maria Kechagia | University College London | United Kingdom |
| Jens Knodel | Caruso Dataplace | Germany |
| Raghavan Komondoor | Indian Institute of Science, Bangalore | India |
| Jens Krinke | University College London | United Kingdom |
| Dawn Lawrie | Johns Hopkins University | United States |
| Mario Linarez-Vásquez | Universidad de los Andes | Colombia |
| David Lo | Singapore Management University | Singapore |
| Xiaoxing Ma | Nanjing University | China |
| Andrian Marcus | University of Texas at Dallas | United States |
| Davood Mazinanian | University of British Columbia | Canada |
| Collin McMillan | University of Notre Dame | United States |
| Phil McMinn | University of Sheffield | United Kingdom |
| Na Meng | Virginia Tech | United States |
| Tom Mens | University of Mons | Belgium |
| Ali Mesbah | University of British Columbia | Canada |
| Kevin Moran | College of William and Mary | United States |
| Laura Moreno | Colorado State University | United States |
| Meiyappan Nagappan | University of Waterloo | Canada |
| Christian Newman | Rochester Institute of Technology | United States |
| Nicole Novielli | University of Bari | Italy |
| Mike Papadakis | Luxembourg University | Luxemburg |
| Xin Peng | Fudan University | China |
| Denys Poshyvanyk | College of William and Mary | United States |
| Jochen Quante | Robert Bosch GmbH | Germany |
| Chaiyong Ragkhitwetsagul | Mahidol University Thailand | Thailand |
| Baishakhi Ray | Columbia University | United States |
| Peter Rigby | Concordia University | Canada |
| Paige Rodeghero | Clemson University | United States |
| Sandro Schulze | University of Magdeburg | Germany |
| Alexander Serebrenik | Eindhoven University of Technology | Netherlands |
| Vibha Sinha | United States | |
| Harry Sneed | SoRing Kft / ZTP GmbH | Budapest / Vienna |
| Paolo Tonella | Università della Svizzera Italiana (USI) | Switzerland |
| Christoph Treude | University of Adelaide | Australia |
| Arie van Deursen | Delft University of Technology | The Netherlands |
| Santiago A. Vidal | Universidad Nacional del Centro De La Provincia de Buenos Aires | Argentina |
| Xinyu Wang | Zhejiang University | China |
| Jun Wei | Institute of Software, Chinese Academy of Sciences | China |
| Hyrum Wright | United States | |
| Xin Xia | Monash University | Australia |
| Xiaoyuan Xie | Wuhan University | China |
| Zhenchang Xing | Australian National University | Australia |
| Shin Yoo | Korea Advanced Institute of Science and Technology | Korea |
| Andy Zaidman | Delft University of Technology | Netherlands |
| Hongyu Zhang | The University of Newcastle | Australia |
| Lingming Zhang | University of Texas at Dallas | United States |
| Hao Zhong | Shanghai Jiao Tong University | China |
| Minghui Zhou | Peking University | China |
| Chairs | ||
|---|---|---|
| Sonia Haiduc | Florida State University | United States |
| Federica Sarro | University College London | United Kingdom | Members |
| Maurício Aniche | Delft University of Technology | Netherlands |
| Afnan Al‑Subaihin | University College London | United Kingdom |
| Alexandre Bergel | University of Chile | Chile |
| Cor‑Paul Bezemer | Queen's University | Canada |
| Fernando Castor | Federal University of Pernambuco | Brazil |
| Oscar Chaparro | The University of Texas at Dallas | Texas |
| Mel Ó Cinnéide | University College Dublin | Ireland |
| Neil Ernst | University of Victoria | Canada |
| Jesus M. Gonzalez‑Barahona | Universidad Rey Juan Carlos | Spain |
| Andre Hora | UFMG | Brazil |
| Andrea Janes | Free University of Bolzano | Italy |
| Valentina Lenarduzzi | Tampere University of Technology | Finland |
| Mehdi Mirakhorli | Rochester Institute of Technology | United States |
| Leon Moonen | Simula Research Laboratory | Norway |
| Rocco Oliveto | University of Molise | Italy |
| Matheus Paixão | University College London | United Kingdom |
| Giuseppe Scanniello | University of Basilicata | Italy |
| Francisco Servant | Virginia Tech | United States |
| Igor Steinmacher | Northern Arizona University | United States |
| Stefan Wagner | University of Stuttgart | Germany |
| Jie Zhang | University College London | United Kingdom |
| Chairs | ||
|---|---|---|
| Kevin Moran | College of William and Mary | United States |
| Bonita Sharif | University of Nebraska-Lincoln | United States | Members |
| Jairo Aponte | National University of Colombia | Colombia |
| Hamid Bagheri | University of Nebraska - Lincoln | United States |
| Olga Baysal | Carelton University | Canada |
| Jon Bell | George Mason University | United States |
| Michael Decker | Bowling Green State University | United States |
| Jin Guo | McGill University | Canada |
| Austin Henley | University of Tennesse - Knoxville | United States |
| Laura Moreno | Colorado State University | United States |
| Fabio Palomba | University of Zurich | Switzerland |
| Paige Rodeghero | Clemson University | United States |
| Alexander Serebrenik | Eindhoven University of Technology | Netherlands |
| Andreas Stefik | University of Nevada, Las Vegas | United States |
| Chris Vendome | Miami University Ohio | United States |
| Chairs | ||
|---|---|---|
| Michael Collard | The University of Akron | United States |
| Shinpei Hayashi | Tokyo Institute of Technology | Japan | Members |
| Oscar Chaparro | University of Texas at Dallas | United States |
| Damian Dechev | University of Central Florida | United States |
| Michael J. Decker | Bowling Green State University | United States |
| Natalia Dragan | Kent State University | United States |
| Robert Dyer | Bowling Green State University | United States |
| Hideaki Hata | Nara Institute of Science and Technology | Japan |
| Takashi Ishio | Nara Institute of Science and Technology | Japan |
| Foutse Khomh | DGIGL, École Polytechnique de Montréal | Canada |
| Roberto Minelli | Università della Svizzera Italiana (USI) | Switzerland |
| Mohamed Wiem Mkaouer | Rochester Institute of Technology | United States |
| Kunihiro Noda | Fujitsu Laboratories | Japan |
| Dario Di Nucci | Vrije Universiteit Brussel | Belgium |
| Coen De Roover | Vrije Universiteit Brussel | Belgium |
| Chairs | ||
|---|---|---|
| Katja Kevic | Microsoft | United Kingdom |
| Nicholas A. Kraft | UserVoice | United States | Members |
| Shaukat Ali | Simula Research Laboratory | Norway |
| Titus Barik | Microsoft | United States |
| Jurgen Cito | MIT | United States |
| Kostadin Damevski | Virginia Commonwealth University | United States |
| Slawomir Duszynski | Bosch | Germany |
| Xi Ge | Apple Inc. | United States |
| Austin Henley | University of Tennessee - Knoxville | United States |
| Raula Kula | Nara Institute of Science and Technology | Japan |
| Boyang Li | ABB Robotic R&D Center | United States |
| Shane McIntosh | McGill University | Canada |
| Andrea Mocci | Università della Svizzera Italiana (USI) | Switzerland |
| Brendan Murphy | Microsoft Research | United Kingdom |
| Meiyappan Nagappan | University of Waterloo | Canada |
| Christian Newman | Rochester Institute of Technology | United States |
| Ipek Ozkaya | Carnegie Mellon Software Engineering Institute | United States |
| Rahul Pandita | Phase Change Software | United States |
| Jochen Quante | Robert Bosch GmbH | Germany |
| Antonino Sabetta | SAP Labs | France |
| Yan Wang | The Ohio State University | United States |
| Erik Wittern | IBM | United States |
| Chairs | ||
|---|---|---|
| Roberto Minelli | Università della Svizzera Italiana (USI) | Switzerland |
| Paige Rodeghero | Clemson University | United States | Members |
| Sebastian Baltes | University of Trier | Germany |
| Matthias Galster | University of Canterbury | New Zealand |
| Austin Henley | University of Tennessee - Knoxville | United States |
| Siyuan Jiang | Eastern Michigan University | United States |
| Boyang Li | ABB Robotic R&D Center | United States |
| Bin Lin | Università della Svizzera Italiana (USI) | Switzerland |
| Mario Linares-Vásquez | Universidad de los Andes | Colombia |
| Kevin Moran | College of William and Mary | United States |
| Laura Moreno | Colorado State University | United States |
| Csaba Nagy | Università della Svizzera Italiana (USI) | Switzerland |
| Gustavo Pinto | UFPA | Brazil |
| Sebastian Proksch | University of Zurich | Switzerland |
| Fiorella Zampetti | University of Sannio | Italy |
| Chairs | ||
|---|---|---|
| James Clause | University of Delaware | United States |
| Alexander Serebrenik | Eindhoven University of Technology | Netherlands | Members |
| Alessandra Gorla | IMDEA Software Institute | Spain |
| Shinpei Hayashi | Tokyo Institute of Technology | Japan |
| Nicholas A. Kraft | UserVoice | United States |
| Shane Mcintosh | McGill University | Canada |
| Bonita Sharif | University of Nebraska - Lincoln | United States |
| Thomas Zimmermann | Microsoft | United States |
| Members | ||
|---|---|---|
| Bram Adams | Polytechnique Montréal | Canada |
| Árpád Beszédes | University of Szeged | Hungary |
| Christian Bird | Microsoft | United States |
| Kelly Blincoe | University of Auckland | New Zealand |
| Alessandra Gorla | IMDEA Software Institute | Spain |
| Dan Hao | Peking University | China |
| Miryung Kim | University of California, Los Angeles | United States |
| Dawn Lawrie | Loyola University Maryland | United States |
| Nicole Novielli | University of Bari | Italy |
| Alexander Serebrenik | Eindhoven University of Technology | Netherlands |
| Andy Zaidman | Delft University of Technology | Netherlands |


Yorick Language Reference
Constants
By default, an integer number is a constant of type long, and
a real number is a constant of type double. Constants of the typesshort,
int, float,
and complex are specified by means of the suffices
s, n, f, and
i, respectively. Here are some examples:
char '\0', '\1', '\x7f', '\177', 'A', '\t'
short 0s, 1S, 0x7fs, 0177s, -32766s
int 0N, 1n, 0x7Fn, 0177n, -32766n
long 0, 1, 0x7f, 0177, -32766, 1234L
float .0f, 1.f, 1.27e2f, 0.00127f, -32.766e3f
double 0.0, 1.0, 127.0, 1.27e-3, -32.766e-33
complex 0i, 1i, 127.i, 1.27e-3i, -32.766e-33i
string "", "Hello, world!", "\tTab\n2nd line"
The following escape sequences are recognized in type char
and type string constants:
\n newline
\t tab
\" double quote
\' single quote
\\ backslash
\ooo octal number
\xhh hexadecimal number
\a alert (bell)
\b backspace
\f formfeed (new page)
\r carriage return
|


- IMPORT_RULE - Static variable in interface org.w3c.dom.css.CSSRule
-
The rule is a CSSImportRule
.
- importNode(Node, boolean) - Method in interface org.w3c.dom.Document
-
Imports a node from another document to this document, without altering
or removing the source node from the original document; this method
creates a new copy of the source node.
- INDEX_SIZE_ERR - Static variable in exception org.w3c.dom.DOMException
-
If index or size is negative, or greater than the allowed value.
- initEvent(String, boolean, boolean) - Method in interface org.w3c.dom.events.Event
-
The initEvent
method is used to initialize the value of an
Event
created through the DocumentEvent
interface.
- initMouseEvent(String, boolean, boolean, AbstractView, int, int, int, int, int, boolean, boolean, boolean, boolean, short, EventTarget) - Method in interface org.w3c.dom.events.MouseEvent
-
The initMouseEvent
method is used to initialize the value
of a MouseEvent
created through the
DocumentEvent
interface.
- initMutationEvent(String, boolean, boolean, Node, String, String, String, short) - Method in interface org.w3c.dom.events.MutationEvent
-
The initMutationEvent
method is used to initialize the
value of a MutationEvent
created through the
DocumentEvent
interface.
- initUIEvent(String, boolean, boolean, AbstractView, int) - Method in interface org.w3c.dom.events.UIEvent
-
The initUIEvent
method is used to initialize the value of
a UIEvent
created through the DocumentEvent
interface.
- insertBefore(Node, Node) - Method in interface org.w3c.dom.Node
-
Inserts the node newChild
before the existing child node
refChild
.
- insertCell(int) - Method in interface org.w3c.dom.html.HTMLTableRowElement
-
Insert an empty TD
cell into this row.
- insertData(int, String) - Method in interface org.w3c.dom.CharacterData
-
Insert a string at the specified 16-bit unit offset.
- insertNode(Node) - Method in interface org.w3c.dom.ranges.Range
-
Inserts a node into the Document or DocumentFragment at the start of
the Range.
- insertRow(int) - Method in interface org.w3c.dom.html.HTMLTableElement
-
Insert a new empty row in the table.
- insertRow(int) - Method in interface org.w3c.dom.html.HTMLTableSectionElement
-
Insert a row into this section.
- insertRule(String, int) - Method in interface org.w3c.dom.css.CSSMediaRule
-
Used to insert a new rule into the media block.
- insertRule(String, int) - Method in interface org.w3c.dom.css.CSSStyleSheet
-
Used to insert a new rule into the style sheet.
- INUSE_ATTRIBUTE_ERR - Static variable in exception org.w3c.dom.DOMException
-
If an attempt is made to add an attribute that is already in use
elsewhere.
- INVALID_ACCESS_ERR - Static variable in exception org.w3c.dom.DOMException
-
If a parameter or an operation is not supported by the underlying
object.
- INVALID_CHARACTER_ERR - Static variable in exception org.w3c.dom.DOMException
-
If an invalid or illegal character is specified, such as in an XML name.
- INVALID_MODIFICATION_ERR - Static variable in exception org.w3c.dom.DOMException
-
If an attempt is made to modify the type of the underlying object.
- INVALID_NODE_TYPE_ERR - Static variable in exception org.w3c.dom.ranges.RangeException
-
If the container of an boundary-point of a Range is being set to either
a node of an invalid type or a node with an ancestor of an invalid
type.
- INVALID_STATE_ERR - Static variable in exception org.w3c.dom.DOMException
-
If an attempt is made to use an object that is not, or is no longer,
usable.
- invokeAndWait(DOMAction) - Method in class com.sun.java.browser.dom.DOMService
-
Causes action.run() to be executed synchronously on the
DOM action dispatching thread.
- invokeLater(DOMAction) - Method in class com.sun.java.browser.dom.DOMService
-
Causes action.run() to be executed asynchronously on the
DOM action dispatching thread.
- isDefaultNamespace(String) - Method in interface org.w3c.dom.Node
-
This method checks if the specified namespaceURI
is the
default namespace or not.
- isDerivedFrom(String, String, int) - Method in interface org.w3c.dom.TypeInfo
-
This method returns if there is a derivation between the reference
type definition, i.e.
- isElementContentWhitespace() - Method in interface org.w3c.dom.Text
-
- isEqualNode(Node) - Method in interface org.w3c.dom.Node
-
Tests whether two nodes are equal.
- isId() - Method in interface org.w3c.dom.Attr
-
Returns whether this attribute is known to be of type ID (i.e.
- isSameNode(Node) - Method in interface org.w3c.dom.Node
-
Returns whether this node is the same node as the given one.
- isSupported(String, String) - Method in interface org.w3c.dom.Node
-
Tests whether the DOM implementation implements a specific feature and
that feature is supported by this node, as specified in .
- item(int) - Method in interface org.w3c.dom.css.CSSRuleList
-
Used to retrieve a CSS rule by ordinal index.
- item(int) - Method in interface org.w3c.dom.css.CSSStyleDeclaration
-
Used to retrieve the properties that have been explicitly set in this
declaration block.
- item(int) - Method in interface org.w3c.dom.css.CSSValueList
-
Used to retrieve a CSSValue
by ordinal index.
- item(int) - Method in interface org.w3c.dom.DOMImplementationList
-
Returns the index
th item in the collection.
- item(int) - Method in interface org.w3c.dom.DOMStringList
-
Returns the index
th item in the collection.
- item(int) - Method in interface org.w3c.dom.html.HTMLCollection
-
This method retrieves a node specified by ordinal index.
- item(int) - Method in interface org.w3c.dom.NamedNodeMap
-
Returns the index
th item in the map.
- item(int) - Method in interface org.w3c.dom.NodeList
-
Returns the index
th item in the collection.
- item(int) - Method in interface org.w3c.dom.stylesheets.MediaList
-
Returns the index
th in the list.
- item(int) - Method in interface org.w3c.dom.stylesheets.StyleSheetList
-
Used to retrieve a style sheet by ordinal index.


{{> navbarHeader }}
{{> yield }}
{{> navbarFooter}}
This example uploads a file to the /programs/server/assets/app/uploads directory. If you're running it on a local development environment, you'll need to go to .meteor/local/build/programs/server/assets/app/uploads.
{{> dropzone url="/uploads" id="#creativeTagDropZone" }}


Error category:
Error Description:
If you'd like to include a note with your gift, please designate it here. If you have any questions please click this link to email us or call us at {{org_phone}}
Please select the trip, then you will be able to choose the participant you'd like to support.
If you have questions please email, {{contact_address}}.


Because field validation functions must be very quick and low-resource, server-based Asynchronous validation
cannot be done inside these callbacks. It can be implemented using a simple workaround. The application
connects to the field's onBlur
handler and keeps track when the validation is started. This
technique is demonstrated below.


{% extends "internal_base.html" %} {% from "internal/groups/member.html" import render_user_name_link %} {% block page_content %} {% if user_is_member_of_year %}
You're member of this group.
Year participation request is pending.
Request to join


Tom Thompson
Lottery
- Daily
- $50 Prizes (8)
- Sponsor Prizes (20)
- Weekly
- $200 Prizes (1)
- Sponsor Prizes (10)
- LEADERBOARD
- John Doe
- Jane Payne
- Bob Carter
Environmental Visualization
On average, a Vancouver commuter travels 30km each day, 5 days a week between work.
If you drive a , for each year:
| MPG | Gallons of Gas | Tons of CO2 | Sequestered by |
|---|---|---|---|
| 35 | 68 | 0.7 | 16.5 trees* |
Statistics
-
Total kilometers biked:
86 -
Total CO2 sequestered:
107 pounds -
Total money donated:
$72 -
Longest streak:
46 days -
Current streak:
15 days -
Total friends invited:
3 -
Longest route in a day:
18 km


All of our virtual professionals are highly experienced in the areas in which they work and have been through a thorough recruitment process.
©Designed and Developed by GrayGrids


|
OpenZL
|
namespace zl More...
Classes | |
| class | Mat_ |
| template 2D Matrix class. More... | |
| class | Point_ |
| template 2D point class. More... | |
| class | Rect_ |
| The 2D up-right rectangle class. More... | |
| class | Scalar_ |
| Simple template Scalar_ class. More... | |
| class | Size_ |
| The 2D size class. More... | |
| class | Timer |
| Cross-platform Timer class. More... | |
| class | Vec2_ |
| template 2D Vector class. More... | |
Typedefs | |
| typedef Scalar_< double > | Scalar |
| default use double precision | |
| typedef Point_< int > | Point2i |
| typedef Point_< float > | Point2f |
| typedef Point_< double > | Point2d |
| typedef Point2i | Point |
| typedef std::vector< Point > | Vecpt |
| 1-D vector of Points | |
| typedef Size_< int > | Size2i |
| typedef Size_< float > | Size2f |
| typedef Size_< double > | Size2d |
| typedef Size2i | Size |
| typedef Rect_< int > | Rect2i |
| typedef Rect_< float > | Rect2f |
| typedef Rect_< double > | Rect2d |
| typedef Rect2i | Rect |
| typedef Mat_< uchar > | Matu8 |
| typedef Mat_< ushort > | Matu16 |
| typedef Mat_< sint > | Mati |
| typedef Mat_< float > | Matf |
| typedef Mat_< double > | Matd |
| typedef Matu8 | Mat |
| typedef Vec2_< uchar > | Vec2u8 |
| typedef Vec2_< ushort > | Vec2u16 |
| typedef Vec2_< sint > | Vec2i |
| typedef Vec2_< float > | Vec2f |
| typedef Vec2_< double > | Vec2d |
| typedef Vec2d | Vec2 |
Functions | |
| void | error (String err) |
| Prints the specified error and exit. More... | |
| void | warning (String warn) |
| Prints the specified warning. More... | |
| int | waitkey (double ms) |
| wait for the specficed ms until keypressed More... | |
| void | hold_screen () |
| Hold screen for key press More... | |
| int | get_key () |
| Get asynchronized keyboard press. More... | |
| int | kb_hit () |
| Detect keyboard hit, no wait More... | |
| template<class T > | |
| const T | abs (const T &v) |
| Return the abosolute value More... | |
| template<class T > | |
| const T | min (const T &a, const T &b) |
| Return the smaller value More... | |
| template<class T > | |
| const T | max (const T &a, const T &b) |
| Return the larger value More... | |
| template<class T > | |
| const T | lock_in (const T &value, const T &low, const T &high) |
| Lock the specified value inside range [low, high] More... | |
| template<typename T > | |
| void | println (T t) |
| Print the message, start a new line More... | |
| template<typename T , typename... U> | |
| void | println (T t, U...u) |
| Print the message with various arguments, start a new line More... | |
| int | fast_round (double value) |
| inline fast round function More... | |
| template<typename _Tp > | |
| bool | cvt_color (Mat_< _Tp > &src, Mat_< _Tp > &dst, int code) |
| Convert the color space of given image. More... | |
| void | imshow (const char *windowname, Mat &image) |
| Display image in window given title More... | |
| void | destroy_window (const char *windowname) |
| Destroy window with the specified windowname. More... | |
| void | destroy_all_windows () |
| Destroy all windows. More... | |
| void | draw_line (Mat &image, int x0, int y0, int x1, int y1, Scalar color, int thickness) |
| Draw line on the specified image. More... | |
| void | draw_line (Mat &image, Point pt1, Point pt2, Scalar color, int thickness) |
| Draw line on the specified image, overloaded with points. More... | |
| void | draw_circle (Mat &image, int xc, int yc, int radius, Scalar color, int thickness, bool fill) |
| Draw a circle on the specified image. More... | |
| void | draw_circle (Mat &image, Point center, int radius, Scalar color, int thickness, bool fill) |
| Draw a circle on the specified image. Overloaded with center point. More... | |
| void | draw_rectangle (Mat &image, int x0, int y0, int x1, int y1, Scalar color, int thickness, bool fill) |
| Draw a rectangle on the specified image. More... | |
| void | draw_rectangle (Mat &image, Point pt0, Point pt1, Scalar color, int thickness, bool fill) |
| Draw a rectangle on the specified image. Overload with Points More... | |
| void | draw_rectangle (Mat &image, Rect rect, Scalar color, int thickness, bool fill) |
| Draw a rectangle on the specified image. Overloaded with Rect More... | |
| void | draw_polygon (Mat &image, Vecpt &vertices, Scalar color, bool fill) |
| Draw a polygon on the specified image. The drawing contour follow the vertices order! More... | |
| bool | imread (Mat &image, const String &filename, int flags) |
| Read image from file More... | |
| bool | imwrite (const String &filename, Mat &img, int flags, int quality) |
| Write image to file More... | |
namespace zl
where all the functionality resides
|
inline |
Return the abosolute value
| v | The input value. |
|
inline |
Convert the color space of given image.
| src | The src image. |
| dst | The dst image. |
| code | The convertion code. |
| void zl::destroy_all_windows | ( | ) |
Destroy all windows.
| void zl::destroy_window | ( | const char * | windowname | ) |
Destroy window with the specified windowname.
| windowname | The windowname. |
| void zl::draw_circle | ( | Mat & | image, |
| int | xc, | ||
| int | yc, | ||
| int | radius, | ||
| Scalar | color, | ||
| int | thickness, | ||
| bool | fill | ||
| ) |
Draw a circle on the specified image.
| image | The image. |
| xc | The center x. |
| yc | The center y. |
| radius | The radius. |
| color | The color. |
| thickness | The thickness. |
| fill | if set to true fill the circle. |
| void zl::draw_circle | ( | Mat & | image, |
| Point | center, | ||
| int | radius, | ||
| Scalar | color, | ||
| int | thickness, | ||
| bool | fill | ||
| ) |
Draw a circle on the specified image. Overloaded with center point.
| image | The image. |
| center | The center point. |
| radius | The radius. |
| color | The color. |
| thickness | The thickness. |
| fill | if set to true [fill] the circle. |
Draw line on the specified image.
| image | The image. |
| x0 | The x0. |
| y0 | The y0. |
| x1 | The x1. |
| y1 | The y1. |
| color | The color. |
| lineWidth | Thickness of the line. |
Draw line on the specified image, overloaded with points.
| image | The image. |
| pt1 | The Point1. |
| pt2 | The Point2. |
| color | The color. |
| lineWidth | Thickness of the line. |
Draw a polygon on the specified image. The drawing contour follow the vertices order!
| image | The image. |
| vertices | The vertices in ORDER! |
| color | The color. |
| fill | if set to true [fill] the polygon. |
| void zl::draw_rectangle | ( | Mat & | image, |
| int | x0, | ||
| int | y0, | ||
| int | x1, | ||
| int | y1, | ||
| Scalar | color, | ||
| int | thickness, | ||
| bool | fill | ||
| ) |
Draw a rectangle on the specified image.
| image | The image. |
| x0 | The x0. |
| y0 | The y0. |
| x1 | The x1. |
| y1 | The y1. |
| color | The color. |
| thickness | The thickness. |
| fill | if set to true [fill] the rectangle. |
| void zl::draw_rectangle | ( | Mat & | image, |
| Point | pt0, | ||
| Point | pt1, | ||
| Scalar | color, | ||
| int | thickness, | ||
| bool | fill | ||
| ) |
Draw a rectangle on the specified image. Overload with Points
| image | The image. |
| pt0 | The Point 0. |
| pt1 | The Point 1. |
| color | The color. |
| thickness | The thickness. |
| fill | if set to true [fill]. |
Draw a rectangle on the specified image. Overloaded with Rect
| image | The image. |
| rect | The rect. |
| color | The color. |
| thickness | The thickness. |
| fill | if set to true [fill]. |
| void zl::error | ( | String | err | ) |
Prints the specified error and exit.
| err | The error to output. |
|
inline |
inline fast round function
| value | The floating value. |
| int zl::get_key | ( | ) |
Get asynchronized keyboard press.
| void zl::hold_screen | ( | ) |
Hold screen for key press
| bool zl::imread | ( | Mat & | image, |
| const String & | filename, | ||
| int | flags | ||
| ) |
Read image from file
| image | The image container. |
| filename | The filename. |
| flags | The flags. |
| void zl::imshow | ( | const char * | windowname, |
| Mat & | image | ||
| ) |
Display image in window given title
| windowname | The windowname. |
| image | The image. |
| bool zl::imwrite | ( | const String & | filename, |
| Mat & | img, | ||
| int | flags, | ||
| int | quality | ||
| ) |
Write image to file
| filename | The filename. |
| img | The image container. |
| flags | The flags. |
| quality | The quality(only for JPEG). |
| int zl::kb_hit | ( | ) |
Detect keyboard hit, no wait
|
inline |
Lock the specified value inside range [low, high]
| value | The value. |
| low | The low threshold. |
| high | The high threshold. |
|
inline |
Return the larger value
| a | a. |
| b | b. |
|
inline |
Return the smaller value
| a | a. |
| b | b. |
|
inline |
Print the message, start a new line
| logMsg | The log message to print. |
|
inline |
Print the message with various arguments, start a new line
| t | The first message. |
| ...u | The additional message. |
| int zl::waitkey | ( | double | ms | ) |
wait for the specficed ms until keypressed
| ms | The ms to wait. |
| void zl::warning | ( | String | warn | ) |
Prints the specified warning.
| warn | The warning string to output. |


{% block content %}
Heart Disease Prediction
Best Method To Find Prediction
Get Started!
{% endblock %}