Linear expressions and relations
[Direct modeling support]
Namespaces | |
| namespace | Gecode |
Gecode toplevel namespace | |
Functions | |
| LinIntExpr | Gecode::operator+ (int, const IntVar &) |
| Construct linear expression as sum of integer variable and integer. | |
| LinIntExpr | Gecode::operator+ (int, const BoolVar &) |
| Construct linear expression as sum of Boolean variable and integer. | |
| LinIntExpr | Gecode::operator+ (int, const LinIntExpr &) |
| Construct linear expression as sum of linear expression and integer. | |
| LinIntExpr | Gecode::operator+ (const IntVar &, int) |
| Construct linear expression as sum of integer variable and integer. | |
| LinIntExpr | Gecode::operator+ (const BoolVar &, int) |
| Construct linear expression as sum of Boolean variable and integer. | |
| LinIntExpr | Gecode::operator+ (const LinIntExpr &, int) |
| Construct linear expression as sum of linear expression and integer. | |
| LinIntExpr | Gecode::operator+ (const IntVar &, const IntVar &) |
| Construct linear expression as sum of integer variables. | |
| LinIntExpr | Gecode::operator+ (const IntVar &, const BoolVar &) |
| Construct linear expression as sum of integer and Boolean variable. | |
| LinIntExpr | Gecode::operator+ (const BoolVar &, const IntVar &) |
| Construct linear expression as sum of Boolean and integer variable. | |
| LinIntExpr | Gecode::operator+ (const BoolVar &, const BoolVar &) |
| Construct linear expression as sum of Boolean variables. | |
| LinIntExpr | Gecode::operator+ (const IntVar &, const LinIntExpr &) |
| Construct linear expression as sum of integer variable and linear expression. | |
| LinIntExpr | Gecode::operator+ (const BoolVar &, const LinIntExpr &) |
| Construct linear expression as sum of Boolean variable and linear expression. | |
| LinIntExpr | Gecode::operator+ (const LinIntExpr &, const IntVar &) |
| Construct linear expression as sum of linear expression and integer variable. | |
| LinIntExpr | Gecode::operator+ (const LinIntExpr &, const BoolVar &) |
| Construct linear expression as sum of linear expression and Boolean variable. | |
| LinIntExpr | Gecode::operator+ (const LinIntExpr &, const LinIntExpr &) |
| Construct linear expression as sum of linear expressions. | |
| LinIntExpr | Gecode::operator- (int, const IntVar &) |
| Construct linear expression as sum of integer variable and integer. | |
| LinIntExpr | Gecode::operator- (int, const BoolVar &) |
| Construct linear expression as sum of Boolean variable and integer. | |
| LinIntExpr | Gecode::operator- (int, const LinIntExpr &) |
| Construct linear expression as sum of integer and linear expression. | |
| LinIntExpr | Gecode::operator- (const IntVar &, int) |
| Construct linear expression as sum of integer variable and integer. | |
| LinIntExpr | Gecode::operator- (const BoolVar &, int) |
| Construct linear expression as sum of Boolean variable and integer. | |
| LinIntExpr | Gecode::operator- (const LinIntExpr &, int) |
| Construct linear expression as sum of linear expression and integer. | |
| LinIntExpr | Gecode::operator- (const IntVar &, const IntVar &) |
| Construct linear expression as sum of integer variables. | |
| LinIntExpr | Gecode::operator- (const IntVar &, const BoolVar &) |
| Construct linear expression as sum of integer and Boolean variable. | |
| LinIntExpr | Gecode::operator- (const BoolVar &, const IntVar &) |
| Construct linear expression as sum of Boolean and integer variable. | |
| LinIntExpr | Gecode::operator- (const BoolVar &, const BoolVar &) |
| Construct linear expression as sum of Boolean variables. | |
| LinIntExpr | Gecode::operator- (const IntVar &, const LinIntExpr &) |
| Construct linear expression as sum of integer variable and linear expression. | |
| LinIntExpr | Gecode::operator- (const BoolVar &, const LinIntExpr &) |
| Construct linear expression as sum of Boolean variable and linear expression. | |
| LinIntExpr | Gecode::operator- (const LinIntExpr &, const IntVar &) |
| Construct linear expression as sum of linear expression and integer variable. | |
| LinIntExpr | Gecode::operator- (const LinIntExpr &, const BoolVar &) |
| Construct linear expression as sum of linear expression and Boolean variable. | |
| LinIntExpr | Gecode::operator- (const LinIntExpr &, const LinIntExpr &) |
| Construct linear expression as sum of linear expressions. | |
| LinIntExpr | Gecode::operator- (const IntVar &) |
| Construct linear expression as negative of integer variable. | |
| LinIntExpr | Gecode::operator- (const BoolVar &) |
| Construct linear expression as negative of Boolean variable. | |
| LinIntExpr | Gecode::operator- (const LinIntExpr &) |
| Construct linear expression as negative of linear expression. | |
| LinIntExpr | Gecode::operator* (int, const IntVar &) |
| Construct linear expression as product of integer coefficient and integer variable. | |
| LinIntExpr | Gecode::operator* (int, const BoolVar &) |
| Construct linear expression as product of integer coefficient and Boolean variable. | |
| LinIntExpr | Gecode::operator* (const IntVar &, int) |
| Construct linear expression as product of integer coefficient and integer variable. | |
| LinIntExpr | Gecode::operator* (const BoolVar &, int) |
| Construct linear expression as product of integer coefficient and Boolean variable. | |
| LinIntExpr | Gecode::operator* (const LinIntExpr &, int) |
| Construct linear expression as product of integer coefficient and linear expression. | |
| LinIntExpr | Gecode::operator* (int, const LinIntExpr &) |
| Construct linear expression as product of integer coefficient and linear expression. | |
| LinIntExpr | Gecode::sum (const IntVarArgs &x) |
| Construct linear expression as sum of integer variables. | |
| LinIntExpr | Gecode::sum (const IntArgs &a, const IntVarArgs &x) |
| Construct linear expression as sum of integer variables with coefficients. | |
| LinIntExpr | Gecode::sum (const BoolVarArgs &x) |
| Construct linear expression as sum of Boolean variables. | |
| LinIntExpr | Gecode::sum (const IntArgs &a, const BoolVarArgs &x) |
| Construct linear expression as sum of Boolean variables with coefficients. | |
| LinIntExpr | Gecode::sum (const IntArgs &args) |
| Construct linear expression as sum of IntArgs. | |
| LinIntRel | Gecode::operator== (int l, const IntVar &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (int l, const BoolVar &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (int l, const LinIntExpr &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const IntVar &l, int r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const BoolVar &l, int r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const LinIntExpr &l, int r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const IntVar &l, const IntVar &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const IntVar &l, const BoolVar &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const BoolVar &l, const IntVar &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const BoolVar &l, const BoolVar &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const IntVar &l, const LinIntExpr &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const BoolVar &l, const LinIntExpr &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const LinIntExpr &l, const IntVar &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const LinIntExpr &l, const BoolVar &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator== (const LinIntExpr &l, const LinIntExpr &r) |
| Construct linear equality relation. | |
| LinIntRel | Gecode::operator!= (int l, const IntVar &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (int l, const BoolVar &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (int l, const LinIntExpr &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const IntVar &l, int r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const BoolVar &l, int r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const LinIntExpr &l, int r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const IntVar &l, const IntVar &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const IntVar &l, const BoolVar &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const BoolVar &l, const IntVar &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const BoolVar &l, const BoolVar &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const IntVar &l, const LinIntExpr &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const BoolVar &l, const LinIntExpr &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const LinIntExpr &l, const IntVar &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const LinIntExpr &l, const BoolVar &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator!= (const LinIntExpr &l, const LinIntExpr &r) |
| Construct linear disequality relation. | |
| LinIntRel | Gecode::operator< (int l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (int l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (int l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const IntVar &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const BoolVar &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const LinIntExpr &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const IntVar &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const IntVar &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const BoolVar &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const BoolVar &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const IntVar &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const BoolVar &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const LinIntExpr &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const LinIntExpr &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator< (const LinIntExpr &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (int l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (int l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (int l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const IntVar &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const BoolVar &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const LinIntExpr &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const IntVar &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const IntVar &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const BoolVar &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const BoolVar &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const IntVar &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const BoolVar &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const LinIntExpr &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const LinIntExpr &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator<= (const LinIntExpr &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (int l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (int l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (int l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const IntVar &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const BoolVar &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const LinIntExpr &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const IntVar &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const IntVar &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const BoolVar &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const BoolVar &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const IntVar &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const BoolVar &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const LinIntExpr &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const LinIntExpr &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator> (const LinIntExpr &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (int l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (int l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (int l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const IntVar &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const BoolVar &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const LinIntExpr &l, int r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const IntVar &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const IntVar &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const BoolVar &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const BoolVar &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const IntVar &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const BoolVar &l, const LinIntExpr &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const LinIntExpr &l, const IntVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const LinIntExpr &l, const BoolVar &r) |
| Construct linear inequality relation. | |
| LinIntRel | Gecode::operator>= (const LinIntExpr &l, const LinIntExpr &r) |
| Construct linear inequality relation. |
Detailed Description
Linear expressions can be freely composed of sums and differences of integer variables (Gecode::IntVar) or Boolean variables (Gecode::BoolVar) possibly with integer coefficients and integer constants.
Note that both integer and Boolean variables are automatically available as linear expressions.
Linear relations are obtained from linear expressions with the normal relation operators.
Function Documentation
| LinIntExpr Gecode::operator+ | ( | int | c, | |
| const IntVar & | x | |||
| ) |
Construct linear expression as sum of integer variable and integer.
| LinIntExpr Gecode::operator+ | ( | int | c, | |
| const BoolVar & | x | |||
| ) |
Construct linear expression as sum of Boolean variable and integer.
| LinIntExpr Gecode::operator+ | ( | int | c, | |
| const LinIntExpr & | e | |||
| ) |
Construct linear expression as sum of linear expression and integer.
| LinIntExpr Gecode::operator+ | ( | const IntVar & | x, | |
| int | c | |||
| ) |
Construct linear expression as sum of integer variable and integer.
| LinIntExpr Gecode::operator+ | ( | const BoolVar & | x, | |
| int | c | |||
| ) |
Construct linear expression as sum of Boolean variable and integer.
| LinIntExpr Gecode::operator+ | ( | const LinIntExpr & | e, | |
| int | c | |||
| ) |
Construct linear expression as sum of linear expression and integer.
| LinIntExpr Gecode::operator+ | ( | const IntVar & | x, | |
| const IntVar & | y | |||
| ) |
Construct linear expression as sum of integer variables.
| LinIntExpr Gecode::operator+ | ( | const IntVar & | x, | |
| const BoolVar & | y | |||
| ) |
Construct linear expression as sum of integer and Boolean variable.
| LinIntExpr Gecode::operator+ | ( | const BoolVar & | x, | |
| const IntVar & | y | |||
| ) |
Construct linear expression as sum of Boolean and integer variable.
| LinIntExpr Gecode::operator+ | ( | const BoolVar & | x, | |
| const BoolVar & | y | |||
| ) |
Construct linear expression as sum of Boolean variables.
| LinIntExpr Gecode::operator+ | ( | const IntVar & | x, | |
| const LinIntExpr & | e | |||
| ) |
Construct linear expression as sum of integer variable and linear expression.
| LinIntExpr Gecode::operator+ | ( | const BoolVar & | x, | |
| const LinIntExpr & | e | |||
| ) |
Construct linear expression as sum of Boolean variable and linear expression.
| LinIntExpr Gecode::operator+ | ( | const LinIntExpr & | e, | |
| const IntVar & | x | |||
| ) |
Construct linear expression as sum of linear expression and integer variable.
| LinIntExpr Gecode::operator+ | ( | const LinIntExpr & | e, | |
| const BoolVar & | x | |||
| ) |
Construct linear expression as sum of linear expression and Boolean variable.
| LinIntExpr Gecode::operator+ | ( | const LinIntExpr & | e1, | |
| const LinIntExpr & | e2 | |||
| ) |
Construct linear expression as sum of linear expressions.
| LinIntExpr Gecode::operator- | ( | int | c, | |
| const IntVar & | x | |||
| ) |
Construct linear expression as sum of integer variable and integer.
| LinIntExpr Gecode::operator- | ( | int | c, | |
| const BoolVar & | x | |||
| ) |
Construct linear expression as sum of Boolean variable and integer.
| LinIntExpr Gecode::operator- | ( | int | c, | |
| const LinIntExpr & | e | |||
| ) |
Construct linear expression as sum of integer and linear expression.
| LinIntExpr Gecode::operator- | ( | const IntVar & | x, | |
| int | c | |||
| ) |
Construct linear expression as sum of integer variable and integer.
| LinIntExpr Gecode::operator- | ( | const BoolVar & | x, | |
| int | c | |||
| ) |
Construct linear expression as sum of Boolean variable and integer.
| LinIntExpr Gecode::operator- | ( | const LinIntExpr & | e, | |
| int | c | |||
| ) |
Construct linear expression as sum of linear expression and integer.
| LinIntExpr Gecode::operator- | ( | const IntVar & | x, | |
| const IntVar & | y | |||
| ) |
Construct linear expression as sum of integer variables.
| LinIntExpr Gecode::operator- | ( | const IntVar & | x, | |
| const BoolVar & | y | |||
| ) |
Construct linear expression as sum of integer and Boolean variable.
| LinIntExpr Gecode::operator- | ( | const BoolVar & | x, | |
| const IntVar & | y | |||
| ) |
Construct linear expression as sum of Boolean and integer variable.
| LinIntExpr Gecode::operator- | ( | const BoolVar & | x, | |
| const BoolVar & | y | |||
| ) |
Construct linear expression as sum of Boolean variables.
| LinIntExpr Gecode::operator- | ( | const IntVar & | x, | |
| const LinIntExpr & | e | |||
| ) |
Construct linear expression as sum of integer variable and linear expression.
| LinIntExpr Gecode::operator- | ( | const BoolVar & | x, | |
| const LinIntExpr & | e | |||
| ) |
Construct linear expression as sum of Boolean variable and linear expression.
| LinIntExpr Gecode::operator- | ( | const LinIntExpr & | e, | |
| const IntVar & | x | |||
| ) |
Construct linear expression as sum of linear expression and integer variable.
| LinIntExpr Gecode::operator- | ( | const LinIntExpr & | e, | |
| const BoolVar & | x | |||
| ) |
Construct linear expression as sum of linear expression and Boolean variable.
| LinIntExpr Gecode::operator- | ( | const LinIntExpr & | e1, | |
| const LinIntExpr & | e2 | |||
| ) |
Construct linear expression as sum of linear expressions.
| LinIntExpr Gecode::operator- | ( | const IntVar & | x | ) |
Construct linear expression as negative of integer variable.
| LinIntExpr Gecode::operator- | ( | const BoolVar & | x | ) |
Construct linear expression as negative of Boolean variable.
| LinIntExpr Gecode::operator- | ( | const LinIntExpr & | e | ) |
Construct linear expression as negative of linear expression.
| LinIntExpr Gecode::operator* | ( | int | a, | |
| const IntVar & | x | |||
| ) |
Construct linear expression as product of integer coefficient and integer variable.
| LinIntExpr Gecode::operator* | ( | int | a, | |
| const BoolVar & | x | |||
| ) |
Construct linear expression as product of integer coefficient and Boolean variable.
| LinIntExpr Gecode::operator* | ( | const IntVar & | x, | |
| int | a | |||
| ) |
Construct linear expression as product of integer coefficient and integer variable.
| LinIntExpr Gecode::operator* | ( | const BoolVar & | x, | |
| int | a | |||
| ) |
Construct linear expression as product of integer coefficient and Boolean variable.
| LinIntExpr Gecode::operator* | ( | const LinIntExpr & | e, | |
| int | a | |||
| ) |
Construct linear expression as product of integer coefficient and linear expression.
| LinIntExpr Gecode::operator* | ( | int | a, | |
| const LinIntExpr & | e | |||
| ) |
Construct linear expression as product of integer coefficient and linear expression.
| LinIntExpr Gecode::sum | ( | const IntVarArgs & | x | ) |
Construct linear expression as sum of integer variables.
| LinIntExpr Gecode::sum | ( | const IntArgs & | a, | |
| const IntVarArgs & | x | |||
| ) |
Construct linear expression as sum of integer variables with coefficients.
| LinIntExpr Gecode::sum | ( | const BoolVarArgs & | x | ) |
Construct linear expression as sum of Boolean variables.
| LinIntExpr Gecode::sum | ( | const IntArgs & | a, | |
| const BoolVarArgs & | x | |||
| ) |
Construct linear expression as sum of Boolean variables with coefficients.
| LinIntExpr Gecode::sum | ( | const IntArgs & | args | ) |
Construct linear expression as sum of IntArgs.
| LinIntRel Gecode::operator== | ( | int | l, | |
| const IntVar & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | int | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | int | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const IntVar & | l, | |
| int | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const BoolVar & | l, | |
| int | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const LinIntExpr & | l, | |
| int | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const IntVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const IntVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const BoolVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const BoolVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const IntVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const BoolVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const LinIntExpr & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const LinIntExpr & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator== | ( | const LinIntExpr & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear equality relation.
| LinIntRel Gecode::operator!= | ( | int | l, | |
| const IntVar & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | int | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | int | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const IntVar & | l, | |
| int | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const BoolVar & | l, | |
| int | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const LinIntExpr & | l, | |
| int | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const IntVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const IntVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const BoolVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const BoolVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const IntVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const BoolVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const LinIntExpr & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const LinIntExpr & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator!= | ( | const LinIntExpr & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear disequality relation.
| LinIntRel Gecode::operator< | ( | int | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | int | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | int | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const IntVar & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const BoolVar & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const LinIntExpr & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const IntVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const IntVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const BoolVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const BoolVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const IntVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const BoolVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const LinIntExpr & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const LinIntExpr & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator< | ( | const LinIntExpr & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | int | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | int | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | int | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const IntVar & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const BoolVar & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const LinIntExpr & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const IntVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const IntVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const BoolVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const BoolVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const IntVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const BoolVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const LinIntExpr & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const LinIntExpr & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator<= | ( | const LinIntExpr & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | int | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | int | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | int | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const IntVar & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const BoolVar & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const LinIntExpr & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const IntVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const IntVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const BoolVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const BoolVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const IntVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const BoolVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const LinIntExpr & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const LinIntExpr & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator> | ( | const LinIntExpr & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | int | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | int | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | int | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const IntVar & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const BoolVar & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const LinIntExpr & | l, | |
| int | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const IntVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const IntVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const BoolVar & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const BoolVar & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const IntVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const BoolVar & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const LinIntExpr & | l, | |
| const IntVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const LinIntExpr & | l, | |
| const BoolVar & | r | |||
| ) |
Construct linear inequality relation.
| LinIntRel Gecode::operator>= | ( | const LinIntExpr & | l, | |
| const LinIntExpr & | r | |||
| ) |
Construct linear inequality relation.


To start, click the
button on the black
bar. The button will move you
back one step. The button will move you
to the end of this section. The button will
bring you back to the start of the section. Additional and buttons appear in
individual steps (on a grey background, inside task boxes), allowing
you to move between smaller tasks.
In Meshmixer, holding the "Space" bar opens a set of controls which change the way your models are displayed. Most importantly, the buttons in the "Color" section allow you to switch between displaying the original color data from your 3D scan, and displaying what are called "face groups." To toggle between the two views in Meshmixer, simply hold down the "Space" bar and click on either of the two icons in the "Color" area of the pop-up menu.
This section will cover
the following:
Importing your scan file
Removing excess data from the file
Rectifying the positive model
Creating a socket from the rectified positive
Adding an ICRC-compatible mounting point to the socket


{% include build-meta-description.html %} {% include head-general-information.html %} {% include head-social-icons-font.html %} {% include head-open-graph.html %} {% include head-twitter.html %} {% include head-icons.html %} {% include head-google-analytics.html %} {% include head-optimizely.html %}


Josef Vadassy, a Hungarian refugee and language teacher living in France, is enjoying his first break for years in a small hotel on the Riviera. But when he takes his holiday photographs to be developed at a local chemists, he suddenly finds himself mistaken for a Gestapo agent and a charge of espionage is levelled at him. To prove himself innocent to the French police, he must discover which one of his fellow guests at his pension is the real spy. As he desperately tries to uncover the true culprit's identity, Vadassy must risk his job, his safety and everything he holds dear.
I arrived in St Gatien from Nice on Tuesday, the fourteenth of August. I was arrested at 11:45 a.m. on Thursday, the sixteenth, by an agent de police and an inspector in plain clothes and taken to the Commisariat.


Experience
Research Scientist/Software Engineer, in4mation insights, Boston, Massachusetts, US (Mar 2017 - Present)
- Develop a large-scale application for market research analytics
- Design and develop the implementation of in-house data visualization for data analysts
- Develop the data pipeline infrastructure for big data analytics and machine learning. (Python, Django, JavaScript, Bootstrap, D3.js, PostgreSQL)
Data Visualization Architect, EPE Innovations, Dallas, Texas, US (Aug 2016 - Jan 2017)
- Developed the interactive data visualizations of geospatial data using D3.js
- Designed and developed data insights into dashboards, business intelligence, and data visualization
Research Assistant, PhD, Computational Physiology Lab, University of Houston, Texas, US (Aug 2011 - Aug 2016)
- Developed the web application that enabled viewing scholars' accomplishments and comparing them using D3.js, jQuery, PHP, and SQL. - www.scholarplot.com
- Wrote python scripts to extract, transform, and load from unstructured open datasets in XML/JSON.
- Designed the system architecture of front-end, back-end, and a relational model for MySQL.
- Built and configured cloud computing platforms on Microsoft Azure, AWS, and Google App Engine.
- Developed the data visualization app and components using PHP for the project of Toyota Class Action Settlement Safety Research. - http://subjectbook.times.uh.edu/
- Programed R to statistically analyze datasets for publications and government open datasets.
- Developed an Android app for the mobile security project – Published a paper to Homeland Security
- Research leader in the data visualization project
- Propose, design and implement a novel data visualization tool, ScholarPlot, to visualize scholarly research accomplishments
- Invent and develop an online data visualization method, User Portrait, to condense Affective User Data: API available.
- Statistical analysis of Google Scholar data
Research Intern, PhD, Northwestern University - Kellogg School of Management, Evanston, Illinois, US (June 2015 - Aug 2015)
- Developed the platform algorithms that convert statistical and deterministic models into program features based on citation data.
- Implemented comparative analysis features and improved the backend data intake features from Google Scholar
Teaching Assistant, Department of Computer Science, University of Houston, Texas, US (Aug 2011 - Dec 2013)
- Instructed COSC 6355 Ubiquitous Computing to guide with iPhone Programming (Fall 2013)
- Assessed and guided COSC 3320 Design and Database Systems (Spring 2013)
- Taught and analyzed COSC 3320 Algorithms and Data Structures (Fall 2011, Spring 2012, Fall 2012)
- Instructed and graded COSC 3320 Introduction to Automata and Computation (Summer 2012, Fall 2012)
Software Engineer, TmaxSoft, Seoul, Korea (Jan 2006 - Oct 2009)
- Led team and developed core banking system of large transaction volumes with high availability
- Designed and built a system migration from a mainframe to an open system to improve product infrastructure
- Implemented Finance Management System to drive performance with consistent financial and operational information; leading to a 150% performance improvement
- Contributed to an internal project that increases global transactions coverage by 40%
- Programmed and maintained a learning management system to support training program
Link


{{ partial "header.html" . }} Hop Orchestration Platform The Hop Orchestration Platform aims to facilitate all aspects of data and metadata orchestration. Quick Links Source code (github) JIRA Forums Contribution Guide Get started {{ .Content }} {{ partial "footer.html" . }}
The Hop Orchestration Platform aims to facilitate all aspects of data and metadata orchestration.


Hi, this is what I created my seventhweek of Digital Engineering For my final project I constructed a wooden roller skate with a wooden roller plate, 3D printed wheels, and a flip-flop for the shoe base. The four main components of my project included a wooden base, three 3D printed wheels, two metal axles, and one rubber flip-flop. I spent a long time designing the .8 inch wide wheel and a 10 inch 3D printed wheel base, however it was too large for the Makerbot printer so I decided to build a wooden wheel base and screw in rubber flip-flop to the base. To decorate the side of the wheel base I rastored STAR WARS into the side of the wood. The most important lession I learned from this project is that planning is key. My 3D printed Base was far betting in design and precision of the dimensions. However I could not use it as a result of its size.
First, I designed a 2 and 1/2 tall, .8 inch wide 3D printed wheel in Fusion 360 and printed three using the Makerbot priter. Second, I designed a wooden base with 1/2 inch thick wood that was 10" by 4". I then cut out two 10" long, 1 and 1/2 inch by 2" wide pieces of wood to act as the wheel supports. I then placed them .9 inches apart allowing for room for the wheel. I then drilled two holes throught the front and back of the wooden base to serve as an axle Third, I put my metal axle through the front of the skate, got a 1/4 inch thick piece of wood and cut it 5" by 1" and placed it slightly behind the axle under the wooden base. I then got two 1/2 inch wooden piece and cut them 2" by 1". I then drilled a 1/4" hole in both the fit the axle. I then screwed the drilled pieces of wood to the one flat connecting piece. Lastly, I screwed a rubber flip-flop onto the top of the wooden base and sanded the base to fit the size of the sandal better. This is the .stl file for the wheel, to build the base just follow my instructions above and use the pictures as a guide. In additon, here is the base that I originally planned on constructing the skate with.


AWS Workshop preps
Prerequisites
Prepare AWS account
- Log in to AWS
- Go to Services -> Identity and Access Management
- Create new user - take note of the access key and secret
- Click on the new user and select the Permissions tab
- Attach the Administrator access policy to the user
Note: In real life scenarios, you would not assign administrator privileges but more fine grain permissions.
Setting AWS Access on laptop
- Create directory .aws to your home folder
- Copy file config to your .aws folder
- Copy file credentials to your .aws folder
- Enter the access key and secret key for your AWS account to the credentials file
Testing the setup
- Create directory workshop and under that new directory awstest
- Change directory to awstest, run npm install aws-sdk
- Copy file awstest.js to your awstest directory
- Run node awstest.js
You should get your IAM account name as a response if set up correctly.
Install Serverless Framework
- Run npm install -g<EMAIL_ADDRESS>Create workshop projects under the workshop directory to use the installed Serverless version.


|
|
|
Female English Names
[ Suggest
Names for this page ] [ Go to Male
English
Names ]
[
1 ] [ 2 ] [
3 ] [ 4 ]
[ 5
] [
6 ] [ 7 ] [
8 ] [ 9 ]
[ 10 ]
[
11 ] [ 1 2 ] [
1
3 ] [ 14 ] [
15 ] [ 16 ] [
17 ] [ 18 ] [
19 ] [ 20 ]
- CHARISSA:
English elaborated form of Latin Charis,
meaning "grace."
- CHARITA:
Variant form of English Charity, meaning
"dear."
- CHARITY: English
name derived from the vocabulary word charity,
from Latin caritas, from carus, meaning
"dear." It is one of the virtue names that
were popular with the Puritans; some others are Chastity,
Faith, Honor,
Hope,
and Prudence.
- CHARLA:
Pet form of English Charlene, meaning
"man."
- CHARLEEN:
Variant spelling of English Charlene, meaning
"man."
- CHARLENE:
English form of French Charline,
meaning "man."
- CHARLEY:
Variant spelling of English unisex Charlie,
meaning "man."
- CHARLIE:
Unisex pet form of English Charles
and Charlene, meaning "man."
- CHARLOTTE:
Feminine form of French Charlot,
meaning "man."
- CHARMAINE:
English name of Latin origin, meaning
"sing."
- CHARMIAN:
English name derived from Greek charma,
meaning "delight."
- CHASITY:
Variant spelling of
English Chastity, meaning
"purity."
- CHASTITY:
English name meaning "purity." It is one
of the virtue names that were popular with the Puritans;
some others are Charity, Faith,
Honor, Hope,
and Prudence.
- CHELLE:
English short form of French Michelle,
meaning "who is like God?"
- CHELSEA:
English name derived from the name of a
district in London, meaning "landing place" or
"landing
port."
- CHELSEY:
Variant spelling of English Chelsea, meaning "landing
place" or "landing
port."
- CHELSIE:
Variant spelling of English Chelsea, meaning "landing
place" or "landing
port."
- CHER:
Short form of English Cheryl, probably meaning
"darling beryl."
- CHERETTE:
Pet form of English Cherie, meaning
"darling," and other names beginning with Cher-.
- CHERI:
Variant spelling of English Cherie, meaning
"darling."
- CHERICE:
Variant spelling of English Cherise, meaning
"cherry."
- CHERIE:
English name derived from the French word chérie,
meaning "darling."
- CHERILYN:
English compound name
composed of Cheri
"darling" and Lyn
"lake," hence "darling lake."
- CHERISE:
English variant spelling of French Cerise, meaning
"cherry."
- CHERISH:
English name derived from the vocabulary word cherish, meaning "to
cherish; to hold dear."
- CHEROKEE:
Unisex name derived from the English pronunciation of Tsa-la-gi,
a name that the Native
American Cherokee people used to refer to themselves,
meaning "principal people."
- CHERRY:
- English name
derived from the vocabulary word, meaning
"cherry."
-
Variant spelling of English Cherie, meaning
"darling."
CHERYL:
This English name first appeared in the 1920s and is probably
a blend of Cherie
"darling" and the gem name Beryl,
hence "darling beryl."
CHEVONNE:
English pronunciation of Irish Gaelic Siobhán,
meaning "God is gracious."
CHEYANNE:
Variant spelling of English unisex Cheyenne, meaning
"little Šahíya" or "little
red-talker."
CHEYENNE:
English unisex name derived from the name of the Native
American people, from Dakota Sioux Šahíyena, meaning
"little Šahíya" or "little
red-talker."
CHINA:
English name derived from the country name which probably got its name from the
Qin dynasty. The Chinese
people call their country Zhongguo which translates to
"middle kingdom." Compare with another form of China.
CHITA: Middle English name meaning "kitten."
Compare with other forms of Chita.
CHLOE: Latin
form of Greek Chloē, meaning "green shoot." In mythology, this is
a surname of
the goddess Demeter. In the New Testament
bible, this name is mentioned by Paul in 1
Corinthians 1:11.
CHLORIS:
Latin form of Greek Khloris,
meaning "green buds." In mythology, this is
the name of a goddess of flowers and vegetation.
CHONSIE:
Feminine form of English Chauncey,
meaning "good fortune."
CHRIS:
English unisex short form of longer names beginning with Chris-.
CHRISSIE:
English pet form of French Christine,
meaning
"believer" or "follower of Christ."
CHRISSY:
Variant spelling of
English Chrissie, meaning
"believer" or "follower of Christ."
CHRISTA:
Contracted form of Latin Christina,
meaning
"believer" or "follower of Christ."
CHRISTABEL:
Variant spelling of English Christabelle,
meaning "believer" or "follower of Christ"
and Belle,
"beautiful."
CHRISTABELLA:
English compound name composed of French Christine
"believer" or "follower of Christ"
and Latin Bella
"beautiful."
CHRISTABELLE:
English compound name composed of French Christine
"believer" or "follower of Christ"
and French Belle
"beautiful."
CHRISTAL:
Variant spelling of English Crystal, meaning
"crystal, ice."
CHRISTEL:
Variant spelling of English Crystal, meaning
"crystal, ice."
CHRISTELLE:
Pet form of French Christine,
meaning "believer" or "follower of Christ."
CHRISTEN:
English variant spelling of German Kristen,
meaning "believer" or "follower of Christ."
CHRISTI:
Variant spelling of English Christie,
meaning "believer" or "follower of Christ."
CHRISTIANA:
Feminine form of Latin Christianus,
meaning "believer" or "follower of Christ."
CHRISTIANNE: Feminine form of
English Christian,
meaning "believer" or "follower of Christ."
CHRISTIE:
English pet form of Latin Christina,
meaning "believer" or "follower of Christ."
CHRISTIN:
English abbreviated form of French Christine
or Latin Christina, meaning
"believer" or "follower of Christ."
CHRISTINA:
Variant spelling of Latin Christiana,
meaning "believer" or "follower of Christ."
CHRISTINE:
French from of Latin Christina,
meaning "believer" or "follower of Christ."
CHRISTOBEL:
Variant spelling of English Christabel,
meaning "believer" or "follower of Christ"
and "beautiful."
CHRISTY:
Variant spelling of English Christie,
meaning "believer" or "follower of Christ."
Compare with masculine Christy.
CHRYSANTA:
Latin form of Greek Chrysanthe,
meaning "golden flower."
CHRYSSA:
English pet form of Latin Chrysanta, meaning
"golden flower."
CHRYSTAL:
Variant spelling of English Crystal, meaning
"crystal, ice."
CHYNA:
Variant spelling of English China, derived from the country
name which probably got its name from the Qin dynasty. The Chinese
people call their country Zhongguo which translates to
"middle kingdom."
CICELY:
Variant spelling of English Cecily,
meaning "blind."
CIEL:
English name derived from the French word for
"sky."
CIERA:
Variant spelling of
English Sierra,
meaning "mountain range."
CIERRA:
Variant spelling of
English Sierra,
meaning "mountain range."
CILLA:
Pet form of
English Cecilia,
meaning "blind."
CIMONE:
English variant spelling of French Simone,
meaning "hearkening."
CINDERELLA:
English form of French Cendrillon,
meaning "little ashes."
CINDRA:
Modern English name, probably a blend of Cindy
"woman from Kynthos" and Sandra
"defender of mankind."
CINDY:
English pet form of Latin Cynthia, meaning "woman from Kynthos."
CIS:
Short form of English Cissy,
meaning "blind."
CISS:
Short form of English Cissy, meaning "blind."
CISSY:
Pet form of
English Cecilia,
meaning "blind."
CLAIR:
English variant spelling of French Claire,
meaning "clear, bright."
CLAIRE:
French form of Latin Clara,
meaning
"clear, bright."
CLAIRENE:
Pet form of French Claire, meaning
"clear, bright."
CLARA:
Feminine form of Latin Clarus,
meaning "clear, bright." In use by the English
and Italians.
CLARABELLA:
English compound name composed of Latin Clara
"clear, bright" and Bella
"beautiful," hence "bright beauty."
CLARABELLE:
Variant spelling of English Clarabella,
meaning "bright beauty."
CLARAMAE:
English compound name
composed of Latin Clara,
"clear; bright," and English Mae
"pearl" or "obstinate, rebellious."
CLARAMAY:
Variant spelling of English Claramae, meaning
"bright pearl" or "bright rebel."
CLARE: English form of Latin
Clara,
meaning "clear, bright." Compare with
masculine Clare.
CLARETTA:
Pet form of Latin Clara, meaning
"clear, bright."
CLARETTE:
Pet form of English Clare, meaning "clear, bright."
CLARIBEL:
Variant spelling of English Clarabelle,
meaning "bright and beautiful."
CLARICE:
Medieval French form of Latin Clarissa,
meaning "fame."
CLARISSA:
Diminutive form of Latin Clara, meaning "fame."
CLARITY:
English name derived from the vocabulary word clarity, from Latin clarus, meaning
"clear."
CLAUDETTE:
Diminutive form of French Claudia,
meaning "little lame one."
CLAUDIA:
Feminine form of French Claude, meaning "lame."
CLAUDIE:
Pet form of French Claudia,
meaning "lame."
CLAUDINE:
Diminutive form of French Claudia,
meaning "little lame one."
CLEMATIS:
English name derived from the name of the flowering vine
clematis, from Greek klema, meaning "branch or
brushwood."
CLEMENCY:
Feminine form of Latin Clement,
meaning "gentle
and merciful."
CLEMENTINE:
French form of Latin Clementina, meaning "of
Clementius."
CLEO:
Short form of Latin Cleopatra, meaning
"glory of the father."
CLEOPATRA:
Latin form of Greek Kleopatra,
meaning "glory of the father." Cleopatra VII reigned as Queen of Egypt from 51-30 B.C. She was born in 69 B.C. in Alexandria, Egypt and is
believed to have been black African.
CLOVER:
Old English flower name, meaning simply "clover."
COCO:
Originally from the Italian occupational name for a
"cook," it is now in continental use as a pet
form of longer names beginning with Co-.
CODIE:
Variant spelling of English unisex Cody,
meaning "helper."
CODY: Irish surname
transferred to unisex forename use, from a variant spelling of
the surname Cuddihy (also spelled Cuddy), an Anglicized
form of Gaelic Ó Cuidighthigh "descendant of
Cuidightheach," hence "helper."
COLEEN:
Variant spelling of English Colleen, meaning
"girl."
COLENA:
Variant spelling of English Colleen,
meaning "girl."
COLENE:
Variant spelling of English Colleen, meaning
"girl."
COLETTE:
Short form of French Nicolette,
meaning "victor of the people."
COLINE:
Variant spelling of English Colleen,
meaning "girl."
COLLEEN:
Anglicized form of Irish Gaelic Cailín,
meaning "girl."
COLLYN:
Variant spelling of English Colleen,
meaning "girl."
COLUMBINE: English name derived from the plant name columbine,
from Late Latin columbina, meaning "verbina"
or "dovelike," so-called because when inverted
the flower resembles a cluster of doves. Compare with
another form of Columbine.
COMFORT:
English name derived from the vocabulary word, meaning "to
comfort, help, strengthen."
CONCORDIA:
Latin name meaning
"harmony; peace; with (one) heart." In
mythology, this is the name of a goddess of peace. Her Greek
name is Harmonia.
CONNIE:
Pet form of English/French Constance, meaning
"steadfast."
CONRADINE:
Feminine form of German Conrad,
meaning "bold counsel."
CONSTANCE:
English form of Latin Constantia,
meaning "steadfast."
CORA:
Latin form of Greek Kore, meaning "maiden." In mythology, this is a name borne by
Persephone,
a goddess of the underworld.
CORAL:
English name derived from the gem name, from Latin corallium, probably ultimately from Hebrew goral,
meaning "small pebble."
CORALIE:
Pet form of
English Coral, meaning
"coral" or "small pebble."
CORDELIA:
English name which may be an elaborated form of the Latin
word cor, meaning "heart." This is the
name of a legendary queen of the Britons. It is also the name
of a moon of Uranus and an asteroid, both of which were
named after a Shakespeare character who also bore this
name.
CORIANDER:
English name derived from the spice name coriander
(also commonly called Cilantro), from Latin coriandrum,
from Greek corys ("bedbug") with the
added element -ander "resembling"
(referring to the smell of the spice which is similar
to the odor of bedbugs), hence "smells like a
bedbug."
CORLISS:
English surname transferred to
forename use, from a byname derived from Old English carleas,
composed of the elements caru "care; grief"
and leas
"without," hence "carefree."
CORNELIA:
Feminine form of Roman Latin Cornelius, meaning
"of a horn."
CORONA:
English name derived from the vocabulary word, Latin corona, meaning
"crown, garland, wreath." The outer atmosphere
of a star is called a corona.
CORRINA:
English variant spelling of Latin Corinna,
meaning "maiden."
CORRINE:
English variant spelling of French Corinne, meaning
"maiden."
CORTNEY:
Variant spelling of English unisex Courtney,
meaning "short nose."
CORYNN:
English variant spelling of French Corinne,
meaning "maiden."
COURTNEY:
English surname transferred to unisex forename use, from
the French baronial name Courtenay, from the
nickname court nez, meaning "short
nose."
CRESSIDA:
From the English literary name found in various
retellings of the Trojan War, based on the Greek name Khryseis, from khrysos, meaning "gold."
CRISTAL:
Variant spelling of English Crystal, meaning
"crystal, ice."
CRISTEN:
English variant spelling of Scandinavian Kristin,
meaning "believer" or "follower of Christ."
CRISTINA:
Variant spelling of Latin Christina,
meaning "believer" or "follower of Christ."
CRYSTAL:
English name derived from the gem name, from Greek krystallos,
meaning "ice."
CYAN:
English name derived from the vocabulary word, from Greek kyanos,
meaning
"dark blue" and "lapis
lazuli." The color cyan is also sometimes called
blue-green, electric blue, and turquoise.
CYBILL:
English variant spelling of Greek Sybil, meaning
"prophetess."
CYMONE:
English variant spelling of French Simone,
meaning "hearkening."
CYNDI:
Variant spelling of
English Cindy, meaning "woman from
Kynthos."
CYNTHIA:
Latin form of Greek Kynthia,
meaning "woman from Kynthos." In mythology, this was another
name for Artemis.
CYRILLA:
Feminine form of
English Cyril,
meaning "lord."
DACEY:
Irish surname transferred to unisex forename
use, from an Anglicized form of Gaelic Déiseach which
was originally a name for a member of the Déise,
"a tenant, a vassal," a word tracing back to Indo-European *dem-s
("house").
DAFFODIL:
English name derived from the flower name, from Latin asphodelus,
from Greek asphodelos, meaning "asphodel
flower." In
Greek mythology, it is described as a pale yellow
deathless kind of lily flower that overspreads the plains of Hades
and is the favorite food of the dead.
DAHLIA:
English name derived from
the flower name, from the surname of Swedish botanist
Anders Dahl, meaning "valley," hence
"dahlia flower" or "valley flower."
DAISY: English name
derived from the flower name, from Old English dægeseage,
"day's eye."
DAKOTA:
English unisex name derived from the name that the Sioux
people call themselves, literally meaning "allies."
DALE:
English surname transferred to
unisex forename use, meaning "dale, valley."
DALIA:
Variant spelling of English Dahlia, meaning
"dahlia flower" or "valley flower."
DALILAH:
Variant spelling of English Delilah,
meaning
"delicate, weak."
DALINDA:
Variant spelling of English Delinda, meaning "noble serpent."
DARINA:
Anglicized form of Irish Gaelic Dáiríne, meaning
"fertile,
fruitful."
DALLAS:
English surname
transferred to unisex forename use, derived from the
Scottish place name Dalfhas, composed of the Gaelic
elements dail "meadow" and fhas
"stance," hence "meadow stance,"
i.e. a meadow used by cattle droves as an overnight
dwelling.
DALYA:
Variant spelling of English Dahlia,
meaning "dahlia flower."
DAMIA: Feminine
form of English Damian,
meaning "to tame, to subdue" and
euphemistically "to kill."
[
1 ] [ 2 ] [
3 ] [ 4 ]
[ 5
] [
6 ] [ 7 ] [
8 ] [ 9 ]
[ 10 ]
[
11 ] [ 1 2 ] [
1
3 ] [ 14 ] [
15 ] [ 16 ] [
17 ] [ 18 ] [
19 ] [ 20 ]
|
|
|
A-Z
Baby Names
|
|
Girl Names
A,
B, C,
D, E,
F, G,
H, I,
J, K,
L, M,
N, O,
P, Q,
R, S,
T, U,
V, W,
X, Y,
Z
Boy
Names
A,
B, C,
D, E,
F, G,
H, I,
J, K,
L, M,
N, O,
P, Q,
R, S,
T, U,
V, W,
X, Y,
Z
|
|
|
***
|
|
Pet
Names
Names for your pets. Grouped by species.
Naming Tips &
Quips
|
| Miscellany |
|
New Page 1
|
|
| *** |
New Page 1
|
Games
have been removed. 20kWeb is being converted into an
Etymology site. |
|
|
|
|
|


there was once a time when almost nobody knew when i was on acid and when i wasn't including my oh so loving and understanding parents. my therepist and best friend could spot. i was on a journey to find the answer. i was going to find out why the world began, and i was convinced that acid would show me the answers. i also have adhd and ocd.
a washout is an empty vail of acid that has been filled 3/4 of the way w/ vodka or whiskey. vodka is better if availible, i'm not sure if proof matters. i'd stick with a good 80.
6.30pmish to 9:30pmish: first washout is dropped w/ my best friend. we have make an oath of forever friendship in the bathroom and then go to my parents and dance to the Beatles.  He is revived by milk. we sit around bullshitting. there are 9 people in total who are all under lsd. two freinds play fight and one is not wearing a shirt. there is a little bit of snow on the ground. we decide to go on another walk. look at bushs that resemble animals. the same four of us go and climb up a mountain where the city is completly visable and lights are jumping everywhere. we think we see a cop and hide. it's not really there. there is a unidentifiable orange light somewhere. i'm feeling exited and a bit clumsy. bit like a four year old girl peeping out from behind a door.
12.30pmish to 1.30amish: first we find balloons in trees. we find ourselves at the edge of a cliff that was cut out during the construction of a freeway. we climbed over barbed wire to get here, all to look at cars, 40 feet from above. we remanice about early childhood until we see ghetto birds. there are two of them with search lights. we run, trying to find our way out of this barbed wire fence. my friend who went blind gets caught, but morphs into a bucking bronco. he makes it out alive without any scrapes. we run down the hill from cops flying a mile away from us, who are looking for a gun man, not four teenagers on acid. i'm feeling an adrenline rush and am laughing at my friend who refuses to a use a trail, but must run and jump on every bush in his path.
1.30amish to 3.00amish: this is where it starts to get really fucking wierd. we walk down the hill and my friend john's most famous words are used here. 'you think your fucking with the desert, but the deserts fucking with you.' my nose is clogged and i'm starting to get cold. my mind is starting to wonder. i'm thinking, god please don't let me go insane. we return to our friends house to rest and trip out. i have tripped on acid in this garage 30 times, give or take a few. inside of it there is the center of the earth where the indian died that can only be opened by a sea world backpack that no longer leaves the crevas i call my closet. this trips a friend out. i then start babbling for 10 minutes. i don't remember what i said, except for the end. something about a guy riding his bicycle to power the earth.
3.30amish to day break. the moment the last word left my mouth i felt a stone door inside my body open and it was as though i had been enclosed in a trap door that had just opened. it and many other things that i've thought of on acid come from the many episodes of scooby-doo that entranced me as a little kid. i got up very jaggedly (my body felt like stiff ruber that was about to give out at any second)and begged my best friend not to leave me where ever i had ended up. my three freinds look at me silently. i had taken my best friend with me, tripped my friend john out, and had led mr. blind into a confusion/reality milkshake.
that's when i realized something very important. that thing that i had been searching for. i'd been looking for answers that could not be solved, unless i were to meet god. the definition of god is the creator of the earth. unless i could meet what ever the hell created the universe my questions'll never be answered. so i gave up my search, decided to take aldous huxley's advice of here and now, gave props to god, and danced to the same damn trance song for nearly three hours, just remembering every time i'd ever done acid and swearing that i wouldn't do it for six months after i thought that i'd never do it again.
in 15 days it will be 6 months. i don't know if i'll ever dose again, but i will say this. if you find god because of a drug, i highly suggest you take a break. i mean i'm happy with my faith and everything, but its really sad that i let a drug drag me that far, but i don't regret it. i can still see the ground moving and if i stay up for about 24 hours sprinklers turn into things like lawn gnomes who move, so all in all, i'm not all here or there anymore, but shit, i'm havin' a damn good time. also, if you're having a bad acid trip drink the juice from canned peaches, milk, throw up if you gotta, and say whatever your thinking out loud to someone who isn't on acid so you don't trip the other people out. don't let this scare you away from acid, that was like trip 150 and please don't attempt a washout unless you can kick it under at least 30 hits.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


@@
- Mission
- Contacts
-
- Chairs
- Team Contacts
- Charter
- @@
- Status
- @@
- Participating Organizations
- Participating Individuals
- [Join the Group] [Detailed list of Participants]
- W3C Patent Policy
- See IPP status
- Services
- Repositories
-
- Published Technical Reports
- Testing


Ordering by '{{ sort.orderProp }}' in {{sort.sortReverse ? 'descending' : 'ascending'}} order.
Showing {{sort.total}} of {{sort.total_results}} results found. Please refine your search criteria to get more accurate results.


New Search
My Favorites
Dinner and a Joke? Yes, Please!
**Save a recipe for later and we'll show you the punchline!**
Favorite saved! Here's your punchline:


Personal data
Surname
First Name
Middle name
You are
male
female
Age
Country of Residence
Netherland
Oz
Moominvalley
Narinia
Wonderland
City
Ryazan
Moscow
Photography
Title
Web Master
Database Administrator
Computer-aided design
Economic planning
Management accounting
Budgeting and planning
Salary
Contact information
Site
Email
Phone
Password


The roller coaster traces its origins to Russia, where wood-framed ice slides sent sledders down 70-foot high slopes as early as the 16th century. These Russian Mountains also became popular summertime attractions when wheeled carts rolled riders down large, undulating wooden ramps. The first successful commercial roller coaster made its debut in 1884 at New York's famous Coney Island: the Gravity Switchback Railway. The ride was an instant success, drawing long lines of eager riders . The idea of the gravity ride spread quickly, leading to great diversity in roller coaster design.


I had the bag of stilnox for a few weeks, obtained from an overseas pharmacy for my insomnia. I knew that it wasn't a long term solution and could actually make the problem worse, but I vowed to use responsibly. I had a brief rx for it before which I obtained for mostly recreational curiosity. I found it to be visual (producing wavy patterning-like effects with 15 to 20mg) and somewhat euphoric. Also I felt lousy one morning after taking 3 (I got uninhibited and took 2 more than I had to go to bed. I didn't take this effect seriously).
I'd consider myself an experienced and responsible occasional user of mostly psychedelic substances. I admit some opiate addiction troubles, but don't attribute that addictive behavior to my ambien binges. I have used zolpidem to relax in addition to sleep, but in my sober or even altered-on-whatever-besides-ambien mind, would NEVER take so many pills of anything.
So, it was a cold rainy night. I was feeling down and stressed. At 9pm, I took out my big bag of 'ambien', counted them, then took 2 10mg pills. I laid down and turned on The Simpsons. In 15 minutes I already felt the relaxing yet strange feeling. I enjoyed it, especially as my anxiety slowly drifted away. At about 9:45, I felt so nice that I wanted more. I took another 2. At a little past 10, I saw ripples forming on the floor. It was as if looking through a cup of water, but this only was for the ground. My balance was off. Bart's head took on a strange appearance, one I'd associate with the look of myself in the mirror a while later. The only way I could remotely describe it is it was as if I was looking at myself or the Simpsons characters as if we were miles away, but I was using a very powerful telescope to bring us up close. I felt happy and fun. I wished I felt like this all the time. I didn't want to sleep, I wanted to enjoy this...
There are just flashes and brief clips of what happened. The next crystal clear memory is waking up at 9am, feeling absolutely horrible. This was slightly worse than my worst alcohol hangover. It felt like a combo between bad alcohol and a bad ecstasy crash. I forced myself up to get a drink.  Right away I noticed things in the room of a strange out of place nature...
The garbage can and 2 feet in diameter around it was covered with yellow puke. There was a spilled cup of water on my nightstand. There was a spilled mug of water on the floor, along with a spoon containing a dried up cotton ball, syringe with no cap on, 4 'o' sized red marks on the leg, burned cheese in the skillet, about 30 empty wrappers of sliced cheese on the counter and floor, astroglide lube laying face down with ooze all over it (along with astroglide on my door and the shared bathroom's door, in addition to all my remote controls, keyboard and mouse), movies from my neatly organized cabinet all over the floor by the TV, and finally, when I moved the mouse to turn off my screensaver, a first person shooter game was up displaying a message 'Kicked for Teamkilling'.
I skipped classes and stayed in bed, feeling absolutely wrecked. I fixed up a few 'out of place' objects then counted my pills. I had 'lost' 9. My half gram of ketamine stash was completely gone, except for the 200 or so mg spilled scattered in a small carpet spot.
I recall very little after the 40mg was going strong. I don't remember injecting (I usually use K in the IM method, in the thigh), or how sterile I was. I later came to realize from flashes of brief memory that I had two K doses, when the first wore off I clumsily injected the rest minus what I'd spilled. I remember what was happening as the K was wearing off. I wasn't I, laying down and everything in the room was recognized by my brain as a living thing, in an insane city block-sized blur spinning rapidly. I didn't know what I was, but this odd reality was fading quickly and I was coming back into my room and body. When I came back I became very sick and vomited violently.
After this experience last week, I've done zolpidem twice more, trying to be more careful. It doesn't work like that. The two most recent both involve me not sleeping and eating a few more, although I didn't indulge in any other substances or make a mess. The day-afters have been hard, I regret buying the pills at all. It is tempting on a lonely boring night, knowing that it will provide a significant mood lift and a restful sleep. But I can't fool myself much longer, the stuff is dangerous, especially due to the way it destroys my inhibitions and takes away memory of the foolish behavior that follows.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


HTML and CSS are two sides of the same coin, though you can have the former without the latter. HTML dictates the content that will be displayed on the web page, and CSS dictates how the content will be displayed (styling!). Think of it as though you were baking a cake. The cake mixture is the thing that you will eat, and the icing is the thing that you will use to decorate it (and also eat!).
Control flow is the order in which the code in any given program is being executed. A loop is a sequence of instructions that allows said code to be executed repeatedly until a certain condition has been reached. Think of the two like washing the dishes––the control flow is the order that you wash the dishes in (hopefully cleanest to dirtiest and glassware through to pots and pans!!), and the loop is the repeated process of washing each dish until all of them have been cleaned.
The DOM is a feature that allows the modification and manipulation of a web page without affecting the web page document in real time. You can use it to alter the way a web page looks without actually affecting the official website––all of the changes made are only on your own browser and will be deleted upon refresing the page.
An array is a single variable used to store different elements. An object is comparable to an everyday object, something that has its own properties. An array stores a collection of data whereas an object is a collection of properties.The former allows you to distinguish between different variables while the latter holds an association between a name and a value.
A function is defined by what it aims to do and is a process that performs a task in Javascript. A function is useful because it allows you to assign a single method to various objects without having to write out the same code repeatedly each time.


An Ordered and an Unordered List
My favorite bands
(in no particular order)
- The Birthday Massacre
- Kill Hannah
- Shiny Toy Guns
- My Chemical Romance
- Ghostland Observatory
- She
Vitamin C content of fruits
(in descending order)
- Orange - 138mg
- Peach - 94mg
- Kiwi - 93mg
- Grape - 83mg
- Papaya - 62mg
per 100 gram serving
Link back to Pliny's homepage


The AI•ON values
Openness
- Anyone can join AI•ON as a research contributor. We do not screen members based on education credentials, affiliation, or any other attribute. Contributions should speak on their own merit.
- All code deliverables are open-sourced. In particular, all experiments released by AI•ON should be accompanied by properly documented open-source code to reproduce them.
- The entirety of the research process should take place in the open, and in particular all communications between researchers should be public and archived.
- Anyone can submit research problems to be considered by AI•ON. The problems we publish on our website are carefully curated, but the curation process is in the hands of the community and takes place in the open.
Science
- We are committed to advancing science in a meaningful way. We will only publish on our website problems that we believe are both important and scientifically sound, and that can maximize the impact we can have using our limited resources. We achieve this through rigorous curation of the proposed research problems.
- The fact that anyone can jump into the research process regardless of affiliation or credentials should lead to more robust findings and faster progress, not to shoddiness. We achieve this through an uncompromising adherence to the scientific method throughout each and every of our projects. Because the entire research process takes place in the open and involves many independent and disinterest individuals, we can set a standard of scientific rigor that would be unrealistic in academia or industry. No trust required: every claim can be quickly verified, every experiment can be easily reproduced.
Learning
- As of 2016, there is a tremendous amount of student interest in artificial intelligence and machine learning, and the supply of learning opportunities is no longer keeping up with the demand. Machine learning conferences and machine learning classes at universities everywhere are overflowing. This will only get more dire in the next few years. As a result, there is a pressing need for alternative learning avenues for newcomers to the field. We are committed to growing AI•ON into a viable, large-scale process to educate the machine learning experts that the world will need in coming years.
- We believe that the best way to learn is by working as a team on applied projects. Learn by doing, and collaborate with others both in quality of mentor and mentee.
- We believe that a core tenet of learning and teaching, which is often overlooked, is sustainable motivation. Student projects are sometimes devoid of meaning beyond the walls of the university, which undermines student motivation and thus adversely affects the learning experience. Applied research propects proposed by AI•ON all deal with meaningful, real problems, and as result the solutions developed by AI•ON contributors are likely to find impactful applications in the real world. We believe this is the best way to solve the problem of sustainable motivation.
Community
- Research can be done in isolation. Learning can be done in isolation. However, we believe that contact with others can accelerate research and learning by several orders of magnitude. Communication is a catalyzer of progress, and in an age where communication is free and reaches globally, we intend on maximally leveraging this catalyzer.
- This goes beyond teaching, passing on best practices, or mentorship. As a community, we can tackle problems that would have been out of reach for us as a collection of individuals: we can crowd-source data on a large scale, we can brainstorm ideas far and wide across scientific fields, and we may even be able to pool computing resources in the future.
Acknowledgments
We would like to thank the following projects for showing the way and providing inspiration for the launch of AI•ON:
- Arxiv, the pulse of the artificial intelligence research community.
- Github, and the open-source community that has grown around it.
- Kaggle and its community.
Chronology


Pingchuan Ma (馬平川) is a first-year Ph.D. student at MIT CSAIL, advised by Prof. Wojciech Matusik. Previously, he worked with Prof. Ming-Ming Cheng and Prof. Bo Ren at Nankai University. He also conducted research at ByteDance AI Lab, SenseTime Research and HKU.
Hover your cursor on my photo and you will see my cat - Mr. McFlurry. I love him <3


Controlling the subconcious mind
The subconcious is the like the cellar of the mind. It contains many past thoughts. It needs to be cleared in order for the concious mind to be control. Uncleared, it acts as an opposing force, seeking to re-manifest the past thoughts.
To clear the barriers in one’s subconcious, one has to think Holy thoughts continuous. So as to clear out or perhaps re-program the subconcious.
Beware a trick of the Mind
“It is foolishness to worry about the future while allowing the devil to conquer the present.”
The challenges of spiritual life is very simple: to be good, truly moral and master of ourselves for only this moment. What time is there outside this moment, that we should worry about it?
The simplest and surest method of controlling the mind
Love God. But if you do not believe in God, than believe in yourself.
Summary
Mind-control has always, been a difficult task even for a heroic person; but it is not an impossible one. There are well-defined methods.
The entire secret of controlling the mind is given by Sri Krsna in the two words abhydsa and vairagya, practice and dispassion.
To bring these two disciplines into the stream of our life: we have to develop a strong will to control the mind; we have to understand the nature of our mind; we have to learn certain techniques and practise them.
In order to strengthen the will, we need to overcome our pleasure-motive and’also understand what is involved in controlling the mind.
The nature of the mind is explained from the Hindu point of view in The Complete Works of Swami Vivekananda.
To be able to control our mind we must know how not to make our task unnecessarily difficult.
Mind-control is the personal task of the person concerned. The object of mind-control is the realization of our absolute oneness with the Divine. For this no price can be too great to pay.
“To be able to practise effectively the disciplines leading to mind-control we need a favourable inner climate. This includes the capacity to accept certain features of life as inevitable.
For controlling the mind we need two sets of inner disciplines: one to give a healthy general direction to the mind, and the other to save us in emergencies.”
“The purer the mind, the easier it is to control. So we should practise disciplines for the purification of the mind. Our object should be to bring about a preponderance of sattw in our inner nature, and then to transcend sattva by purifying it according * to authentic disciplines.”
“The easiest method of doing tins, however, is cultivating holy company.
The Vedantic disciplines can be helpfully supplemented by the Yoga disciplines taught by Patanjali.
Along with the practice of the disciplines of Yoga should go the practice of discrimination. Then we shall be able to train the mind to behave. When it has been trained to behave, the senses will have been trained not to come in contact with their objects, but to obey the mind. Then pratydhara will have been achieved.
Certain ancillary measures which greatly help the effective practice of the main disciplines should be given attention. These measures are: keeping our human relationships in order; giving the mind a healthy occupation; making right use of the imagination; and guarding against despondency.
Mind-control is greatly helped by the practice of meditation, and meditation by mind-control.
In explosive inner situations to apply highpower emergency brakes, Patafijalfs teaching is: practise thinking contrary thoughts. Ceaseless chanting of the Lords name and also taking refuge in God help.”
“Methodical control of thought is a great secret in controlling the mind.
Without controlling the subconscious, the mind cannot be controlled. The subconscious can be controlled by pouring holy thought into it, as it were, and by the practice of Prdnaydma and other disciplines, among which is bhaktL These rouse the kundalinl, the latent spiritual power in a person.
We must beware of a harmful kind of imagination. By being truly moral only for this moment, and then at the next moment for the next moment, and so on always we can guard against such a possibility.
Believers are at an advantage in controlling the mind.
The simplest and surest method of controlling the mind is through love of God.
Those who do not believe in God can control the mind by transcending the gunas through self-effort.
Mind-control is valuable because it leads to the highest blessing —the illumined state of being,”


Guide for GEOPM Developers
These are instructions for a developer that would like to modify the
source code in the GEOPM git repository. The GEOPM repository
contains two independent autotools based build systems that are used
to compile, test and install software components written in C++ and
Python. The service
subdirectory of the GEOPM repository contains
all files related to the GEOPM systemd service including the build
system and all source code for the software components. The base
directory of the GEOPM git repository is populated with a build system
that supports all software components not located in the service
directory. The base build depends solely on components in the
service
directory that are installed by the service build
including: the libgeopmd.so
library, the C and C++ public
interface header files for that library, and the geopmdpy
Python
module.
Prior to following the build steps, it’s recommended to get familiar with the build requirements for the GEOPM service and the GEOPM HPC runtime.
Developer Build Process
The basic procedure for building all of the software in the GEOPM repository is to run the following commands within the base of the GEOPM repository:
# Build the geopm-service package
cd service/
./autogen.sh
./configure
make
# Optionally, build the GEOPM HPC runtime package
cd ..
./autogen.sh
./configure
make
After the build is complete, a developer may wish to execute the unit
tests. Each of the two builds has a check
target for their
makefiles. The test programs may be built separately from the
check
target by specifying the checkprogs
make target.
# Run the geopm-service package unit tests
cd service/
make checkprogs
make check
# Optionally run the GEOPM HPC runtime package unit tests
cd ..
make checkprogs
make check
The developer may be interested in installing the build artifacts to a separate directory. In this case, the build process differs slightly: some extra options will be provided to configure.
# Define the install location
GEOPM_INSTALL=$HOME/build/geopm
# Build the geopm-service package
cd service/
./autogen.sh
./configure --prefix=$GEOPM_INSTALL
make
make install
# Optionally, build the GEOPM HPC runtime package
cd ..
./autogen.sh
./configure --prefix=$GEOPM_INSTALL --with-geopmd=$GEOPM_INSTALL
make
make install
The libraries, binaries and python tools will not be installed into
the standard system paths if GEOPM is built from source and configured
with the --prefix
option. In this case, it is required that the
user augment their environment to specify the installed location. If
the configure option is specified as above. then the following
modifications to the user’s environment should be made prior to
running any GEOPM tools:
export LD_LIBRARY_PATH=$GEOPM_INSTALL/lib:$LD_LIBRARY_PATH
export PATH=$GEOPM_INSTALL/bin:$PATH
export PYTHONPATH=$(ls -d $GEOPM_INSTALL/lib/python*/site-packages | tail -n1):$PYTHONPATH
Use a PYTHONPATH that points to the site-packages created by the geopm build. The version created is for whichever version of python 3 was used in the configure step. If a different version of python is desired, override the default with the –with-python option in the configure script.
Configuring the Build
There are many options that may be passed to each of the two configure
scripts that are part of the GEOPM repository build system. Two
scripts called autogen.sh
are provided, one in the base of the
GEOPM repository and the other in the service directory. Each of
these scripts manage the GEOPM version that is embedded in the build
artifacts, and create the two configure
scripts using the
autotools package.
Running the configure scripts generates a number of output files,
including the Makefile
that is used for the rest of the build
steps. The configure
scripts accept a large number of command line
options, and environment variables that affect the behavior.
Each configure script will provide user documentation through the
./configure --help
command. Some important options and
environment variables are listed below.
Both configure scripts
--prefix
Path prefix for install artifacts--enable-debug
Create more verbose error and warning messaging and disable optimization.--enable-coverage
Enable coverage report generation with gcovexport CC=
Set the C compiler with environment variableexport CXX=
Set the C++ compiler with environment variable
Service configure script
--enable-nvml
Add support for the Nvidia NVML library--enable-levelzero
Add support for OneAPI LevelZero--disable-systemd
Do not build GEOPM Service access into PlatformIO
Base configure script
--with-geopmd=
Provide install location of the service build--disable-mpi
Build the base directory without MPI dependencies--disable-fortran
Build the base directory without fortran dependencies--disable-openmp
Build the base directory without OpenMP dependenciesexport FC=
Set the Fortran compiler with environment variableexport F77=
Set the Fortran 77 compiler with environment variableexport MPICC=
Set the MPI C compiler wrapper with environment variableexport MPICXX=
Set the MPI C++ compiler wrapper with environment variableexport MPIFC=
Set the Fortran compiler wrapper with environment variableexport MPIF77=
Set the Fortran 77 compiler wrapper with environment variable
Intel Compiler and MPI Toolchain
To enable the use of the Intel toolchain for both the compiler and MPI support, export the following variables prior to configuring the base build of the GEOPM repository:
export CC=icc
export CXX=icpc
export FC=ifort
export F77=ifort
export MPICC=mpiicc
export MPICXX=mpiicpc
export MPIFC=mpiifort
export MPIF77=mpiifort
We recommend using the system compiler toolchain for compiling the
GEOPM service when creating an installed RPM. The make rpm
target
of the service directory uses the geopm-service spec file to ensure
that the system GCC toolchain is used to create the RPM.
Coverage Instructions
To generate a coverage report, first be sure that you have installed the lcov package. Note that if you are using GCC 9 or above, you must use lcov v1.15 or later to work around this issue.
The lcov source is available here:
https://github.com/linux-test-project/lcov
The GEOPM build must be configured with the “–enable-coverage” option prior to running the tests. Then in either the service directory or the root directory, simply run
make coverage
which runs the corresponding unit tests and produces a coverage report in
./coverage/index.html
Note that all tests must pass in order to generate a coverage report. Any help in increasing code coverage levels is appreciated.
Coding Style
Python code should follow the PEP8 standard as described in https://peps.python.org/pep-0008/.
C++ code can be corrected to conform to the GEOPM standard using astyle with the following options:
astyle --style=linux --indent=spaces=4 -y -S -C -N
Note that astyle is not perfect (in particular it is confused by C++11 initializer lists), and some versions of astyle will format the code slightly differently.
Use C style variable names with lower case and underscores. Upper camel case is used exclusively for class names. Prefix all member variables with “m” and all global variables with “g“.
Please avoid global variables as much as possible and if it is necessary to use a global (primarily for C code) please scope them statically to the compilation unit.
Avoid preprocessor macros as much as possible (use enum not #define). Preprocessor usage should be reserved for expressing configure time options.
Pre-Commit Checks
This repository includes a configuration for pre-commit that uses some of their standard hooks that are relevant to GEOPM, and adds a hook that performs the GEOPM license checks.
To install the pre-commit infrastructure and our configuration:
pip install pre-commit
pre-commit install
Now you will automatically run some checks whenever you make a commit, instead of waiting until you make a pull request to see all of them.
License Headers
Introducing a new file requires a license comment in its header with a corresponding copying_headers/header.* file. The new file path must be listed in the corresponding copying_headers/MANIFEST.* file. This can be tested by running the copying_headers/test_license script after committing the new file to git, and rerunning the autogen.sh script. Files for which a license comment is not appropriate should be listed in copying_headers/MANIFEST.EXEMPT. Any new installed files should also be added to specs/geopm.spec.in or service/geopm-service.spec.in.
Creating Manuals
Introducing a new man page requires changes in multiple files:
The build target (man page) should be added to rst_file in conf.py
The rst source file should be added to EXTRA_DIST in service/docs/Makefile.mk
The build target (man page) should be added to dist_man_MANS in service/docs/Makefile.mk
The rst source file should be added to copying_headers/MANIFEST.EXEMPT as described above.
The gzipped installed man page should be listed in the %files section of geopm-service.spec.in
A link to the new html page should be added to the SEE ALSO section of geopm.7.rst and any other related man pages.
Note
In addition, new documentation should follow the style guidelines defined here:


Translates a CSS3 selector into an equivalent XPath expression. This allows us to use CSS selectors when working with the XML package as it can only evaluate XPath expressions. Also provided are convenience functions useful for using CSS selectors on XML nodes. This package is a port of the Python package 'cssselect' (<https://cssselect.readthedocs.io/>).
| Version: | 0.4-1 |
| Depends: | R (≥ 3.0) |
| Imports: | methods, stringr, R6 |
| Suggests: | testthat, XML, xml2 |
| Published: | 2018-04-06 |
| Author: | Simon Potter [aut, trl, cre], Simon Sapin [aut], Ian Bicking [aut] |
| Maintainer: | Simon Potter <simon at sjp.co.nz> |
| BugReports: | https://github.com/sjp/selectr/issues |
| License: | BSD_3_clause + file LICENCE |
| URL: | https://sjp.co.nz/projects/selectr |
| NeedsCompilation: | no |
| Citation: | selectr citation info |
| Materials: | README NEWS |
| CRAN checks: | selectr results |
| Reference manual: | selectr.pdf |
| Package source: | selectr_0.4-1.tar.gz |
| Windows binaries: | r-devel: selectr_0.4-1.zip, r-release: selectr_0.4-1.zip, r-oldrel: selectr_0.4-1.zip |
| OS X binaries: | r-release: selectr_0.4-1.tgz, r-oldrel: selectr_0.4-1.tgz |
| Old sources: | selectr archive |
| Reverse imports: | cliapp, ganalytics, Rcrawler, rvest, wikilake |
| Reverse suggests: | aire.zmvm, unpivotr |
Please use the canonical form https://CRAN.R-project.org/package=selectr to link to this page.


{% extends "base.html" %} {% block title %}Cancer Hallmarks Analytics Tool{% endblock %} {% block content %}
The Cancer Hallmarks Analytics Tool (CHAT) allows users to quickly and easily analyze the strength of association between terms of interest and the hallmarks of cancer (Hanahan and Weinberg 2011; PubMed, PDF) in the literature based on a text-mining analysis of 26 million PubMed abstracts.
To analyze the association of any term with the hallmarks of cancer, simply enter the term into the "Query" text box on the CHAT homepage and press "Submit".
The resulting screen will show a chart summarising the association of the query term (below "p53") with the various hallmarks of cancer.
To compare the strength of association between two terms with the hallmarks of cancer, click on the "Compare" tab on the CHAT homepage, enter the two terms in the "Query" text boxes and press "Submit".
CHAT will then show a chart comparing the strength of association of the two terms (below "Mdm2" and "mTOR") with the hallmarks of cancer.
CHAT supports the following metrics for assessing the strength of association between a hallmark (h) and a query (q):
To change the metric to apply, use the Metric selector found in both the Search and Compare tabs as well as on the top of their respective result pages. For interpretation of the metrics, see the following sections.
The value c(h,q) of the count metric for a hallmark h and a query q is simply the number of contexts where both h and q occur. While the count metric is easy to understand, direct comparisons of count values can be misleading because raw co-occurrence counts do not normalize over the number of times that h and q occur overall.
For example, if hallmark h1 is discussed in the literature more often than h2 (e.g. Invasion and metastasis compared to Replicative immortality), then a query q may be more strongly (statistically) associated with h2 than h1 even if c(h1,q) is greater than c(h2,q): the larger co-occurrence count may simply reflect h1 being more frequent.
Similarly, for two queries q1 and q2, if q1 occurs more frequently in the literature than q2 (e.g. "TP53" vs. "BRCA2"), c(h,q1) > c(h,q2) does not necessarily indicate a stronger association of hallmark h with q1 than with q2.
The conditional probability p(h|q) of a hallmark h occurring in a context where a query term q has occurred is defined as the co-occurrence count c(h,q) divided by the overall count of the query term c(q).
Unlike count (see above), the cprob metric takes into account the overall frequency of the query term, normalizing by this value. This allows more meaningful comparison of cprob values across queries where the terms are not discussed in the literature with similar frequency.
For example, this comparison shows that "autotaxin" has a much higher cprob value with Invasion and metastasis than "Akt" does, despite the latter much more common term having a higher co-occurrence count with this hallmark (see here)
Pointwise mutual information pmi (h,q) is an information-theoretic metric of association strength that measures how often a hallmark h and a query q occur together compared to how often they would be expected to co-occur if their occurrences were independent (i.e. if they only co-occurred at random).
pmi (h,q) is defined as base-2 logarithm (measuring information in bits) of of the probability of co-occurrence p(h,q) divided by the product of the occurrence probabilities p(h)p(q). These probabilities are derived directly from the counts (see above).
pmi accounts for the overall frequency of both the query and the hallmark and its values are interpretable in that pmi (h,q) = 0 when p and q are independent, > 0 when they co-occur more often than expected from random co-occurrence, and < 0 when less often (negative association).
While a pmi value of zero indicates no association (see above), values of the metric for positive associations can be difficult to interpret and compare as the maximum pmi (h,q) value increases when the query terms q and hallmarks h become less common (see e.g. Manning and Schütze 1999, Sec 5.4).
The npmi metric normalizes pmi by dividing by the negative log probability of co-occurrence -log2 p(h,q), which constrains its values to the range [-1, 1].
npmi maintains the benefits of pmi but is also more easily interpreted and compared. Regardless of the overall frequency of h and q, a npmi (h,q) value of -1 indicates no co-occurrence, 0 a frequency of co-occurrence matching random (no association, as for pmi) and 1 complete co-occurrence (perfect association).
CHAT organizes cancer-related concepts using a taxonomy based on the hallmarks of cancer (Hanahan and Weinberg 2000; 2011) and supports two different granularities of analysis:
The full hallmarks provide finer granularity while the top hallmarks feature greater reliability to their higher frequency.
To change the granularity, use the Hallmarks selector found in the Search and Compare tabs and on the result pages.
To "drill down" from a chart view to the documents and annotations serving as its source data, click on the relevant part of the chart.
For example, after querying for "p53", clicking on the segment of the chart denoting "resisting cell death" shows summaries of PubMed documents relating to the association of p53 with resisting cell death.
Clicking further on any of the titles gives a visualization of all hallmark annotations for that PubMed document.


Direction:
end
start
Duration:
Play
Animation Status:
Not Start
Time Line:
0
s
Sequence of Animation


profile
friends
adittitonal information
Additionl informatrion
Student at
Vinsa
Born in Sliven
Live in Varna
working at
Poker stars


Select one of a set of elements.
This is paragraph 1
This is paragraph 2
This is paragraph 3
This is paragraph 4