| Previous | Table of Contents | Next |
This section of the tutorial introduces one of the "rustiest" aspects of Rust: memory management.
Rust provides memory references in a way that is quite different from other languages you may be familiar with, and it requires some effort to understand, but provide the big advantage of providing both explicit control and safety. We'll also cover strings and vectors, file and user I/O, and basic error handling in Rust. At the end of this section, you'll write a simple encryption program that employs many of the new concepts.
The box in Rust is the fundamental abstraction of memory. References in Rust can point to boxes. Because Rust is designed to emphasize safety, any allocated memory in Rust is boxed, and thus any box can be thought of as simply a chunk of memory.
~
) and the borrowed reference (denoted with ampersand:
&
). Both kinds of pointers point to a box, and the pointer types are orthogonal to the type of data the box contains. For example,
~[&str]
is a owned reference to a vector of borrowed strings.
Similarly, dereferencing a Rust pointer is done with the star operator (
*
). The next section on ownership will go into more detail on the usage and interaction of both of these.
@
which was automatically managed (garbage collected). As of Rust 0.9, this syntax is deprecated, however it is planned to be reintroduced in future releases. These added a deal of simplicity to pointer management, however other pointer types could be used with more efficency. Automatically managed pointers may be implemented as library types.
In Rust, there is a notion of ownership of an object. The owner of an object, which could be a variable that refers to that object, manages the object's lifetime (that is, when its memory is allocated and reclaimed). Programmers do not have to explicitly allocated and deallocate storage. Rather, it is done by the Rust compiler and runtime based on how the object references are used.
A declaration of an owned (
~
) pointer can be thought of as giving the declared variable ownership of the box. What does this mean in code? The following block works as anticipated, printing out "10".
1 2 | let x = ~10; println!("{:d}", *x); |
However the following block gives a compilation error:
1 2 3 | let x = ~10; let y = x; println!("{:d}", *x); |
tut2.rs:3:23: 3:24 error: use of moved value: `x`
tut2.rs:3 println!("{:d}", *x);
The error message is a bit unclear, but what it is reporting is a violation of ownership rules. When we create the owned box of
~10
, that box is owned by the variable
x
. The initialization,
let y = x;
assigns the pointer to y. Because of Rust's emphasis on safety this is not allowed: it creates two references to an owned box.
In other languages, such as C and Java, there are no restrictions on pointer sharing. We could do,
y = x;
*y = 3;
thus changing the value of
*x
through the alias. With Rust, the assignment,
y = x
transfers ownership of the box
x
refers to from the
x
reference to the
y
reference. From this point on, any attempts to use
x
to manipulate that box will result in a compiler error.
We can make a copy of a box using the
clone
method which copies over the content of a box and creates a new owned pointer to the copy. So the following code will assign
y
to a new owned pointer pointing to a new copy of the value "10". The dereferencing of
x
no longer causes a compiler error, as
x
still has proper ownership of its box.
1 2 3 | let x = ~10; let y = x.clone(); println!("{:d}", *x); |
But,
x
and
y
refer to different boxes now — a modification of
*x
will not be visible through
y
.
All that copying would be expensive, and eliminate the benefits of data sharing for uses like pass-by-reference and data structures. Rust's solution is to provide a way for owners to loan out their objects.
Using the
&
operator creates a temporary reference to some memory that has already been allocated. These references are refered to as "borrowed" because they can access the contents of the box during the borrowing period, but do not own the box. This most commonly used to pass in a pointer reference to a method.
Because of Rust's emphasis on safety there are many resctriction on what can be done with a reference. Most notably, if a pointer has a borrowed reference in scope (more on scope in the next section), any function which would free the memory or change the type being pointed to would cause a compile-time error. Think of it this way: creating a reference to a box "lends" that box's contents to the reference until the loaned box is "returned". Thus, a reference owner gives up full control over a loaned box while it is being borrowed.
Borrowed references are frequently used as function parameters. For example,
1 2 3 | fn borrow(r : &int) -> int { *r } |
declares the function
borrow
to take a borrowed pointer to an int. We can call it by passing in an owned pointer:
1 2 | let x = ~10; println!("borrow(x): {:d}", borrow(x)); |
Borrowed pointers can also be loaned by the borrowee, within the lifetime of the original loan. We can pass in an owned pointer to borrow2, which borrows that pointer and passes it as a borrowed pointer to borrow:
1 2 3 | fn borrow2(r : &int) -> int { borrow(r) } |
As with scalar variables, boxes are immutable by default. The
mut
qualifier is used to indicate that a box is mutable. Mutability applies to the contents of a box, and not the pointer itself.
For example,
1 2 3 | fn increment(r: &int) { *r = *r + 1; } |
is not permitted:
borrowed.rs:2:4: 2:6 error: cannot assign to immutable dereference of & pointer
borrowed.rs:2 *r = *r + 1;
^~
To allow the modification, we need to declare the parameter as a borrowed, mutable reference:
r: &mut int
Now, the compiler produces an error for the callsite since the passed object is not mutable:
borrowed.rs:16:14: 16:15 error: cannot borrow immutable dereference of ~ pointer as mutable
borrowed.rs:16 increment(x);
To change this, we need to add
mut
to the declaration:
1 2 3 | fn main() { let mut x = ~10; increment(x); |
The
mut
here applies to the reference
x
and is also inherited by the box (so no separate
mut
annotation is needed for the
~
. It allows both the variable
x
to be reassigned, as well as the contents of the owned box to be modified:
1 2 3 | let mut x = ~10; x = ~20; *x = 30; |
The first assignment statement creates a new box owned by
x
holding the value
20
. The second assignment statement modifies the value in that box to be
30
. Without the
mut
neither assignment would be permitted by the Rust compiler.
Borrowed references do not inherit mutability. For example, this code is invalid:
1 2 3 4 5 | let mut val1 = 10; let mut val2 = 20; let mut borrowed = &val1; borrowed = &val2; *borrowed = 11; |
borrowed.rs:23:4: 23:13 error: cannot assign to immutable dereference of & pointer
borrowed.rs:23 *borrowed = 11;
^~~~~~~~~
To allow both modifications, we need:
1 | let mut borrowed = &mut val1; |
which allows both modifying the referenced box and changing what
borrowed
references.
Keep in mind that references are type checked (yet another safety measure of Rust!) so the following code produces an error at compile time due to trying to reassign an int reference to a float reference.
1 2 3 4 | let mut val1 = 10; let mut val3 = 10.0; let borrowed = &val1; borrowed = &val3; |
tut2.rs:4:16: 6:21 error: mismatched types: expected `&<VI0>` but found `&<VF0>` (expected integral variable but found floating-point variable)
tut2.rs:4 borrowed = &val3;
When an object is loaned through a borrowed reference, the lender loses the ability to modify that object. This is especially important for multi-tasking (which we'll get to soon), but still relevant with a single thread.
For example, the following program produces a compiler error:
1 2 3 4 5 6 | let mut x = 10; { let y = &x; x = 11; // Error } x = 12; //This is fine |
example.rs:4:9: 4:10 error: cannot assign to `x` because it is borrowed
example.rs:4 x = 11;
When the reference
y
borrows the value
x
refers to, the value of
x
is frozen until the reference to it goes out of scope. Thus, the first reassignment here is invalid, but the second (after
y
is out of scope) is fine.
Memory allocated in Rust is automatically freed when its owner either goes out of scope or is reassigned. This eliminates the need to explicitly free storage (as in C or C++), but guarantees safety without giving up control to a garbage collector.
Owned pointers follow similar rules of deallocation, so borrowing a reference to some box and trying to access it once it has gone out of scope throws a compiler error.
1 2 3 4 5 6 | let mut reference: &~int; { let val: ~int = ~10; reference = &val; } //val deallocated here println!("{:d}", **reference); //Referencing something that's gone! |
example.rs:4:21: 4:25 error: borrowed value does not live long enough
example.rs:4 reference = &val;
Rust provides built-in vector and string types, consistent with Rust's focus on safety.
A vector is defined by using comma seperated values within brackets.
A specific element can be accessed via
foo[index]
. Any vector definition where the elements may change after the initial definition should be an owned box, so the methods of
std::vec::OwnedVector
may be used to mutate the vector.
These examples show simple vector functions:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | let mut vec = ~[0, 1, 2]; vec.push(3); // Appends to end: [0, 1, 2, 3] vec.insert(2, 10); // Inserts 10 at position 2: [0, 1, 10, 2, 3] let last = vec.pop(); // Returns last element, removing it from the vector: [0, 1, 10, 2] let element1 = vec.remove(1); // Returns and removes element at specified index: [0, 10, 2] // An iterator for going through all elements in order: for &x in vec.iter() { // note the use of & for borrowing println!("{}", x); } // len() returns the number of elements in the vector for i in range(0, vec.len()) { println!("{}", vec[i]); } |
Rust supposrts a
scdoe
string
edoc
type which is a vector of characters. Each character is a UTF-8 sequence, represented by the
u8
type in Rust.
A notable construct that is very important for strings is the
slice
. This represents a view into a string, but not a string itself. Its type is
&string
.
Methods that produce a slice include
slice(&self, begin: int, end: int)
, which returns a slice of characters between begin and end - 1,
slice_from(&self, begin: int)
, which returns a slice with first element from the index provided that continues to the end, and
slice_to(&self, end: int)
, which returns a slice starting at the beginning with final element from index end - 1.
These slice methods produce an immutable values, so they cannot be modified.
To do something such as taking a substring, a slice may be converted to an owned string via the
to_owned(&self)
method. These slice methods work on any vector, but string manipulation is the most common use of slices.
Other notable string methods include
str::eq(&~str, &~str)
which checks two strings for bytewise equality, and
split(&self, char)
which returns an iterator that splits the string the method is called on into slices delimited by the parameter character.
For string concatenation, the
+
operator is used.
These methods are used in the example below:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | let string = ~"This is a string"; let subst1 = string.slice(10, 16).to_owned(); let subst2 = string.slice_from(10).to_owned(); println!("{}", std::str::eq(&subst1, &subst2)); let doublesub = subst1 + subst2; println!("{}", doublesub); // Using split iterator to print word by word for tempstr in string.split(' ') { println!("{}", tempstr); } // Another useful function of the split iterator // collect() Creates a vector ~["This", "is", "a", "string"] let wordvec: ~[&str] = string.split(' ').collect(); for &s in wordvec.iter() { println!("{}", s); } |
increment
that takes as input a vector of integers and returns a new vector of integers that has the values of the original list each incremented by one. For example:
1 2 3 4 5 6 7 | fn main() { let p = ~[1, 2, 3]; let q = increment(p); for &x in q.iter() { print!("{:d} ", x); } } |
should print out 2 3 4.
incrementMut
that takes as input a vector of integers and modifies the values of the original list by incrementing each value by one. For example:
1 2 3 4 5 6 7 | fn main() { let mut p = ~[1, 2, 3]; incrementMut(p); for &x in p.iter() { print!("{:d} ", x); } } |
should print out 2 3 4.
Rust handles file and user input/output using the std::io module.
The most intuitive way to work with these is through the use of a
BufferedReader,
which will be explained more in depth in the following sections. Take note that many methods in
BufferedReader
return vectors of bytes, not strings, so appropriate conversions may be necessary.
Standard input is provided through
std::io::stdin
, and implemented by creating a buffered reader. The following example (taken from the Rust documentation) prints out a series of lines from standard input, automatically stopping at the end of input. The
lines
method returns an iterator that goes through each line until the end of imput.
1 2 3 4 5 6 7 8 9 | use std::io::buffered::BufferedReader; use std::io::stdin; fn main(){ let mut stdin = BufferedReader::new(stdin()); for line in stdin.lines() { print(line); } } |
Reading line by line is a bit more difficult, as the
read_line
method is of an
Option<~str>
type. These option types are explained more in depth in the "Error Handling" section later on this page of the tutorial. The gist of it is the following though: a call to
read_line
can either succeed or fail. Thus, when it is called, we need a match statement to determine if it succeeded (where it will return
line
in the following example) or fail (which returns
None
). The example code below reads in the next 5 lines from stdin, and prints them. If there are less than 5 lines, the loop ends without crashing the program.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 | use std::io::buffered::BufferedReader; use std::io::stdin; fn main(){ let mut stdin = BufferedReader::new(stdin()); for i in range(0, 5) { match stdin.read_line() { Some(line) => { print(line); } None => { println("End of input!"); break; } } } } |
The standard library functions for working with files in Rust are handled via the std::io::File module. This module contains methods for opening and writing to a file.
A file is opened using
Path
objects, which are included in any Rust program by default. Creating a
Path
object is done through
Path::new("path/to/file.foo")
.
To simply open a new file for writing,
File::create(&Path)
is the simplest call. This returns an
edoc
Option type
, so it must be matched to ensure that a file was successfully opened.
The two most common ways to write to the file once opened are:
File::write(&mut self, &[u8])
which writes a buffer of bytes to a file, and:
File::write_str(&mut self, &str)
which writes a string to the file.
This example demonstrated opening a file for writing using both of these methods:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | use std::io::File; fn main() { match File::create(&Path::new("message.txt")) { Some(mut file) => { file.write(bytes!("line one\n")); file.write_str("line two\n"); } None =>{ println("Opening message.txt failed!"); } } } |
Reading a file can be accomplished easily through using the BufferedReader module, much like reading from standard in.
Opening a file to a
BufferedReader
is done using the
File::open(&Path)
function, which opens the file at a given path in read-only mode, followed by
BufferedReader::new(File)
.
Note that the file needs to be matched before converting to a
BufferedReader
, as
File::open
returns an
Option<File>
type. Once converted to a
BufferedReader
, a file is read in an identical manner to reading from stdin in the previous example, and all relevant methods are outlined on the
BufferedReader
documentation.
Here's a simple example of reading a file:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | use std::io::buffered::BufferedReader; use std::io::File; fn main() { match File::open(&Path::new("message.txt")) { Some(file) => { let reader = BufferedReader::new(file); //reading from file } None =>{ println("Opening message.txt failed!"); } } } |
The
File::open_mode(&Path, FileMode, FileAccess)
method allows specifying the mode in which a file is accessed.
FileMode
and
FileAccess
are enumerable types imported from
std::io::FileMode
and
std::io::FileAccess
respectively. For example, to open a file with read and write access, positioned to append to the end of the file, the following must be included, and then called as so.
1 2 3 4 5 | use std::io::{File, Append, ReadWrite}; /* ... */ let file = File::open_mode(&Path::new("message.txt"), Append, ReadWrite); |
Like the other file methods, this returns an
Option
objects that must be matched to check for opening failures.
Error handling in Rust is done with the intention of catching what can be caught at compile-time, and reducing runtime errors. We've seen the
Option<T>
type used for functions which either create an object or fail (represented by
None()
). There is another, similar construct to this called a
Result<T,E>
which is like a
Option
, but determined on whether a function succeds as intended on a pre-existing object (as opposed to the creation of a new object with
Option
).
A
Result
requires a match statement to use the values obtained. The
Ok(T)
branch represents a successful call, whereas
Err(E)
is a failed called. The error result may provide specific information about the failure, depending on the function.
If a
None()
or
Err(E)
branch is reached and the program can no longer continue, a
fail!()
macro can be used to terminate a program with an optional message.
The following code terminates with a message if "foo.txt" is failed to open:
1 2 3 4 5 6 | match File::create(&Path::new("foo.txt")) { Some(mut file) => { /* ... */ } None => { fail!("Creating foo.txt failed!"); } } |
The XOR operation is a simple, but effective method for hiding meaning.
It's derived from the identity A = (A ^ B) ^ B
. XOR-ing a
message with a random key provides perfect encryption, known as
a one-time pad. It is essentially the only form of encryption
that is information-theoretically secure, but is impractical for most
purposes since it requires a perfectly-random key as long as the
message and that key can never be reused.
It works by taking in a message and a random bit sequence (key) of equal length. Each bit in the message is XORed with the corresponding bit in the key to produce the encrypted message. The original message can then be recovered by applying the XOR process to the key and the encrypted message.
For this exercise, we will use this strategy to convert a plaintext file into two secret shares, each of which discloses no information about the original file (other than its length), but if someone has both shares they can put them together to produce the original file. A paranoid individual might use such an approach to store a file in the cloud by storing one share using Dropbox and the other share using Google Docs. The user could acquire both shares to obtain the file, and if the NSA can hypothetically (of course) obtain all of the data from one of the services but not both of them, it would not be enough to learn the contents of the file.
Note that our implementation uses
std::rand::random
to generate the random key. This is not cryptographically strong randomness, so should be used for entertainment purposes only! (If you are interested in better random numbers, see tRustees: True Random Number Generation.)
We'll provide the code to do the splitting, and leave it as an exercise for you to write the joining code.
The following Rust code implements the splitter. It takes as input the name of a file, and writes out two share files.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 | use std::rand::random; use std::os; use std::io::File; fn main() { let args: ~[~str] = os::args(); if args.len() != 2 { println!("Usage: {:s} <inputfile>", args[0]); } else { let fname = args[1]; let path = Path::new(fname.clone()); let msg_file = File::open(&path); match (msg_file) { Some(mut msg) => { let msg_bytes: ~[u8] = msg.read_to_end(); let share1_file = File::create(&Path::new(fname + ".share1")); let share2_file = File::create(&Path::new(fname + ".share2")); match (share1_file, share2_file) { (Some(share1), Some(share2)) => { split(msg_bytes, share1, share2); } , (_, _) => fail!("Error opening output files!"), } } , None => fail!("Error opening message file: {:s}", fname) } } } fn xor(a: &[u8], b: &[u8]) -> ~[u8] { let mut ret = ~[]; for i in range(0, a.len()) { ret.push(a[i] ^ b[i]); } ret } fn split(msg_bytes: &[u8], mut share1: File, mut share2: File) { let mut random_bytes: ~[u8] = ~[]; // This is not cryptographically strong randomness! // (For entertainment purposes only.) for _ in range(0, msg_bytes.len()) { let random_byte = random(); random_bytes.push(random_byte); } let encrypted_bytes = xor(msg_bytes, random_bytes); share1.write(random_bytes); share2.write(encrypted_bytes); } |
The joiner reverses the splitting process, taking the two shares and combining them to produce the original message.
Exercise 2.3. Implement the joiner. It should take two file names as its inputs, and output to standard output the result of XOR-ing the bytes in those files. The inputs files must be the same length.
Your joiner should be able to produce the plaintext from the example files: msg.share1 and msg.share2. You should download these files (look at them to confirm they appear to be random bytes).
Then, try executing:
joiner msg.share1 msg.share2
If you implemented the joiner correctly, you should see a (somewhat) meaningful message.
| Previous | Table of Contents | Next |


Connection State
host
port
Connection State
connect
disconnect
Login
username
password
Login
Record
record someUser
subscribe
unsubscribe
delete
record data
firstname
lastname
performance
set timestamp
time since record was updated
Memory
create and destroy records
stop
Event
emit
name
data
OK
subscribe
name
OK
events
,
RPC
provide addTwo
OK
make rpc addTwo
numA
numB
response
response time
OK


Required, directory to save uploaded images to, url friendly, auto-generated, relative to your www root. e.g. images
resizing is recommended to reduce bandwidth and to avoid breaking the localStorage limit of 5.2 MB for all data. requires canvas support.
Images get resized to fit into this bounding box while keeping their aspect ratio.
do you want to edit a group or add a new one
name of a class of images, url friendly
on every upload, different types of an image are created
do you want to edit a type or add a new one
name for a version of an image, url friendly
fit in defined rectangle while keeping aspect ratio
cover defined rectangle while keeping aspect ratio
Examples: sepia; blur 30, 20; monochrome; colorize 100, 0, 0; modulate 100, 50; … Documentation


Jump fatigue is not limited to capital pilots, it also affects anyone using a jumpbridge. Please read up on the topic as its important for everyone to understand the new mechanic.
Cooldown = Timer preventing you from jumping
Fatigue = Penalty timer used as a basis for the cooldown timer
Everytime you travel using a jump mechanic this happens:
Cooldown (minutes) = Max ( fatigue / 10, 1 + ( distance in lightyears * ( 1 - bonus ) ) )
Fatigue (minutes) = Min ( 60 * 24 * 30, Max ( fatigue, 10 ) * ( 1 + ( distance in lightyears * ( 1 - bonus ) ) ) )
Be aware that there is no benefit in waiting for fatigue to decay below 10 minutes
| Ship | Jumping to Cyno Bridged by Titan Using Jumpbridge | Jumping to Covert Cyno Bridged by Black Ops |
|---|---|---|
| Black Ops | 50% | 50% |
| Covert Ops, Force Recon | 0% | 50% |
| Blockade Runner | 90% | 95% |
| Standard Industrial, Deep Space Transport, Capital Industrial, Jumpfreighter, Freighter | 90% | N/A |
| Everything else | 0% | N/A |
| Ship | Range (ly) |
|---|---|
| Jumpfreighter, Rorqual | 5.0 - 10.0 |
| Black Ops | 4.0 - 8.0 |
| Carrier, Force Auxillary, Dreadnought | 4.2 - 7.0 |
| Supercarrier, Titan | 3.6 - 6.0 |


{% extends "home-base.html" %} {% block title %} About {% endblock %} {% block active_tab %}
Here, you can learn more about me!


The jQuery API
Image taken from here
Sandbox for JS and other languages
Huge resource for web based programming


Creates a new User record in the portal
| Flag | Type | Required | Default | Description |
|---|---|---|---|---|
| string | Yes | The user's Email address | ||
| --username | string | Yes | The user's Username | |
| --displayname | string | No | The Display Name for the user. If not specified, the Display Name will be firstname + single space + lastname | |
| --firstname | string | Yes | The user's First Name | |
| --lastname | string | Yes | The user's Last Name | |
| --password | string | No | auto-generated | The Password for the user account. If not specified, a random password will be generated. Note that unless you are forcing the user to reset their password, you should ensure that someone is notified of the password. |
| --approved | boolean | No | true | Whether the user account is authorized. Defaults to true if not specified. |
| --notify | boolean | No | false | If true, the system email will be sent to the user at the user's email address. The type of email is determined by the registration type. If this is not passed, the default portal settings will be observed. If the site's registration mode is set to None, no email will be sent regardless of the value of --notify . |
This generates a random password and assigns it to the newly created user. Display name is generated by concatenating the first and last name. Note that because "van Doorne" contains a space, we need to enclose it in double-quotes. The resulting Display name will be "Erik van Doorne".
new-user --username edoorne --email<EMAIL_ADDRESS>--firstname Erik --lastname "van Doorne"


Time Left:
1:00 seconds
Score:
60
Dang kid, that was fantastic! You scored big ones!
Tired of inputs and collection forms? Tired of always giving away information on the internet? How about trying a little input destruction for a change! Start Game


Domestic abuse victim pretends to order pizza to call police on violent partner
Police in Oregon city, Ohio, USA, praised the woman's quick thinking - but victims in the UK are advised to use a different tactic to warn authorities they are in danger
by Neil MurphyA domestic abuse victim pretended to order a pizza so the perpetrator wouldn't know she was calling for 911 for help.
The woman, who has not been named, has been praised for her quick-thinking by police after they were called to her address in Oregon city, Ohio, USA.
Officers arrived at the home and arrested the man over reports that he had assaulted the woman's mother, reports ABC 13 .
Similar instances of ordering pizza to alert police about domestic violence have been widely shared on social media in the past.
However, such tactics are considered rare and are not generally advocated by law enforcement agencies.
The operator who answered the call, Tim Teneyck, says he initially thought the person had rang the wrong number, but the woman's real intentions quickly became apparent.
Mr Teneyck was able to respond accordingly after reading about other instances on social media where it has happened.
"You see it on Facebook , but it's not something that anybody has ever been trained for," Mr Teneyck said.
"Other dispatchers that I've talked to would not have picked up on this. They've told me they wouldn't have picked up on this."
The transcript of the call shows how the woman was able to communicate her the nature of her emergency without directly discussing it.
It reads:
Mr Teneyck: Oregon 911
Caller: I would like to order a pizza at [address redacted].
Mr Teneyck: You called 911 to order a pizza?
Caller: Uh, yeah. Apartment [redacted].
Mr Teneyck: This is the wrong number to call for a pizza...
Caller: No, no, no. You're not understanding.
Mr Teneyck: I'm getting you now.
Later in the call, the woman found creative ways to answer Mr Teneyck's yes or no questions about how much danger she and her mother were in, and what services they needed.
Mr Teneyck: Is the other guy still there?
Caller: Yep, I need a large pizza.
Mr Teneyck: All right. How about medical, do you need medical?
Caller: No. With pepperoni.
The exact origin of the pizza emergency call is unclear but it did make an appearance on Reddit in 2014 when a user described a similar incident.
They wrote that the call "started out pretty dumb, but was actually pretty serious"
Last year, Christopher Carver who is operations director for National Emergency Number Association in the US, debunked claims that operators were trained to deal with calls of this nature.
"Setting any expectations of secret phrases that will work with any 911 centre is potentially very dangerous," he said, and recommended that people use 911's SMS service instead.
Victims of domestic violence in the UK have been advised to use the "silent solution system" used by British cops.
Callers to 999 should remain silent if they are able to speak and can then dial 55 to inform the person on the other end that they are in a genuine emergency.
If this option is not available, callers can leave the phone off the hook so that operators can hear what is going on.
Police should be able to trace the address of the call and respond accordingly.


Hello, my name is Kamil and I'm 24. My journey with programming and IT started in Upper Secondary School of Comunications in Cracow. In 2019, after first-cycle studies I started graduate studies at the same degree course and University with hopes to finish it in 2021.
I'm looking for opportunieties in web development or testing, but I will consider every offer. I spend a lot of time to make my projects user friendly and to make them looking good. In which helps me knowledge of Adobe Photoshop & Illustrator.
When it comes to my personality, I'm introvert and friendly. I can work by my own or in larger group. I am realist and I prefer to look for possible difficulties rather than obvious positivies. Also I am kind of person who plans literally everything.
Only frontend on fully functional matchmaking system for M&B Warband PC game
Theme called "Prince" - mainly CSS, HTML and less with some UX design


Grid
The Grid is a fluid system with a max width of 120.0rem (1200px), that
shrinks with the browser/device at smaller sizes. The grid uses CSS
Flexible Box Layout Module standard. Simply add columns you want in a
row, and they'll evenly take up the available space. If you want three
columns, add three columns, if you want five columns, add five columns.
Then came the night of the first falling star.
Silver mist suffused the deck of the ship.
All their equipment and instruments are alive.
A red flare silhouetted the jagged edge of a wing.
Offsets
I watched the storm, so beautiful yet terrific. Mist enveloped the
ship three hours out from port. The sky was cloudless and of a deep
dark blue.
A shining crescent far beneath the flying vessel. Almost before we
knew it, we had left the ground. It was going to be a lonely trip
back.
Column widths
The Grid system also supports specifying column widths as a ratio of the
parent row's width. Append one of the percentages listed below to a
column- class to achieve the desired layout.
I watched the storm, so beautiful
I watched the storm, so beautiful yet terrific. Mist
I watched the storm, so beautiful yet terrific. The sky was
I watched the storm, so beautiful yet terrific. Mist enveloped the
ship three
I watched the storm, so beautiful yet terrific. Mist enveloped the
ship three hours out from
I watched the storm, so beautiful yet terrific. Mist enveloped the
ship three hours out from port. The
I watched the storm, so beautiful yet terrific. Mist enveloped the
ship three hours out from port. The sky was
I watched the storm, so beautiful yet terrific. Mist enveloped the
ship three hours out from port. The sky was cloudless
I watched the storm, so beautiful yet terrific. Mist enveloped the
ship three hours out from port. The sky was cloudless and of a deep
dark
I watched the storm, so beautiful yet terrific. Mist enveloped the
ship three hours out from port. The sky was cloudless and of a deep
dark blue.


Performing authentication checks. Please wait...
Welcome to the admin dashboard, {{name}}.
New contest


We specialize in the sales and repair of classic keyboards, in particular the Fender Rhodes, Wurliter EP200, and Hohner Clavinet.


From: Suman Nath<EMAIL_ADDRESS>Date: 04/23/03
Hi Ganesh
In the version (stable030203) of IrisNet you are using, SA sends XML paths
and values to update. OAs then construct the necessary XUPDATE commands to
do the update.
However, this does not reflect the true potential of XUPDATE, since OAs
only "replaces" existing values. However, real XUPDATE supports a lot of
other operations like node addition, deletion etc. IrisNet's OAs actually
supports any arbitrary XUPDATe commands, but currently there is no way for
SAs to use that feature.
The new version that I will send to you will allow SAs to send
arbitrary XUPDATE commands to the OAs (thus SAs will have more control
over how to manipulate the data). I will send the code to you soon. In the
mean time, you may like to look at the following links to get an idea
about XUPDATE specification and syntax. Thus when you have our code, you
can write senselets to construct required XUPDATE commands.
1. http://www.xmldatabases.org/projects/XUpdate-UseCases/ : excellent page
with a lot of examples of allmost all possible XUPDATE commands.
2. http://www.xmldb.org/xupdate/ : XUPDATE specification
3. http://www.xindice.org/Resources/XindiceDocumentation.html : xindice
documntation page.
For now, I think the 1st link would be enough for you. The page
gives a lot of example xupdate commands. Your senselet should be able to
construct similar xupdate commands that suit your schema.
Dont worry, I will help you in case you find something alien.
Suman
This archive was generated by hypermail 2.1.5 : 04/23/03 EDT


19-25 Dec 2018
21 Nov 2018
Competitions where I actually won stuff LOL
I remember this day, 20th May 2018 clearly since it was on my birthday.
It was also one day before my Chinese O level paper 1 and 2 LMAO (I still got A1 so it's fine)
If you were expecting a picture of my team and I: there isn't one! The organisers said that they would post it on the event's Facebook page but they didn't, so.

This one was in mid-December 2017..
I went to Kallang Theatre to watch the Vainglory 2017 World Championship.
Basically two Razer staff asked if I wanted to play in a competition too and told me that there would be prizes so I agreed.
It was a king-of-the-hill-style match which I didn't know about until the competition started, and since I was the first to sign up, I was also first in line to play.
When I looked behind me, there was a long queue snaking all the way to the entrance of the venue, and I thought, "Oh shit" but it was too late to back out, so I just carried on with it.
To my surprise, I easily carried my team and steamrolled over most of the other players. Yes, easily. At that time, I was spending hours everyday playing Vainglory, and I was ranked at Tier 9, Gold division, one rank away from the highest tier.
All was going smoothly, there were only 2 teams left between my team and the top prize. That was when a team of 3, all wearing matching jerseys, stood at the Razer phones across us. At a glance I knew they were different, and reality proved it to be true. They crushed me with their superior skill and team synergy just as I had done to the many teams before them.
Defeated, I could only accept the consolation prize, which was a Razer Hammerhead earpiece...for iOS. "I'm an Android user dammit", I thought, but there was nothing I could do.
The next day, I went again (to watch the competition of course), and I saw the same two Razer employees
Well they saw me too, so I waved to greet them as they approached me with somewhat apprehensive expressions on their faces.

Since they were only second-string pro players, they weren't sent to represent Singapore in the world championship, and instead came to participate in the unofficial one which I also happened to be in..
The thing is, they weren't actually allowed to play in the unofficial competition since they were pro players, and the Razer employees didn't notice that they were pro players, so they let them play. However, once they found out the truth about them being pro players, the employees immediately disqualified them.
However, by then, I was long gone, watching the championship within the huge crowd upstairs. Unable to find or contact me, they decided to hold the unofficial competition again the next day in hopes that my team would pass by again so that they could make it up to us.
As fate would have it, we did pass by just after the registration ended. The Razer employees decided to let us join at the end of the queue as they felt bad about the previous day.
When it was our turn, history repeated and we easily crushed the previous king of the hill. This time, we were fully rested, not exhausted from playing for nearly an hour without any breaks, and had ample time to prepare to destroy the reigning king while waiting in the queue.


Class Employee
public class Employee
extends java.lang.Object
-
Field Summary
Fields Modifier and Type Field Description (package private) java.time.LocalDateTime
currentDateTime
private java.lang.String
empName
private int
empNo
private Role
givenRole
-
Constructor Summary
-
Method Summary
Modifier and Type Method Description boolean
changeBooking(int bookingNo, java.util.ArrayList<java.lang.String> toBeChangedAttributes, java.util.ArrayList<java.lang.Object> changedValues)
Implementation of the Employee's ability to change one or multiple attributes of a Booking same params as createBooking, but some can be null-like values, if they should not be changed.boolean
changeCustomer(int customerID, java.lang.String key, java.lang.String value)
The implementation of the Employee's ability to change a customer by given customerID and key and value of the new customers property.boolean
changeRoomDetails(int roomNo, java.util.ArrayList<java.lang.String> toBeChangedAttributes, java.util.ArrayList<java.lang.Object> changedValues)
Implementation of the Employee's ability to change attributes of a room to save details of real world changes to the room does not change the number of a room or its use case (hotel room or conference room).Booking
createBooking(int roomNo, int customerID, TimeFrame timeFrame, DateFrame dateFrame, Booking.BookingType bookingType, Room.Category roomCategory, java.lang.String specialWishes, boolean isBusinessCustomer)
Implementation of the Employee's ability to create Bookings for Customers uses getEmpNo to automatically add the employee's number and always the current date to ensure the right date is stored to bookingDate.ConferenceRoom
createConferenceRoom(int roomNo, Room.Category category, int areaInSqrMetre, int maxAmountOfParticipants, int amountOfWhiteboards, int amountOfBeamer, boolean hasScreen, boolean hasComputer, boolean hasTV, float pricePerUnit)
Implementation of the Employee's ability to create a conference room.Customer
createCustomer(java.lang.String firstName, java.lang.String lastName, java.lang.String streetName, java.lang.String streetNumber, java.lang.String postalCode, java.lang.String cityName, java.lang.String mailAddress, Customer.paymentMethods paymentMethod, java.lang.String iban)
The implementation of the Employee's ability to create a customer by given parameters.HotelRoom
createHotelRoom(int roomNo, Room.Category category, int areaInSqrMetre, int bedCount, boolean hasSpeedLAN, boolean hasTV, boolean hasKitchen, boolean hasCoffeemaker, float pricePerUnit)
Implementation of the Employee's ability to create a hotel room.void
deleteBooking(int bookingNo)
Implementation of the Employee's ability to delete a Booking by its booking number does not use the remove method of the ArrayList to keep the relation of the position of a booking in Bookings to its bookingNo.void
deleteCustomer(int customerID)
The implementation of the Employee's ability to delete a customer from customers ArrayList by given customerID.void
deleteRoom(int roomNo)
Implementation of the Employee's ability to delete a room entirely.java.util.ArrayList<Booking>
findBooking(int BookingNo, int RoomNo, int empNo, DateFrame dateFrame, TimeFrame timeFrame, java.lang.String bookingDate, Room.Category roomCategory)
Implementation of the Employee's ability to search for a booking by several parameters given.java.lang.String
getEmpName()
int
getEmpNo()
Role
getGivenRole()
void
manageBookingRequests()
The implementation of an autonomous management of customer requests, based on whether or not a suitable room is free at the time given.void
setEmpName(java.lang.String empName)
void
setEmpNo(int empNo)
void
setGivenRole(Role givenRole)
java.lang.StringBuilder
showAllBookings()
The implementation of a Listing feature, to analyze all Bookings.Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
-
Field Details
-
currentDateTime
java.time.LocalDateTime currentDateTime -
empNo
private int empNo -
empName
private java.lang.String empName -
givenRole
-
-
Constructor Details
-
Employee
public Employee(java.lang.String empName) -
Employee
-
-
Method Details
-
createBooking
public Booking createBooking(int roomNo, int customerID, TimeFrame timeFrame, DateFrame dateFrame, Booking.BookingType bookingType, Room.Category roomCategory, java.lang.String specialWishes, boolean isBusinessCustomer) throws java.lang.IllegalCallerExceptionImplementation of the Employee's ability to create Bookings for Customers uses getEmpNo to automatically add the employee's number and always the current date to ensure the right date is stored to bookingDate. Role BookingManager is needed.
- Parameters:
roomNo
- Number of the Room which is used as well as its position inside RoomstimeFrame
- the time span in which the corresponding room will be used; should contain fixed time spans for hotel rooms and variable time spans for conference roomsdateFrame
- the date span for one or multiple days, of which a room is blocked; should allow variable date spans for both types of rooms as a conference room could be used for a congress for multiple days and a hotel room can be used for one or multiple nightsbookingType
- indicates if the booking is a HotelRoomBooking or a ConferenceRoomBookingroomCategory
- Description of the time of room, should be Suite, Single Room or Double Room for hotel rooms or Little Group or Big Group for conference roomsspecialWishes
- contains any special wishes made by a customer, could be an extra bed, room service or wake up service in the morningisBusinessCustomer
- marks the booking to be requested by a business customer or for personal use; important for generation of bills and taxes to be used- Returns:
- the Booking created just now
- Throws:
java.lang.IllegalCallerException
- if the employee does not inherit the role BookingManager
-
changeBooking
public boolean changeBooking(int bookingNo, java.util.ArrayList<java.lang.String> toBeChangedAttributes, java.util.ArrayList<java.lang.Object> changedValues) throws java.lang.IllegalArgumentException, java.lang.IllegalCallerExceptionImplementation of the Employee's ability to change one or multiple attributes of a Booking same params as createBooking, but some can be null-like values, if they should not be changed. Role BookingManager is needed.
- Parameters:
bookingNo
- Number of the Booking as well as its position inside BookingstoBeChangedAttributes
- contains all attributes named by string, that need to be changed inside the Booking objectchangedValues
- contains all values for the attributes named in toBeChangedAttributes, which need to be casted to the right datatype before setting them in the Booking object- Throws:
java.lang.IllegalArgumentException
- if the amount of arguments is too few for the amount of values to be changedjava.lang.IllegalCallerException
- if the employee does not inherit the role BookingManager
-
deleteBooking
public void deleteBooking(int bookingNo) throws java.lang.IllegalCallerExceptionImplementation of the Employee's ability to delete a Booking by its booking number does not use the remove method of the ArrayList to keep the relation of the position of a booking in Bookings to its bookingNo. Role BookingManager is needed.
- Parameters:
bookingNo
- Number of the Booking as well as its position inside Bookings- Throws:
java.lang.IllegalCallerException
- if the employee does not inherit the role BookingManager
-
changeRoomDetails
public boolean changeRoomDetails(int roomNo, java.util.ArrayList<java.lang.String> toBeChangedAttributes, java.util.ArrayList<java.lang.Object> changedValues) throws java.lang.IllegalCallerExceptionImplementation of the Employee's ability to change attributes of a room to save details of real world changes to the room does not change the number of a room or its use case (hotel room or conference room). Role RoomAdministrator is needed.
- Parameters:
roomNo
- Number of the room which is to be changed; provides the index of the room inside RoomstoBeChangedAttributes
- contains all values named by string, that need to be changedchangedValues
- contains all changed Values, needs to be casted to the right datatype- Throws:
java.lang.IllegalCallerException
- if the employee does not inherit the role RoomAdministrator
-
createConferenceRoom
public ConferenceRoom createConferenceRoom(int roomNo, Room.Category category, int areaInSqrMetre, int maxAmountOfParticipants, int amountOfWhiteboards, int amountOfBeamer, boolean hasScreen, boolean hasComputer, boolean hasTV, float pricePerUnit) throws java.lang.IllegalCallerExceptionImplementation of the Employee's ability to create a conference room. Creates a new room according to the given details and adds it to the roomList. Role RoomAdministrator is needed.
- Parameters:
roomNo
- Number of the room, that is created according to real world; index of the rumber in Roomscategory
- category of the room, depending on if it is a hotel room (suite, single room, double room) or conference room (big group, small group)areaInSqrMetre
- area of the room in square metresmaxAmountOfParticipants
- maximal amount of people allowed in the room according to current corona guidelines, later depending on amount of seatsamountOfWhiteboards
- tells how many Whiteboards are in the roomamountOfBeamer
- tells how many beamers are in the roomhasScreen
- tells whether there is a screen for the presentation of datahasComputer
- tells whether there is a computer in the roomhasTV
- tells whether there is a TV in the room- Returns:
- ConferenceRoom created
- Throws:
java.lang.IllegalCallerException
- if the employee does not inherit the role RoomAdministrator
-
createHotelRoom
public HotelRoom createHotelRoom(int roomNo, Room.Category category, int areaInSqrMetre, int bedCount, boolean hasSpeedLAN, boolean hasTV, boolean hasKitchen, boolean hasCoffeemaker, float pricePerUnit) throws java.lang.IllegalCallerExceptionImplementation of the Employee's ability to create a hotel room. Creates a new room according to the given details and adds it to the roomList. Role RoomAdministrator is needed.
- Parameters:
roomNo
- Number of the room, that is created according to real world; index of the rumber in Roomscategory
- category of the room, depending on if it is a hotel room (suite, single room, double room) or conference room (big group, small group)areaInSqrMetre
- area of the room in square metresbedCount
- amount of beds in the hotel roomhasSpeedLAN
- tells if the room has a SpeedLan Connection avaiablehasTV
- tells if the room has a TVhasKitchen
- tells if there is a kitchen to cook in the roomhasCoffeemaker
- tells if there is a Coffeemaker in the room- Returns:
- HotelRoom created
- Throws:
java.lang.IllegalCallerException
- if the employee does not inherit the role RoomAdministrator
-
deleteRoom
public void deleteRoom(int roomNo) throws java.lang.IllegalCallerExceptionImplementation of the Employee's ability to delete a room entirely. Ensures that unsuable rooms are deleted from the Rooms and can not be used for bookings. Reasons could be a fusion of two or multiple rooms or the purpose of a room has changed entirely. Role RoomAdministrator is needed.
- Parameters:
roomNo
- number of the room to be deleted- Throws:
java.lang.IllegalCallerException
- if the employee does not inherit the role RoomAdministrator
-
findBooking
public java.util.ArrayList<Booking> findBooking(int BookingNo, int RoomNo, int empNo, DateFrame dateFrame, TimeFrame timeFrame, java.lang.String bookingDate, Room.Category roomCategory)Implementation of the Employee's ability to search for a booking by several parameters given. Will later be much more efficient if based on database actions. It is possible to search only by EmpNo to determine an Employee's work rate, to search only by bookingNo, which should always return only one booking and to search by a RoomNo and a dateframe and a timeframe, when the room should be used. In the last case there are used even further defined parameters like bookingDate or roomCategory, but only if given. Not all Parameters have to be set to use the function, not known information should be given with "null" or 0, depending on the data type.
- Parameters:
BookingNo
- number of the booking to be searched for as well as its position in BookingsRoomNo
- number of the room which is documented in the booking to be searched forempNo
- number of the employee that created the booking to be searched fordateFrame
- dateframe of the booking to be searched fortimeFrame
- timeframe of the booking to be searched forbookingDate
- date of the booking to be searched forroomCategory
- category of the room which is documented in the booking to be searched for- Returns:
- all resulting Booking that match the search criteria
-
showAllBookings
public java.lang.StringBuilder showAllBookings()The implementation of a Listing feature, to analyze all Bookings. For now the function does not need any arguments, later it will be further developed to change the given view by several aspects needed
- Returns:
- all Bookings inside Bookings
-
manageBookingRequests
public void manageBookingRequests() throws java.lang.IllegalCallerException, java.util.NoSuchElementExceptionThe implementation of an autonomous management of customer requests, based on whether or not a suitable room is free at the time given.
- Throws:
java.lang.IllegalCallerException
- in case of someone using the function without the BookingsManager Role and its inherited Rights to manage bookingsjava.util.NoSuchElementException
- if there is no room of the wanted category at all
-
createCustomer
public Customer createCustomer(java.lang.String firstName, java.lang.String lastName, java.lang.String streetName, java.lang.String streetNumber, java.lang.String postalCode, java.lang.String cityName, java.lang.String mailAddress, Customer.paymentMethods paymentMethod, java.lang.String iban) throws java.lang.IllegalCallerExceptionThe implementation of the Employee's ability to create a customer by given parameters. The customer will be added to an ArrayList
- Parameters:
firstName
- first name of the customerlastName
- last name of the customerstreetName
- name of street where the customer livesstreetNumber
- street number of the customerpostalCode
- postalcode of the customercityName
- name of the city where the customer livesmailAddress
- selected emailaddress by the customer for contactpaymentMethod
- selected paymentmethod of the customeriban
- optional paymentDataCredentials of the customer- Returns:
- Customer created
- Throws:
java.lang.IllegalCallerException
- in case of someone using the function without the CustomerRelationshipManager Role and its inherited rights to manage customers
-
changeCustomer
public boolean changeCustomer(int customerID, java.lang.String key, java.lang.String value) throws java.lang.IllegalCallerExceptionThe implementation of the Employee's ability to change a customer by given customerID and key and value of the new customers property.
- Parameters:
customerID
- id to find the target customer in customers ArrayListkey
- key of the property to be changedvalue
- new value of the property to be changed- Throws:
java.lang.IllegalCallerException
- in case of someone using the function without the CustomerRelationshipManager Role and its inherited rights to manage customers
-
deleteCustomer
public void deleteCustomer(int customerID) throws java.lang.IllegalCallerExceptionThe implementation of the Employee's ability to delete a customer from customers ArrayList by given customerID.
- Parameters:
customerID
- id to select the customer to be deleted- Throws:
java.lang.IllegalCallerException
- in case of someone using the function without the CustomerRelationshipManager Role and its inherited rights to manage customers
-
getEmpNo
public int getEmpNo() -
setEmpNo
public void setEmpNo(int empNo) -
getEmpName
public java.lang.String getEmpName() -
setEmpName
public void setEmpName(java.lang.String empName) -
getGivenRole
-
setGivenRole
-


We examine networks!
- cultivate frictionless ROI
- redefine compelling metrics
- visualize bricks-and-clicks communities
- transform extensible e-business
- synergize real-time functionalities
- orchestrate front-end channels
- cultivate proactive e-markets
- exploit ubiquitous content


The client client is requesting data from the Manually Annotated Sub-Corpus (MASC) v3.0.0 on your behalf.
This data is free to use for any purpose, including commercial uses. If you redistribute MASC data we ask that you give attribute to the American National Corpus (http://www.anc.org).
When citing MASC in research papers or other publications please use: citation needed.


Expression object for dense matrix-transpose dense matrix subtractions.The DMatTDMatSubExpr class represents the compile time expression for subtractions between a row-major dense matrix and a column-major dense matrix.
More...
#include <DMatTDMatSubExpr.h>
Inherits blaze::DenseMatrix< DMatTDMatSubExpr< MT1, MT2 >, false >, blaze::MatMatSubExpr, and blaze::Computation.
|
| enum | : bool { returnExpr = !IsTemporary<RN1>::value && !IsTemporary<RN2>::value
} |
| | Compilation switch for the selection of the subscript operator return type. More...
|
| |
| enum | : bool { useAssign = RequiresEvaluation<MT1>::value || RequiresEvaluation<MT2>::value || !returnExpr
} |
| | Compilation switch for the serial evaluation strategy of the subtraction expression. More...
|
| |
|
typedef ResultType_< MT1 > | RT1 |
| | Result type of the left-hand side dense matrix expression.
|
| |
|
typedef ResultType_< MT2 > | RT2 |
| | Result type of the right-hand side dense matrix expression.
|
| |
|
typedef ReturnType_< MT1 > | RN1 |
| | Return type of the left-hand side dense matrix expression.
|
| |
|
typedef ReturnType_< MT2 > | RN2 |
| | Return type of the right-hand side dense matrix expression.
|
| |
|
typedef CompositeType_< MT1 > | CT1 |
| | Composite type of the left-hand side dense matrix expression.
|
| |
|
typedef CompositeType_< MT2 > | CT2 |
| | Composite type of the right-hand side dense matrix expression.
|
| |
|
typedef SubExprTrait_< RN1, RN2 > | ExprReturnType |
| | Expression return type for the subscript operator.
|
| |
template<typename MT1, typename MT2>
class blaze::DMatTDMatSubExpr< MT1, MT2 >
Expression object for dense matrix-transpose dense matrix subtractions.
The DMatTDMatSubExpr class represents the compile time expression for subtractions between a row-major dense matrix and a column-major dense matrix.
§ anonymous enum
template<typename MT1, typename MT2>
Compilation switch for the selection of the subscript operator return type.
The returnExpr compile time constant expression is a compilation switch for the selection of the ReturnType. If either matrix operand returns a temporary vector or matrix, returnExpr will be set to false and the subscript operator will return it's result by value. Otherwise returnExpr will be set to true and the subscript operator may return it's result as an expression.
§ anonymous enum
template<typename MT1, typename MT2>
Compilation switch for the serial evaluation strategy of the subtraction expression.
The useAssign compile time constant expression represents a compilation switch for the serial evaluation strategy of the subtraction expression. In case either of the two dense matrix operands requires an intermediate evaluation or the subscript operator can only return by value, useAssign will be set to 1 and the subtraction expression will be evaluated via the assign function family. Otherwise useAssign will be set to 0 and the expression will be evaluated via the function call operator.
§ DMatTDMatSubExpr()
template<typename MT1, typename MT2>
Constructor for the DMatTDMatSubExpr class.
- Parameters
-
| lhs | The left-hand side operand of the subtraction expression. |
| rhs | The right-hand side operand of the subtraction expression. |
§ at()
template<typename MT1, typename MT2>
Checked access to the matrix elements.
- Parameters
-
| i | Access index for the row. The index has to be in the range . |
| j | Access index for the column. The index has to be in the range . |
- Returns
- The resulting value.
- Exceptions
-
| std::out_of_range | Invalid matrix access index. |
§ canAlias()
template<typename MT1, typename MT2>
template<typename T >
Returns whether the expression can alias with the given address alias.
- Parameters
-
| alias | The alias to be checked. |
- Returns
- true in case the expression can alias, false otherwise.
§ canSMPAssign()
template<typename MT1, typename MT2>
Returns whether the expression can be used in SMP assignments.
- Returns
- true in case the expression can be used in SMP assignments, false if not.
§ columns()
template<typename MT1, typename MT2>
Returns the current number of columns of the matrix.
- Returns
- The number of columns of the matrix.
§ isAliased()
template<typename MT1, typename MT2>
template<typename T >
Returns whether the expression is aliased with the given address alias.
- Parameters
-
| alias | The alias to be checked. |
- Returns
- true in case an alias effect is detected, false otherwise.
§ isAligned()
template<typename MT1, typename MT2>
Returns whether the operands of the expression are properly aligned in memory.
- Returns
- true in case the operands are aligned, false if not.
§ leftOperand()
template<typename MT1, typename MT2>
Returns the left-hand side dense matrix operand.
- Returns
- The left-hand side dense matrix operand.
§ operator()()
template<typename MT1, typename MT2>
2D-access to the matrix elements.
- Parameters
-
| i | Access index for the row. The index has to be in the range . |
| j | Access index for the column. The index has to be in the range . |
- Returns
- The resulting value.
§ operator~() [1/2]
template<typename MT, bool SO>
Conversion operator for non-constant matrices.
- Returns
- Reference of the actual type of the matrix.
§ operator~() [2/2]
template<typename MT, bool SO>
Conversion operator for constant matrices.
- Returns
- Constant reference of the actual type of the matrix.
§ rightOperand()
template<typename MT1, typename MT2>
Returns the right-hand side transpose dense matrix operand.
- Returns
- The right-hand side transpose dense matrix operand.
§ rows()
template<typename MT1, typename MT2>
Returns the current number of rows of the matrix.
- Returns
- The number of rows of the matrix.
The documentation for this class was generated from the following file:


How to follow conversations on Twitter
After reading Dave’s post about Twitter being the new Facebook yesterday, I decided to give Digsby a go. (I’d heard of it previously, but I was semi-scared off by all the twittermania – it’s a bit like marmite).
Since I was only following a few tweeters there wasn’t of a flow – so I added a couple more higher profile tweeters, like Jeff Atwood’s Coding Horror.
This morning Jeff tweeted:
I hate #region so much.
— Jeff Atwood (@codinghorror) May 15, 2008
I quite like #region in VS.NET, (it makes my code look/feel tidy). I was curious to why Jeff had a problem with it, so I tempted to reply to his tweet. But I stopped – thinking it was a bit of a fan-boy thing to do. Also I’m sure someone else would have asked the same question… which got me thinking how do you follow a conversation on Twitter?
I came across Summize (a search engine for Twitter) the other day, so tried that to see if anyone mentions #region or @codinghorror – which they do, but it’s a tad disjointed. I couldn’t follow a conversation.
So I turned to my old friend Google (how to follow conversations on twitter), and found Quotably!
Now I can follow the conversation: http://quotably.com/codinghorror/statuses/811735028
Quotably is powered by Summize, with some extra jiggery-pokery (and human intervention).
Update (03/01/2009): Quotably has now closed it’s doors. If anyone knows of a good alternative resource, please let me know in the comments.


A drone that can transform into other vehicles
Tech Tools: This new modular robot is designed to teach children about coding
by Ciara O'BrienMakeblock Airblock Transformable Drone (€123)
Drones are fun; the Makeblock Airblock Transformable Drone is even more fun because you can turn it into almost anything you want. Well, if anything you want is a hovercraft, a flying drone, a spinner, a car, or something along those lines.
Designed to teach children about coding, the drone is modular, fitting together with magnets, so it can easily be taken apart and put back together in a new form. It is controlled via Bluetooth through your smartphone, with a coding app that allows children to programme instructions for their robot, and then see them carried out.
Amazon.co.uk


Glossary¶
The Glossary provides short definitions of MNE-Python-specific vocabulary and general neuroimaging concepts. If you think a term is missing, please consider creating a new issue or opening a pull request to add it.
- annotations
An annotation is defined by an onset, a duration, and a string description. It can contain information about the experiments, but also details on signals marked by a human: bad data segments, sleep scores, sleep events (spindles, K-complex) etc. An
Annotations
object is a container of multiple annotations. SeeAnnotations
page for the API of the corresponding object class and Function Annotations for a tutorial on how to manipulate such objects.- BEM
BEM is the acronym for boundary element method or boundary element model. Both are related to the forward model computation and more specifically the definion of the conductor model. The boundary element model consists of surfaces such as the inner skull, outer skull and outer skin (a.k.a. scalp) that define compartments of tissues of the head. You can compute the BEM surfaces with
mne.bem.make_watershed_bem()
ormne.bem.make_flash_bem()
. See Head model and forward computation for usage demo.- channels
Channels refer to MEG sensors, EEG electrodes or any extra electrode or sensor such as EOG, ECG or sEEG, ECoG etc. Channels usually have a type, such as gradiometer, and a unit, such as Tesla/Meter that is used in the code base, e.g. for plotting.
- dipole
- epochs
Epochs (sometimes called “trials” in other software packages) are equal-length spans of data extracted from raw continuous data. Usually, epochs are extracted around stimulus events or subject responses, though sometimes sequential or overlapping epochs are extracted (e.g., for analysis of resting-state activity). See
Epochs
for the API of the corresponding object class, and The Epochs data structure: epoched data for a narrative overview.- equivalent current dipole
An equivalent current dipole (ECD) is an approximate representation of post-synaptic activity in a small region of cortex. The intracellular currents that give rise to measurable EEG/MEG signals are thought to originate in populations of cortical pyramidal neurons aligned perpendicularly to the cortical surface. Because the length of such current sources is very small relative to the distance between the cortex and the EEG/MEG sensors, the fields measured by the techniques are well-approximated by (i.e., “equivalent” to) fields generated by idealized point sources (dipoles) located on the cortical surface.
- events
Events correspond to specific time points in raw data; e.g., triggers, experimental condition events, etc. MNE represents events with integers that are stored in numpy arrays of shape (n_events, 3). Such arrays are classically obtained from a trigger channel, also referred to as stim channel.
- evoked
Evoked data are obtained by averaging epochs. Typically, an evoked object is constructed for each subject and each condition, but it can also be obtained by averaging a list of evoked over different subjects. See
EvokedArray
for the API of the corresponding object class, and The Evoked data structure: evoked/averaged data for a narrative overview.- fiducial point
There are three fiducial (a.k.a. cardinal) points: the left preauricular point (LPA), the right preauricular point (RPA) and the nasion.
- first_samp
The
first_samp
attribute ofRaw
objects is an integer representing the number of time samples that passed between the onset of the hardware acquisition system and the time when data started to be recorded to disk. This approach to sample numbering is a peculiarity of VectorView MEG systems, but for consistency it is present in allRaw
objects regardless of the source of the data. In other words,first_samp
will be0
inRaw
objects loaded from non-VectorView data files.- forward solution
The forward solution (abbr.
fwd
) is a linear operator capturing the relationship between each dipole location in the source space and the corresponding field distribution measured by the sensors (AKA, the “lead field matrix”). Calculating a forward solution requires a conductivity model of the head, encapsulating the geometry and electrical conductivity of the different tissue compartments (see boundary element model andmne.bem.ConductorModel
).- GFP
Global Field Power (abbr.
GFP
) is a measure of the (non-)uniformity of the electromagnetic field at the sensors. It is typically calculated as the standard deviation of the sensor values at each time point; thus it is a one-dimensional time series capturing the spatial variability of the signal across sensor locations.-  Each coil emits a sinusoidal signal of a different frequency, which is picked up by the MEG sensors and can be used to infer the head position. With cHPI, the sinusoidal signals are typically set at frequencies above any neural signal of interest, and thus can be removed after head position correction via low-pass filtering.- info
Also called
measurement info
, it is a collection of metadata regarding a Raw, Epochs or Evoked object; e.g., channel locations and types, sampling frequency, preprocessing history such as filters … See The Info data structure for a narrative overview.- inverse operator
The inverse operator is an \(M \times N\) matrix (\(M\) source locations by \(N\) sensors) that, when applied to the sensor signals, yields estimates of the brain activity that gave rise to the observed sensor signals. Inverse operators are available for the linear inverse methods MNE, dSPM, sLORETA and eLORETA.
- label
A
Label
refers to a region in the cortex, also often called a region of interest (ROI) in the literature.- layout
A
Layout
gives sensor positions in 2 dimensions (defined byx
,y
,width
, andheight
values for each sensor). It is primarily used for illustrative purposes (i.e., making diagrams of approximate sensor positions in top-down diagrams of the head, so-called topographies or topomaps).- montage
EEG channel names and the relative positions of the sensor w.r.t. the scalp. While layout are 2D locations, montages give 3D locations. A montage can also contain locations for HPI points, fiducial points, or extra head shape points. See
DigMontage
for the API of the corresponding object class.- morphing
Morphing refers to the operation of transferring source estimates from one anatomy to another. It is commonly referred as realignment in fMRI literature. This operation is necessary for group studies (to get the data in a common space for statistical analysis). See Morphing and averaging source estimates for more details.
- pick
An integer that is the index of a channel in the measurement info. It allows to obtain the information on a channel in the list of channels available in
info['chs']
.- projector
A projector (abbr.
proj
), also referred to as Signal Space Projection (SSP), defines a linear operation applied spatially to EEG or MEG data. You can see this as a matrix multiplication that reduces the rank of the data by projecting it to a lower dimensional subspace. Such a projection operator is applied to both the data and the forward operator for source localization. Note that EEG average referencing can be done using such a projection operator. It is stored in the measurement info ininfo['projs']
.- raw
It corresponds to continuous data (preprocessed or not). One typically manipulates raw data when reading recordings in a file on disk. See
RawArray
for the API of the corresponding object class, and The Raw data structure: continuous data for a narrative overview.- selection (abbr. sel)
A set of picks. E.g., all sensors included in a Region of Interest.
- source estimates (abbr.
stc
) Source estimates, commonly referred to as STC (Source Time Courses), are obtained from source localization methods, such as dSPM, sLORETA, LCMV or MxNE. It contains the amplitudes of the sources over time. An STC object only stores the amplitudes of activations but not the locations of the sources. To get access to the locations you need to have the source space used to compute the forward operator. See
SourceEstimate
,VolSourceEstimate
VectorSourceEstimate
,MixedSourceEstimate
, for the API of the corresponding object classes.- source space
A source space (abbr.
src
) specifies where in the brain one wants to estimate the source amplitudes. It corresponds to locations of a set of candidate equivalent current dipoles (ECD). MNE mostly works with source spaces defined on the cortical surfaces estimated by FreeSurfer from a T1-weighted MRI image. See Head model and forward computation to read on how to compute a forward operator on a source space. SeeSourceSpaces
for the API of the corresponding object class.- stim channel
A stim channel, a.k.a. trigger channel, is a channel that encodes events during the recording. It is typically a channel that is usually zero and takes positive values when something happens (such as the onset of a stimulus, or a subject response). Stim channels are often prefixed with
STI
to distinguish them from other channel types. See What is a STIM channel? for more details.- trans
A coordinate frame affine transformation, usually between the Neuromag head coordinate frame and the MRI Surface RAS coordinate frame used by Freesurfer.


We currently off a wide variety of devices; from the beginner to the experienced vaper. We have beginner starter kits that will give you all you need to begin vaping as well as variable/temperature controlled devices to make your vaping experience brand new. At Shadetree Vapes, we offer RA Mods series and parallel boxes to that vaper looking to get the perfect dripping experience. From single coil tanks to sub ohm.. we have them all. If a dripper or rebuildable tank is what you need we have that as well.
Here at Shadetree, we do our best to offer a wide variety of eliquids. We have those with and without nicotine as well as good quality, low cost juice. We also stock many different brands of higher quality premium lines with many different flavors to choose from. Currently we stock over 175 flavors with many different nicotine strengths. We are always expanding and looking to keep our stock fresh and new. If we do not have something that you are looking for, just ask we may be able to special order it for you!
One of the most popular styles of e-cigs are the pen style with a cartomizer attached. The cartomizer can be prefilled with the vapor liquid or there are those that are empty and you can fill with your own. Most light smokers prefer this method because it is most similiar to a cigarette, with the same shape and size, and is easily used. The cartomizer is usually equal to about a pack of regular cigarettes and is easily changed out for a new one with the unscrewing of the top. The battery can be rechargeable or disposable. We offer the rechargeable kind. These are activated simply by "dragging" on tip just like a cigarette; the end lights up to mock the firey end of a cigarette. The vapor is inhaled and released. they come in two flavors, tobacco and menthol.
The other alternative is an e-cig with a tank that is used with what is called "e-juice". These are very similar in use as the pen style system but work with voltage, liquid and more directly with taste and satisfaction. This tends to be the choice for the bigger smoker or the person who enjoys the vaping of different flavors. The way the system works is there is a tank with an atomizer in it. There is a wick system that soaks the juice and a coil that heats up the wick to produce the vapor. The heating coil is activated by the pressing of the button on the battery. This is a large world in vaping and is upgradeable, modifiable and immensely huge. You can use all different tanks and there are various battery strengths and styles available to match almost any need.  The batteries in the E-Juice kits are also longer
We Would Love To Hear From You!!!
Electronic cigarettes may contain nicotine. Nicotine is know to be addictive, and in concentration, a dangerous poison. Misuse can result in serious health risks or even death. Nicotine products should not be used by people under the age of 18, or people with severe kidney disease, heart desease and related heart conditions, overactive thyroid gland, diabetes, phaeochromocytoma, inflammation of the esophagus, inflammation of the lining of the stomach, stomach ulcer, duodenal ulcer, skin problmes, long term throat problems, difficulty breathing because of bronchitis, emphysema or asthma, or if pregnant or breast feeding. Do not ingest or allow nicotine to soak into skin. Keep out of reach of children and pets, Use only as directed. The buyer of this product accepts all risks and liabilities associated with nicotine handling and consumption. This product has not been evaluated by the FDA - use at your own risk.
Electronic cigarettes contain Li-ion battery cells which can explode or burst into flame if used improperly. Do not disassemble, punture, cut, crush, short circuit, incinerate, recharge the disposable cells, or expose to water, fire or high temperatures. Rechargeable batteries should be charged in a fire-proof container and checked after charging and before use. Never charge batteries unattended. Only use appropriate chargers, do not mix chargers. If unsure of what charger to use, please contact Shadetree Vapes via email or phone listed on the contact us page. By purchasing these products, the buyer assumes all risks and liabilities associated with lithium batteries. It is your responsibility (the customer) to understand the dangers, as well as the proper procedures for handling and disposing of li-ion based battery cells.
Blueberry - Blueberries picked right off the bush.
Banana Blitz – Creamy banana with a hint of pastry undertones.
Berry Blast – Take multiple berry flavors roll them into one and then vape them.
Black Diamond – This is a mild Turkish tobacco blend with sweet notes throughout. Great sweet tobacco.
Caramel Coconut Cookie – If you love the famous girl scout cookie you will love this vape.
Creme de Menthol - Built off the popular Creme De Menthe flavor, this offers a wonderful sweet menthol experience. Just think of chocolate, mint candy.
Dakota - The full flavored tobacco blend offers that "black and mild" taste. You can even taste the wood tip
Dark Chocolate – Delicious semi-sweet chocolate blend put into a vape.
FrostBite – An amazing blend of pure menthol sprinkled with peppermint and spearmint. Refreshing vape. No tobacco at all.
Grape Vape - An explosion of grape flavor all up in your vape.
Hybrid - A tobacco based menthol flavor; very similar to a popular traditional full flavor menthol cigarette.
Krypton - A sweet, creamy menthol that is great as a solid all day vape without too much overkill or wonderful to mix with any juice to give a menthol taste.
Limelight - Sweet and tart key lime blend with exceptional citrus flavors.
Spearmint – A wonderful vape of pure spearmint. Crisp, clean vape that you can enjoy all day.
Summer Peach – Sliced peaches in a tank.
Wild Watermelon – Lip-smaking good watermelon flavor .
555 Lite - Like 555 only with a less punchy tobacco flavor.
555 -Is to the tobacco leaf what Sinatra is to the Sands, with just a touch of something else.
Berry Bliss - Straw blue rasp. Berry.
Blueberry Fest - Tastes like blueberries.
Bubblegum Chill - Bubblegum with a touch of menthol
Bubblegum -Yum yum bubble gum
Café Filbert – hazelnut coffee.
Cinnamon Arbalest - Tastes like a cinnamon-tipped arrow shot from a medieval crossbow
Cinnamon Whiskey - Just the like famous Fireball whiskey; this is it!
CocoStrawBango Smoothie - StrawBango but with coconut. Feel free to vape this with a frozen drink.
Cola - Refreshing Cola.
Cookie Monster - a chocolate fudge cookie with chocolate chips.
Cotton Candy - Cottony. Candy-y. Just what you would expect.
Fire and Ice - Cinnamon flavor on the inhale, cool menthol on the exhale
French Vanilla - Sacre bleu! It tastes like vanilla, only Frencher.
Fruit Punch - Your favorite punch!
Funk Berry - Just think how funky that Captain would be with berries.

Hawaiian Sunrise - your favorite polynesian drink; hints of orange, pineapple and coconut.
Hummingbird Cake - major notes are pineapple, banana and pecan.
Illusion - Oh my .. is that a light flavored tobacco taste or just a yummy vape?
Jamaican Sunset - Amazing jamaican rum flavors finished off with tropical fruits.
Jive Juice - Crisp, sweet orange juice squeezed right into your tank.
Loco Tobako - Made from three tobacco flavors and other good stuff!
Menthol - If you like menthol, you'll like this. Strong!
Menthol Chill - Menthol but a little less strong than the original.
Mixed Fruit - think Juicy Fruit gum!
Mountain Dude - Tastes just like Mountain Dew with a good throat hit
Mousse au Chocolate - A fluffy chocolate dessert with a hint of caramel that is simply delicious.
Our Why 5 - French, German, Italian recipes in one fabulous mélange. Overtones of Amaretto.
Peachberry Sour - Peach & Blueberry with a sour twist.
Pebbles - Straight out of the bowl in the morning.. All fruity and stuff.
Pina Colada – think of that wonderful frozen concotion
Pineapple - Golden delicious sweet fruit!
Raging Bull - Raging Bull is all about the energy; this is the vape with no energy
Root Beer Float - Tastes just like a root beer float!
RY4 - Is already a classic. Tobacco with caramel, English toffee, and marshmallow.
Skiddles - That delightful rainbow of sweet flavor all in a great juice!
Strawberry - Decadant, delicious strawberries.
Strawberry Cheesecake - Garden strawberries and cheesecake. Double yum.
Strawpearydoo - The amazing combination of strawberry, pear and honeydew
Summer Fruit - a tasty blend of peaches, blueberries and raspberries
Sweet Honey Tobacco - Just as the name suggests...
Vanilla Cupcake - sweet creaming cake flavor topped off with a delightful vanilla icing.
Watermelon Candy - Just like those melony-sweet pink candies.
Watermelon Chill - This is a mentholated version of Watermelon Candy.
Wintergreen - cool, refreshing, icey.
Unicorn Milk - Strawberry Custard flavor that is creamy and smooth as eating a strawberry shortcake.
Sugar Drizzle - A sugary cinnamon taste that is paired with a smooth milky sweetness close to a cinnamon roll.
Mega Melons - Blend of Cantaloupes, Mangos, and Papaya that is designed to make your mouthwatering for more amazing melons flavors.
Boss Reserve - A golden honey graham cereal with roasted nut clusters. Drenched in creamy milk & layered with sliced bananas. (only available in 30 ml)
Bird Brains – Amazing cereal and milk flavor. Think about those wonderful colored o’s of cereal… all fruity and such!
Apple - a warm fresh and sweet red apple.
Bahama Blizzard - It is a perfect paring of orange, cranberry and peach which is blended and frozen with cool sweet menthol.
Cherry on Top - Sweet ripe red cherry flavor mixed with fluffy and sweet cream notes.
Grape Escape - The perfect grape flavor! Sure to satisfy grape candy lovers while preserving true fruit flavor!
Heartland - fresh, sweet berry overtone caressed with hints of ripe melon.
Maui - It will take your mind right to the beach with a load of ripe pineapple and sweet mango
Peach Lemonade - Sweet and tart! The perfect vape on a hot summers day! If you are a lemonade fan this is a must!
Pom Beach - An attractive undertone of pomegranate laced with a sweet ripe strawberry will certainly satisfy your taste-buds.
Southern Freeze - Peaches dangling on the tree and strawberries on the vine. Ripe, juicy, and plump covered with a thin layer of icy freshness
Strawanna Smoothie - Fresh ripe bananas and strawberries mixed with cream to create the best blended smoothie you will ever vape!
Stripes - A mixture of sweet candy fruits with the slightest hint of refreshing menthol
DRAGONAIRE - An incredibly lively and powerful flavor. It starts with a combination of juicy cantaloupe and dragon fruit notes on the initial inhale. A Menthol flavor leaves a chilly feeling on the exhale along with a sweet taste of watermelon. The Menthol and fruit flavors are paired to give a great sensation.
Illuminati - Blood Orange Pineapple Strawberry
Subliminal - Sweet and Sour Razzmatazz Candy
Wild Fire - Toasted Almond and Mezzaluna Cookie
Bettie White - One of our original flavors and still a best seller, Bettie White has a pomegranate base and subtle hints of apple.
Jon Wayne – This juice is proof that a really good vape is worth the wait. Uncle Junk spent months perfecting this blend of savory and sweet tobacco flavors.
Monica’s Eyes – “Monica” gave this juice a ten out of ten in its testing phase. Monica’s Eyes is a tasty mix of cantaloupe, kiwi, and other delicious fruits.
Banana Chip - The taste of dried banana chips, the popular snack sold in many Asian markets
Ez Duz It - A mixture of strawberry and watermelon 90% VG/10% PG
Grape Drank - The flavor of grape skittles and grape soda 85% VG/15% PG
Jungle Fever - The taste of pineapple, mango and other citrus flavors
Mandingo - Banana cinnamon nut bread 60% VG/40% PG
Ménage à Trois - A sweet raspberry Crème Brûlée Cheesecake 60% vg/40% PG
Peach Fuzz- Peaches & Cream. 85% VG/15% PG
Rise - Lychee & mango. 60% VG/40% PG
Slurricane - A tropical blend of peach, papaya, and guava 90% VG/10% PG
Swamp Thang - Sour apple jolly rancher 85% VG/15% PG
Blue Razz - This premium vapor liquid blends a layer of blue raspberry hard candy over a classic pink bubblegum core. 70% VG | 30% PG
StrawCherry - This premium vapor liquid blends a layer of sweet strawberry and sour cherry hard candies over a classic pink bubblegum core. 70% VG | 30% PG
Green Apple – This premium vapor liquid blends a layer of candied and fresh apple hard candies over a classic pink bubblegum core. 70% VG|30 % PG.
Coconut Thai - This juice was inspired by the exotic flavors from the distant shores of Thailand. The first flavor is that of the smooth coconut, rich and slightly sweet followed by after notes of fresh thai basil and bright lemongrass
Honeysuckle Apple - Launched in the spring of 2015, we are excited to offer our customers this handcrafted blend of light, sweet, bright and full flavoring. It may make one nostalgic for the changing weather, yet it is flavor you will crave all year round.
Key Lime Cookie - This inspired Joose has wonderful sweet/tart notes of key lime, commingled with the flavor of warm baked cookies. Delicious and uniquely crafted for everyone to enjoy.
Monkey Snack - A delicious pairing of rich, creamy peanut butter and sweet, velvety banana. This Joose is sure to invoke wonderful memories and dance on your taste buds.
VCT - This sophisticated joose is sure to leave you desiring more. Sweet and sexy vanilla custard up front, with a rich finish tasting of fine tobacco and a hint of toasted almond. Aimed to please the novice, or the distinguished smoker.
Caramel Corpse - Dark, Creamy Carved Up Chocolate Caramel Controlling My Mind
Rainbow Sherbert in the Dark - No sign of the morning coming. Citrus, berry, and lime. Like a Rainbow in the Dark.
Yig - Where Yig doth tread, no man tread tomorrow. Black Currant harvest of oatmeal cookie and custard.
Lemon Pound Cake - This confectionary delight consists of zesty, tangy lemons infused into our classic buttery pound cake.
Mango Pound Cake - MPC is an irresistible combination of our world famous Philippine Mango baked into a fresh-from- the-oven Pound Cake
Strawberry Pound Cake - Fresh out the oven from your mom’s kitchen comes our delicious Strawberry Pound Cake E-Juice. We have successfully paired the perfect mix of natural strawberries and our classic pound cake to throw your taste buds
in a whirlwind of flavor.
Artemis - 65%VG/35%PG - Artemis is a berry cobbler flavored e-juice with a delicate blend of subtle berry hints mingled with the baked crust traditional to cobblers, mixed together into what one might describe as that of liquid gold.
Athena – 65%VG/35%PG - Our Athena eliquid is a delicious blend of sweet and sour apples featuring subtle flavor on inhalation with a lingering aftertaste that intertwines the sweetness of a red apple with the tartness of a green apple, producing an aroma you won’t soon forget.
Colossus - 65%VG/35%PG - Our Colossus premium eLiquid is a smooth and sweet vanilla custard. The subtle flavor combinations we use in our formula result in a satisfying pull, leaving a great taste on exhale without being overbearing
Eros - 65%VG/35%PG - Let the God of Lust consume you; One of our top sellers is an exotic blend succulent cranberry & citrus flavors which create a flavorful vape to seduce your senses. Caught in the throws of passionate sex on the beach, you will be left to wonder where Eros has been all your life.
Hades – 65%VG/35%PG -Experience warmth once reserved for those sleeping 6 feet under. The mellowness of roasted java beans mingles with sweet mocha and subtle nuttiness to provide a rich and lasting flavor that coffee fans are sure to love.
Poseidon - 65%VG/35%PG - Poseidon delivers a crisp, delicious flavor combination bringing together elements from some of the most succulent fruits and melons known to man. This complex fruit and melon medley transforms from inhale to exhale, embodying the crispness of the sea - a true representation of Poseidon's domain.
Berry Sour - Blueberry Sour Candy
Watermelon Sour - Watermelon Sour Candy.
Nerdz - Those tiny candies on those tiny boxes sure did pack a tangy punch, and so does Nerdz from R & D Creations, a perfect replica of those wee tiny tangy citrus candies in e-liquid form.
 Strawberry kiwi pop rocks!
Mystery "?" Flavor - A tantalizing blend that will delight and intrigue the senses. Is that orange or apple? A faint hint of grape or perhaps a bit of lime....a throwback to the old Airheads Mystery flavors that will be sure to entertain.
Gummy Glu - Imagine all of your favorite sweet and sour gummy candies thrown into a blender..and then transformed into E liquid!
Blueberry Flapjacks - Enjoy a steaming plate of blueberry-infused flapjacks completed with powdered sugar, whipped ceam, and served fresh for the hungry vaper.
Strawberry Shortstack - Enjoy a steaming plate of blueberry-infused flapjacks completed with powdered sugar, whipped cream, and served fresh for the hungry vaper.
Apple Pancakes - Excite your taste buds with a delicious taste of pancakes topped with green apple, powdered sugar and whipped cream.
Raging Donut - A fresh strawberry coated glazed donut topped with crispy fruity cereal. The sweet vape treat of Raging Donut gives you a donut on the inhale with notes of strawberry frosting and fruity cereal on the exhale. It's a yummy all day vape!
Mr. Taffy - That explosion of your favorite candy! A combination of Cherry, Strawberry and Citrus Orange. This juice can be vaped all day! 80% VG
Caramel Apple Drop - Let your lips pucker to the delightful flavor of a tangy apple pop glazed with a candied layer of rich artisan’s caramel. 70% VG
Artisan Vanilla - A clean vanilla flavor that's not oily, smoky, or filled with extras, it's a pure vanilla vape at any temperature.
Blueberry Boss - A clear and sweet blueberry fused with a heavy dairy cream that grows stronger with higher temperatures. You can expect just a touch of tartness at high temperatures, and much more at lower temperatures.
Crucible Cream - A warm and sweet marriage of strawberries and cream that gives you more strawberry at lower temps, and heavier, thicker cream flavor at higher temps.
Firebrick - A sweet and creamy Cinnamon with just enough heat to glow without melting.
Georgia Striker – A Peach flavor so sweet and juicy, it doesn't even need the tea to complete it: Pure, Sweet, and Refreshing.
Jacked Apple - Flame seared harvest apple with a smoky touch of cinnamon and graham. We've Jacked up the flavor to satisfy even the most die hard Vapesmith. When the temperature goes up, the heat goes up.
Melon Quench - A juicy, wet watermelon flavor that stays light even at high heat.
Molten Berry - It's a sweet raspberry delight that carries a light tartness at low heat, and turns mouth wateringly sweet at higher temperatures.
Smith’s Apple - A clean and sweet Grannysmith Apple with just the right amount of tart to balance the sweet. Want more sweet? Just turn up the heat.
Tempered Citrus - A blend of juicy sweet orange and a dash of cranberry flavor complimented by a light Graham Cracker Crumble.
Glazed - A warm right out-the-oven donut, topped with sugary glaze.
Smores - Rich graham cracker sandwich with warm marshmallow and smooth chocolate
in the center.
Le Blanc - Inspired by mango Bellini's of summer on the beaches of Marseille, and the frigid winters of the French Alps, Le Blanc is a marriage of sensual mango, coconut and vanilla, accentuate with frosty mint ice. 70% VG
Bazooka Sour Straws perfectly emulates those chewy,
sweet strips with sour crystals.
Blue Raspberry - A sour blue raspberry strip coated with sugar.
Green Apple - The tart sweetness of a green apple licorice topped strip with sugar.
Strawberry - Sweet and sour strawberry licorice.
Watermelon - Juicy watermelon topped with sweet and sour sugar.


This is the model class for table "survey_question".
The followings are the available columns in table 'survey_question':
integer $id
integer $survey_ID
integer $order_number
integer $type
string $text
The followings are the available model relations:
SurveyAnswer[] $surveyAnswers
Survey $survey
SurveyResponse[] $surveyResponses
Located in /protected/models/SurveyQuestion.php (line 26)
CActiveRecord | --Model | --SurveyQuestion
Returns the static model of the specified AR class.
Please note that you should have this exact method in all your CActiveRecord descendants!
Event that is fired after the model is initialized.
This function generates and returns a unique number for this model.
Retrieves a list of models based on the current search/filter conditions.
Typical usecase:
This function translates the type choice into it's string equivalent.
Inherited From Model
Model::generate_unique_token()
Documentation generated on Fri, 06 Dec 2013 21:27:55 +0100 by phpDocumentor 1.4.4


#include <opencv2/gapi/own/mat.hpp>
|
| | Mat ()=default |
| |
| | Mat (int _rows, int _cols, int _type, void *_data, size_t _step=AUTO_STEP) |
| |
| | Mat (Mat const &src, const Rect &roi) |
| |
| | Mat (Mat const &src)=default |
| |
| | Mat (Mat &&src)=default |
| |
| int | channels () const |
| | Returns the number of matrix channels. More...
|
| |
| void | copyTo (Mat &dst) const |
| | Copies the matrix to another one. More...
|
| |
| void | create (int _rows, int _cols, int _type) |
| |
| void | create (Size _size, int _type) |
| |
| int | depth () const |
| | Returns the depth of a matrix element. More...
|
| |
| size_t | elemSize () const |
| | Returns the matrix element size in bytes. More...
|
| |
| bool | empty () const |
| | Returns true if the array has no elements. More...
|
| |
| Mat | operator() (const Rect &roi) const |
| |
| Mat & | operator= (Mat const &src)=default |
| |
| Mat & | operator= (Mat &&src)=default |
| |
| Mat & | operator= (const Scalar &s) |
| | Sets all or some of the array elements to the specified value. More...
|
| |
| uchar * | ptr (int row, int col=0) |
| | Returns a pointer to the specified matrix row. More...
|
| |
| const uchar * | ptr (int row, int col=0) const |
| |
| size_t | total () const |
| | Returns the total number of array elements. More...
|
| |
| int | type () const |
| | Returns the type of a matrix element. More...
|
| |
◆ Mat() [1/5]
| cv::gapi::own::Mat::Mat |
( |
| ) |
|
|
default |
◆ Mat() [2/5]
| cv::gapi::own::Mat::Mat |
( |
int |
_rows, |
|
|
int |
_cols, |
|
|
int |
_type, |
|
|
void * |
_data, |
|
|
size_t |
_step = AUTO_STEP |
|
) |
| |
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
- Parameters
-
| _rows | Number of rows in a 2D array. |
| _cols | Number of columns in a 2D array. |
| _type | Array type. Use CV_8UC1, ..., CV_64FC4 to create 1-4 channel matrices, or CV_8UC(n), ..., CV_64FC(n) to create multi-channel (up to CV_CN_MAX channels) matrices. |
| _data | Pointer to the user data. Matrix constructors that take data and step parameters do not allocate matrix data. Instead, they just initialize the matrix header that points to the specified data, which means that no data is copied. This operation is very efficient and can be used to process external data using OpenCV functions. The external data is not automatically deallocated, so you should take care of it. |
| _step | Number of bytes each matrix row occupies. The value should include the padding bytes at the end of each row, if any. If the parameter is missing (set to AUTO_STEP ), no padding is assumed and the actual step is calculated as cols*elemSize(). See Mat::elemSize. |
◆ Mat() [3/5]
| cv::gapi::own::Mat::Mat |
( |
Mat const & |
src, |
|
|
const Rect & |
roi |
|
) |
| |
|
inline |
◆ Mat() [4/5]
| cv::gapi::own::Mat::Mat |
( |
Mat const & |
src | ) |
|
|
default |
◆ Mat() [5/5]
| cv::gapi::own::Mat::Mat |
( |
Mat && |
src | ) |
|
|
default |
◆ channels()
| int cv::gapi::own::Mat::channels |
( |
| ) |
const |
|
inline |
Returns the number of matrix channels.
The method returns the number of matrix channels.
◆ copyTo()
| void cv::gapi::own::Mat::copyTo |
( |
Mat & |
dst | ) |
const |
|
inline |
Copies the matrix to another one.
The method copies the matrix data to another matrix. Before copying the data, the method invokes :
m.create(this->size(), this->
type());
so that the destination matrix is reallocated if needed. While m.copyTo(m); works flawlessly, the function does not handle the case of a partial overlap between the source and the destination matrices.
◆ create() [1/2]
| void cv::gapi::own::Mat::create |
( |
int |
_rows, |
|
|
int |
_cols, |
|
|
int |
_type |
|
) |
| |
|
inline |
- Parameters
-
| _rows | New number of rows. |
| _cols | New number of columns. |
| _type | New matrix type. |
◆ create() [2/2]
| void cv::gapi::own::Mat::create |
( |
Size |
_size, |
|
|
int |
_type |
|
) |
| |
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
- Parameters
-
| _size | Alternative new matrix size specification: Size(cols, rows) |
| _type | New matrix type. |
◆ depth()
| int cv::gapi::own::Mat::depth |
( |
| ) |
const |
|
inline |
Returns the depth of a matrix element.
The method returns the identifier of the matrix element depth (the type of each individual channel). For example, for a 16-bit signed element array, the method returns CV_16S . A complete list of matrix types contains the following values:
- CV_8U - 8-bit unsigned integers ( 0..255 )
- CV_8S - 8-bit signed integers ( -128..127 )
- CV_16U - 16-bit unsigned integers ( 0..65535 )
- CV_16S - 16-bit signed integers ( -32768..32767 )
- CV_32S - 32-bit signed integers ( -2147483648..2147483647 )
- CV_32F - 32-bit floating-point numbers ( -FLT_MAX..FLT_MAX, INF, NAN )
- CV_64F - 64-bit floating-point numbers ( -DBL_MAX..DBL_MAX, INF, NAN )
◆ elemSize()
| size_t cv::gapi::own::Mat::elemSize |
( |
| ) |
const |
|
inline |
Returns the matrix element size in bytes.
The method returns the matrix element size in bytes. For example, if the matrix type is CV_16SC3 , the method returns 3*sizeof(short) or 6.
◆ empty()
| bool cv::gapi::own::Mat::empty |
( |
| ) |
const |
Returns true if the array has no elements.
The method returns true if Mat::total() is 0 or if Mat::data is NULL. Because of pop_back() and resize() methods M.total() == 0
does not imply that M.data == NULL
.
◆ operator()()
| Mat cv::gapi::own::Mat::operator() |
( |
const Rect & |
roi | ) |
const |
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
- Parameters
-
| roi | Extracted submatrix specified as a rectangle. |
◆ operator=() [1/3]
| Mat& cv::gapi::own::Mat::operator= |
( |
Mat const & |
src | ) |
|
|
default |
◆ operator=() [2/3]
| Mat& cv::gapi::own::Mat::operator= |
( |
Mat && |
src | ) |
|
|
default |
◆ operator=() [3/3]
| Mat& cv::gapi::own::Mat::operator= |
( |
const Scalar & |
s | ) |
|
|
inline |
Sets all or some of the array elements to the specified value.
- Parameters
-
| s | Assigned scalar converted to the actual array type. |
◆ ptr() [1/2]
| uchar* cv::gapi::own::Mat::ptr |
( |
int |
row, |
|
|
int |
col = 0 |
|
) |
| |
|
inline |
Returns a pointer to the specified matrix row.
The methods return uchar*
or typed pointer to the specified matrix row. See the sample in Mat::isContinuous to know how to use these methods.
- Parameters
-
| row | Index along the dimension 0 |
| col | Index along the dimension 1 |
◆ ptr() [2/2]
| const uchar* cv::gapi::own::Mat::ptr |
( |
int |
row, |
|
|
int |
col = 0 |
|
) |
| const |
|
inline |
This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
◆ total()
| size_t cv::gapi::own::Mat::total |
( |
| ) |
const |
|
inline |
Returns the total number of array elements.
The method returns the number of array elements (a number of pixels if the array represents an image).
◆ type()
| int cv::gapi::own::Mat::type |
( |
| ) |
const |
|
inline |
Returns the type of a matrix element.
The method returns a matrix element type. This is an identifier compatible with the CvMat type system, like CV_16SC3 or 16-bit signed 3-channel array, and so on.
The documentation for this class was generated from the following file: