| I l@ve RuBoard |
The C++ standard library provides the class valarray for the processing of arrays of numeric values. A valarray is a representation of the mathematical concept of a linear sequence of values. It has one dimension, but you can get the illusion of higher dimensionality by special techniques of computed indices and powerful subsetting capabilities. Therefore, a valarray can be used as a base both for vector and matrix operations as well as for the processing of mathematical systems of polynomial equations with good performance.
The valarray classes enable some tricky optimizations to get good performance for the processing of value arrays. However, it is not clear how important this component of the C++ standard library will be in the future because there are other interesting developments that perform even better. One of the most interesting examples is the Blitz system. If you are interested in numeric processing, you should look at it. For details, see http://monet.uwaterloo.ca/blitz/.
The valarray classes were not designed very well. In fact, nobody tried to determine whether the final specification worked. This happened because nobody felt "responsible" for these classes. The people who introduced valarrays to the C++ standard library left the committee a long time before the standard was finished. For example, to use valarrays, you often need some inconvenient and time-consuming type conversions (see page 554).
Valarrays are one-dimensional arrays with elements numbered sequentially from zero. They provide the ability to do some numeric processing for all or a subset of the values in one or more value arrays. For example, you can process the statement
z = a*x*x + b*x + c
with a, b, c, x, and z being arrays that contain hundreds of numeric values. In doing this, you have the advantage of a simple notation. Also, the processing is done with good performance because the classes provide some optimizations that avoid the creation of temporary objects while processing the whole statement. In addition, special interfaces and auxiliary classes provide the ability to process only a certain subset of value arrays or to do some multidimensional processing. In this way, the valarray concept also helps to implement vector and matrix operations and classes.
The standard guarantees that valarrays are alias free. That is, any value of a nonconstant valarray is accessed through a unique path. Thus, operations on these values can get optimized better because the compiler does not have to take into account that the data could be accessed through another path.
Valarrays are declared in the header file <valarray>:
#include <valarray>
In particular, in <valarray> the following classes are declared:
namespace std { template<class T> class valarray; // numeric array of type T class slice; // slice out of a valarray template<class T> class slice_array; class gslice; // a generalized slice template<class T> class gslice_array; template<class T> class mask_array; // a masked valarray template<class T> class indirect_array; // an indirected valarray }
The classes have the following meanings:
valarray is the core class that manages an array of numeric values.
slice and gslice arc provided to define a BLAS-like[4] slice as a subset of a valarray.
[4] The Basic Linear Algebra Subprograms (BLAS) library provides computational kernels for several of the fundamental linear algebra operations, such as matrix multiply, the solution of triangular systems, and simple vector operations.
slice_array, gslice_array, mask_array, and indirect_array are internal auxiliary classes that are used to store temporary values or data. You can't use them in your programming interface directly. They are created indirectly by certain valarray operations.
All classes are templatized for the type of the elements. In principle, the type could be any data type. However, according to the nature of valarrays it should be a numeric data type.
When you create a valarray you usually pass the number of elements as a parameter:
std::valarray<int> va1(10); // valarray of ten ints with value 0 std::valarray<float> va2(5.7, 10); // valarray of ten floats with value 5.7 // (note the order)
If you pass one argument, it is used as the size. The elements are initialized by the default constructor of their type. Elements of fundamental data types are initialized by zero (see Section 2.2.2, for a description of why fundamental data types may be initialized by a default constructor). If you pass a second value, the first is used as the initial value for the elements, whereas the second specifies the number of elements. Note that the order of passing two arguments to the constructor differs from that of all other classes of the C++ standard library. All STL container classes use the first numeric argument as the number of elements and the second argument as the initial value.
You can also initialize a valarray with an ordinary array:
int array[] = { 3, 6, 18, 3, 22 }; // initialize valarray by elements of an ordinary array std::valarray<int> va3(array, sizeof (array)/sizeof (array[0])); // initialize by the second to the fourth element std::valarray<int> va4(array+1, 3);
The valarray creates copies of the passed values. Thus, you can pass temporary data for initialization.
For valarrays, the subscript operator is defined to access the element of a valarray. As usual, the first element has the index 0:
va[0] = 3 * va[1] + va[2];
In addition, all ordinary numeric operators are defined (addition, subtraction, multiplication, modulo, negation, bit operators, comparison operators, and logical operators, as well as all assignment operators). These operators are called for each element in the valarrays that is processed by the operation. Thus, the result of a valarray operation is a valarray that has the same number of elements as the operands and that contains the result of the elementwise computation. For example, the statement
va1 = va2 * va3;
is equivalent to
va1[0] = va2[0] * va3[0]; va1[l] = va2[l] * va3[l]; va1[2] = va2[2] * va3[2]; ...
If the number of elements of the combined valarrays differs, the result is undefined.
Of course, the operations are available only if the element's type supports them. And the exact meaning of the operation depends on the meaning of the operation for the elements. Thus, all of these operations simply do the same for each element or pair of elements in the valarrays they process.
For binary operations, one of the operands may be a single value of the element's type. In this case, the single value is combined with each element of the valarray that is used as the other operand. For example, the statement
va1 = 4 * va2;
is equivalent to
va1[0] = 4 * va2[0]; va1[1] = 4 * va2[l]; va1[2] = 4 * va2[2]; ...
Note that the type of the single value has to match exactly the element type of the valarray. Thus, the previous example works only if the element type is int. The following statement would fail:
std::valarray<double> va(20); ... va = 4 * va; // ERROR: type mismatch
The schema of binary operations also applies to comparison operators. Thus, operator == does not return a single Boolean value that shows whether both valarrays are equal. Instead, it returns a new valarray with the same number of elements of type bool, where each value is the result of the individual comparison. For example, in the following code
std::valarray<double> val(10); std::valarray<double> va2(10); std::valarray<bool> vab(10); ... vab = (va1 == va2);
the last statement is equivalent to
vab[0] = (va1[0] == va2[0]); vab[1] = (va1[1] == va2[1]); vab[2] = (va1[2] == va2[2]); ... vab[9] = (va1 [9] == va2[9]);
For this reason, you can't sort valarrays by using operator <, and you can't use them as elements in STL containers if the test for equality is performed with operator == (see Section 5.10.1, for the requirements of elements of STL containers).
The following program demonstrates a simple use of valarrays:
// num/val1.cpp #include <iostream> #include <valarray> using namespace std; // print valarray template <class T> void printValarray (const valarray<T>& va) { for (int i=0; i<va.size(); i++) { cout << va[i] << ' '; } cout << endl; } int main() { // define two valarrays with ten elements valarray<double> va1(10), va2(10); // assign values 0.0, 1.1, up to 9.9 to the first valarray for (int i=0; i<10; i++) { va1[i] = i * 1.1; } // assign -1 to all elements of the second valarray va2 = -1; // print both valarrays printValarray(va1); printValarray(va2); // print minimum, maximum, and sum of the first valarray cout << "min(): " << val.min() << endl; cout << "max(): " << val.max() << endl; cout << "sum(): " << val.sum() << endl; // assign values of the first to the second valarray va2 = va1; // remove all elements of the first valarray va1.resize (0); // print both valarrays again printValarray(va1); printValarray(va2); }
The program has the following output:
0 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9 -1 -1 -1 -1 -1 -1 -1 -1 -1 -1 min():0 max(): 9.9 sum(): 49.5 0 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9
The transcendental operations (trigonometric and exponential) are defined as equivalent to the numeric operators. The operations are performed with all elements in the valarrays, and for binary operations, one of the operands may be a single value, which is used as one operand, with all elements of the valarrays as the other operand.
All of these operations are defined as global functions instead of member functions. This is to provide automatic type conversion for subsets of valarrays for both operands (subsets of valarrays are covered in Section 12.2.2,).
Here is a second example of the use of valarrays. It demonstrates the use of transcendental operations:
// num/val2.cpp #include <iostream> #include <valarray> using namespace std; // print valarray template <class T> void printValarray (const valarray<T>& va) { for (int i=0; i<va.size(); i++) { cout << va[i] << ' '; } cout << endl; } int main() { // create and initialize valarray with nine elements valarray<double> va(9); for (int i=0; i<va.size(); i++) { va[i] = i * 1.1; } // print valarray printValarray(va); // double values in the valarray va *= 2.0; // print valarray again printValarray(va); // create second valarray initialized by the values of the first plus 10 valarray<double> vb(va+10.0); // print second valarray printValarray(vb); // create third valarray as a result of processing both existing valarrays valarray<double> vc; vc = sqrt(va) + vb/2.0 - 1.0; // print third valarray printValarray(vc); }
The program has the following output:
0 1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 0 2.2 4.4 6.6 8.8 11 13.2 15.4 17.6 10 12.2 14.4 16.6 18.8 21 23.2 25.4 27.6 4 6.58324 8.29762 9.86905 11.3665 12.8166 14.2332 15.6243 16.9952
The subscript operator [] is overloaded for special auxiliary objects of valarrays. These auxiliary objects define subsets of valarrays in different ways. In doing this, they provide an elegant way to operate on certain subsets of valarrays (with both read and write access).
The subset of a valarray is defined by using a certain subset definition as the index. For example:
va[std::slice (2, 4, 3)] // four elements with distance 3 starting from index 2 va[va>7] // all elements with a value greater than 7
If a subset definition such as std::slice(2, 4, 3) or va>7 is used with a constant valarray, the expression returns a new valarray with the corresponding elements. However, if such a subset definition is used with a nonconstant valarray, the expression returns a temporary object of a special auxiliary valarray class. This temporary object does not contain the subset values, only the definition of the subset. Thus, the evaluation of expressions is deferred until the values are needed to compute a final result.
This mechanism is called lazy evaluation. It has the advantage that no temporary values for expressions are computed. This saves time and memory. In addition, the technique provides reference semantics. Thus, the subsets are logical sets of references to the original values. You can use these subsets as the destination (lvalue) of a statement. For example, you could assign one subset of a valarray the result of a multiplication of two other subsets of the same valarray (examples follow shortly).
However, because "temporaries" are avoided, some unexpected conditions might occur when elements in the destination subset are also used in a source subset. Therefore, any operation of valarrays is guaranteed to work only if the elements of the destination subset and the elements of all source subsets are distinct.
With smart definitions of subsets you can give valarrays the semantics of two or more dimensions. Thus, in a way, valarrays may be used as multidimensional arrays.
There are four ways to define subsets of valarrays:
Slices
General slices
Masked subsets
Indirect subsets
The following subsections discuss them and give examples.
Before I start with the individual subsets, I have to mention a general problem. The handling of valarray subsets is not well designed. You can create subsets easily, but you can't combine them easily with other subsets. Unfortunately, you almost always need an explicit type conversion to valarray. This is because the C++ standard library does not specify that valarray subsets provide the same operations as valarrays.
For example, to multiply two subsets and assign the result to a third subset, you can't write the following:
// ERROR: conversions missing va[std::slice(0,4,3)] = va[std::slice (1,4,3)] * va[std::slice (2,4,3)];
Instead, you have to code by using a new-style cast (see page 19)[5] :
[5] Note that you have to put a space between the two ">" characters. ">>" would be parsed as shift operator, which would result in a syntax error.
va[std::slice (0,4,3)] = static_cast<std::valarray<double> >(va[std::slice (l,4,3)]) * static_cast<std::valarray<double> >(va[std::slice (2,4,3)]);
or by using an old-style cast:
va[std::slice(0,4,3)] = std::valarray<double>(va[std::slice (1,4,3)]) * std::valarray<double>(va[std::slice (2,4,3)]);
This is tedious and error prone. Even worse, without good optimization it may cost performance because each cast creates a temporary object, which could be avoided without the cast.
To make the handling a bit more convenient, you can use the following template function:
/* template to convert valarray subset into valarray */ template <class T> inline std::valarray<typename T::value_type> VA (const T& valarray_subset) { return std::valarray<typename T::value_type>(valarray_subset); }
By using this template, you could write
va[std::slice (0,4,3)] = VA(va[std::slice (l,4,3)]) * VA(va[std::slice (2,4,3)]); // OK
However, the performance penalty remains.
If you use a certain element type you could also use a simple type definition:
typedef valarray<double> VAD;
By using this type definition you could also write
va[std::slice (0,4,3)] = VAD(va[std::slice(l,4,3)]) * VAD (va[std:: slice (2,4,3)]); // OK
provided the elements of va have type double.
A slice defines a set of indices that has three properties:
The starting index
The number of elements (size)
The distance between elements (stride)
You can pass these three properties exactly in the same order as parameters to the constructor of class slice. For example, the following expression specifies four elements, starting with index 2 with distance 3:
std::slice (2,4,3)
In other words, the expression specifies the following set of indices:
2 5 8 11
The stride may be negative. For example, the expression
std::slice (9,5,-2)
specifies the following indices:
9 7 5 3 1
To define the subset of a valarray, you simply use a slice as an argument of the subscript operator. For example, the following expression specifies the subset of the valarray va that contains the elements with the indices 2, 5, 8, and 11:
va[std::slice (2,4,3)]
It's up to the caller to ensure that all these indices are valid.
If the subset qualified by a slice is a subset of a constant valarray, the subset is a new valarray. If the valarray is nonconstant, the subset has reference semantics to the original valarray. The auxiliary class slice_array is provided for this:
namespace std { class slice; template <class T> class slice_array; template <class T> class valarray { public: // slice of a constant valarray returns a new valarray valarray<T> operator[] (slice) const; // slice of a variable valarray returns a slice_array slice_array<T> operator[] (slice); ... }; }
For slice_arrays, the following operations are defined:
Assign a single value to all elements.
Assign another valarray (or valarray subset).
Call any computed assignment operation, such as operators += and *=.
For any other operation you have to convert the subset to a valarray (see page 554). Note that the class slice_array<> is intended purely as an internal helper class for slices, and it should be transparent to the user. Thus, all constructors and the assignment operator of class slice_array<> are private.
For example, the statement
va[std::slice (2,4,3)] = 2;
assigns 2 to the third, sixth, ninth, and twelfth elements of the valarray va. It is equivalent to the following statements:
va[2] = 2; va[5] = 2; va[8] = 2; va[11] = 2;
As another example, the following statement squares the values of the elements with index 2, 5, 8, and 11:
va[std::slice (2,4,3)] *= std::valarray<double>(va[std::slice(2,4,3)]);
As mentioned on page 554, you can't write
va[std::slice (2,4,3)] *= va[std::slice (2,4,3)]; // ERROR
But using the VA() template function mentioned on page 555, you can write
va[std::slice(2,4,3)] *= VA(va[std::slice (2,4,3)]);. // OK
By passing different slices of the same valarray you can combine different subsets and store the result in another subset of the valarray. For example, the statement
va[std::slice (0,4,3)] = VA(va[std::slice (l,4,3)]) * VA(va[std::slice (2,4,3)]);
is equivalent to the following:
va[0] = va[1] * va[2]; va[3] = va[4] * va[5]; va[6] = va[7] * va[8]; va[9] = va[10] * va[11];
If you consider your valarray as a two-dimensional matrix, this example is nothing else but vector multiplication (Figure 12.1). However, note that the order of the individual assignments is not defined. Therefore, the behavior is undefined if the destination subset contains elements that are used in the source subsets.
In the same way, more complicated statements are possible. For example:
va[std::slice (0,100,3)] = std::pow(VA(va[std::slice (l,100,3)]) * 5.0, VA(va[std::slice (2,100,3)]));
Note again that a single value, such as 5.0 in this example, has to match the element type of the valarray exactly.
The following program demonstrates a complete example of using valarray slices:
// num/slice1.cpp #include <iostream> #include <valarray> using namespace std; // print valarray line-by-line template<class T> void printValarray (const valarray<T>& va, int num) { for (int i=0; i<va.size()/num; ++i) { for (int j=0; j<num; ++j) { cout << va[i*num+j] << ' '; } cout << endl; } cout << endl; } int main() { /* valarray with 12 elements * - four rows * - three columns */ valarray<double> va(12); // fill valarray with values for (int i=0; i<12; i++) { va[i] = i; } printValarray (va, 3); // first column = second column raised to the third column va [slice (0,4,3)] = pow (valarray<double>(va[slice (l,4,3)]), valarray<double>(va[slice (2,4,3)])); printValarray (va, 3); // create valarray with three times the third element of va valarray<double> vb(va[slice (2,4,0)]); // multiply the third column by the elements of vb va[slice (2,4,3)] *= vb; printValarray (va, 3); // print the square root of the elements in the second row printValarray (sqrt(valarray<double>(va[slice (3,3,1)])), 3); // double the elements in the third row va[slice (2,4,3)] = valarray<double>(va[slice (2,4,3)]) * 2.0; printValarray (va, 3); }
The program has the following output:
0 1 2 3 4 5 6 7 8 9 10 11 1 1 2 1024 4 5 5.7648e+006 7 8 1e+011 10 11 1 1 4 1024 4 10 5.7648e+006 7 16 1e+011 10 22 32 2 3.16228 1 1 8 1024 4 20 5.7648e+006 7 32 1e+011 10 44
General slices, or gslices, are the general form of slices. Similar to slices, which provide the ability to handle a subset that is one dimension out of two dimensions, gslices allow the handling of subsets of multidimensional arrays. In principle, gslices have the same properties as slices:
Starting index
Number of elements (size)
Distance between elements (stride)
Unlike slices, however, the number and distance of elements in a gslice are arrays of values. The number of elements in such an array is equivalent to the number of dimensions used. For example, if a gslice has the state
start: 2 size: [ 4 ] stride: [ 3 ]
then the gslice is equivalent to a slice because the array handles one dimension. Thus, it defines four elements with distance 3, starting with index 2:
2 5 8 11
However, if a gslice has the state
start: 2 size: [ 2 4] stride: [ 10 3]
then the gslice handles two dimensions. The smallest index handles the highest dimension. Thus, this gslice specifies starting from index 2, twice with distance 10, four elements with distance 3:
2 5 8 11 12 15 18 21
Here is an example of a slice with three dimensions:
start: 2 size: [ 3 2 4 ] stride: [ 30 10 3 ]
It specifies starting from index 2, three times with distance 30, twice with distance 10, four elements with distance 3:
2 5 8 11 12 15 18 21 32 35 38 41 42 45 48 51 62 65 68 71 72 75 78 81
The ability to use arrays to define size and stride is the only difference between gslices and slices. Apart from this, gslices behave the same as slices:
To define a concrete subset of a valarray, you simply pass a gslice as the argument to the subscript operator of the valarray.
If the valarray is constant, the resulting expression is a new valarray.
If the valarray is nonconstant, the resulting expression is a gslice_array that represents the elements of the valarray with reference semantics:
namespace std { class gslice; template <class T> class gslice_array; template <class T> class valarray { public: // gslice of a constant valarray returns a new valarray valarray<T> operator[] (const gslice&) const; // gslice of a variable valarray returns a gslice_array gslice_array<T> operator[] (const gslice&); ... }; }
For gslice_array, the assignment and computed assignment operators are provided to modify the elements of the subset.
By using type conversions you can combine a gslice array with other valarrays and subsets of valarrays (see page 554).
The following program demonstrates the use of valarray gslices:
// num/gslice1.cpp #include <iostream> #include <valarray> using namespace std; // print three-dimensional valarray line-by-line template<class T> void printValarray3D (const valarray<T>& va, int dim1, int dim2) { for (int i=0; i<va.size()/(dim1*dim2); ++i) { for (int j=0; j<dim2; ++j) { for (int k=0; k<dim1; ++k) { cout << va[i*dim1*dim2+j*dim1+k] << ' '; } cout << '\n'; } cout << '\n'; } cout << endl; } int main() { /* valarray with 24 elements * - two groups * -four rows * - three columns */ valarray<double> va(24); // fill valarray with values for (int i=0; i<24; i++) { va[i] = i; } // print valarray printValarray3D (va, 3, 4); // we need two two-dimensional subsets of three times 3 values // in two 12-element arrays size_t lengthvalues[] = { 2, 3 }; size_t stridevalues[] = { 12, 3 }; valarray<size_t> length(lengthvalues, 2); valarray<size_t> stride(stridevalues, 2); // assign the second column of the first three rows // to the first column of the first three rows va[gslice (0, length, stride)] = valarray<double>(va[gslice (1, length, stride)]); // add and assign the third of the first three rows // to the first of the first three rows va[gslice (0, length, stride)] += valarray<double>(va[gslice (2, length, stride)]); // print valarray printValarray3D (va, 3, 4); }
The program has the following output:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 3 1 2 9 4 5 15 7 8 9 10 11 27 13 14 33 16 17 39 19 20 21 22 23
Mask arrays provide another way to define a subset of a valarray. You can mask the elements with a Boolean expression. For example, in the expression
va[va > 7]
the subexpression
va > 7
returns a valarray with the size of va, where for each element a Boolean value states whether the element is greater than 7. The Boolean valarray is used by the subscript operator to specify all elements for which the Boolean expression yields true. Thus,
va[va > 7]
specifies the subset of elements in the valarray va that is greater than 7.
Apart from this, mask arrays behave the same as all valarray subsets:
To define a concrete subset of a valarray, you simply pass a valarray of Boolean values as the argument to the subscript operator of the valarray.
If the valarray is constant, the resulting expression is a new valarray.
If the valarray is nonconstant, the resulting expression is a mask_array that represents the elements of the valarray with reference semantics:
namespace std { template <class T> class mask_array; template <class T> class valarray { public: // masking a constant valarray returns a new valarray valarray<T> operator[] (const valarray<bool>&) const; // masking a variable valarray returns a mask_array mask_array<T> operator[] (const valarray<bool>&); ... }; }
For mask_array, the assignment and computed assignment operators are provided to modify the elements of the subset.
By using type conversions you can combine a mask array with other valarrays and subsets of valarrays (see page 554).
The following program demonstrates the use of masked subsets of valarrays:
// num/masked1.cpp #include <iostream> #include <valarray> using namespace std; // print valarray line-by-line template<class T> void printValarray (const valarray<T>& va, int num) { for (int i=0; i<va.size()/num; ++i) { for (int j=0; j<num; ++j) { cout << va[i*num+j] << ' '; } cout << endl; } cout << endl; } int main() { /* valarray with 12 elements * - four rows * - three columns */ valarray<double> va(12); // fill valarray with values for (int i=0; i<12; i++) { va[i] = i; } printValarray (va, 3); // assign 77 to all values that are less than 5 va[va<5.0] = 77.0; // add 100 to all values that are greater than 5 and less than 9 va[va>5.0 && va9.0] = valarray<double>(va[va>5.0 && va<9.0]) + 100.0; printValarray (va, 3); }
The program has the following output:
0 1 2 3 4 5 6 7 8 9 10 11 77 77 77 77 77 5 106 107 108 9 10 11
Note that the type of a numeric value that is compared with the valarray has to match the type of the valarray exactly. So, using an int value to compare it with a valarray of doubles would not compile:
valarray<double> va(12); ... va[va<5] = 77; // ERROR
The fourth and last way to define a subset of a valarray is provided by indirect arrays. Here you simply define the subset of a valarray by passing an array of indices. Note that the indices that specify the subset don't have to be sorted and may occur twice.
Apart from this, indirect arrays behave the same as all valarray subsets:
To define a concrete subset of a valarray you simply pass a valarray of elements of type size_t as the argument to the subscript operator of the valarray.
If the valarray is constant, the resulting expression is a new valarray.
If the valarray is nonconstant, the resulting expression is an indirect_array that represents the elements of the valarray with reference semantics:
namespace std { template <class T> class indirect_array; template <class T> class valarray { public: // indexing a constant valarray returns a new valarray valarray<T> operator[] (const valarray<bool>&) const; // indexing a variable valarray returns a indirect_array indirect_array<T> operator[] (const valarray<bool>&); ... }; }
For indirect_array, the assignment and computed assignment operators are provided to modify the elements of the subset.
By using type conversions you can combine an indirect array with other valarrays and subsets of valarrays (see page 554).
The following program demonstrates how to use indirect arrays:
// num/indi1.cpp #include <iostream> #include <valarray> using namespace std; // print valarray as two-dimensional array template<class T> void printValarray (const valarray<T>& va, int num) { for (int i=0; i<va.size()/num; i++) { for (int j=0; j<num; j++) { cout << va[i*num+j] << ' '; } cout << endl; } cout << endl; } int main() { // create valarray for 12 elements valarray<double> va(12); // initialize valarray by values 1.01, 2.02, ... 12.12 for (int i=0; i<12; i++) { va[i] = (i+1) * 1.01; } printValarray(va, 4); /* create array of indexes * - note: element type has to be size_t */ valarray<size_t> idx(4); idx[0] = 8; idx[1] = 0; idx[2] = 3; idx[3] = 7; // use array of indexes to print the ninth, first, fourth, and eighth elements printValarray(valarray<double>(va[idx]), 4); // change the first and fourth elements and print them again indirectly va[0] = 11.11; va[3] = 44.44; printValarray(valarray<double>(va[idx]), 4); // now select the second, third, sixth, and ninth elements // and assign 99 to them idx[0] = 1; idx[l] = 2; idx[2] = 5; idx[3] = 8; va[idx] = 99; // print the whole valarray again printValarray (va, 4); }
The valarray idx is used to define the subset of the elements in valarray va. The program has the following output:
1.01 2.02 3.03 4.04 5.05 6.06 7.07 8.08 9.09 10.1 11.11 12.12 9.09 1.01 4.04 8.08 9.09 11.11 44.44 8.08 11.11 99 99 44.44 5.05 99 7.07 8.08 99 10.1 11.11 12.12
The class valarray<> is the core part of the valarray component. It is defined as a template class parameterized on the type of the elements:
namespace std { template <class T> class valarray; }
The size is not part of the type. Thus, in principle you can process valarrays with different sizes and you can change the size. However, changing the size of a valarray is provided only to make a two-step initialization (creating and setting the size), which you can't avoid to manage arrays of valarrays. Beware that the result of combining valarrays of different size is undefined.
valarray::valarray ()
The default constructor.
Creates an empty valarray.
This constructor is provided only to enable the creation of arrays of valarrays. The next step is to give them the correct size using the resize() member function.
explicit valarray::valarray (size_t num)
Creates a valarray that contains num elements.
The elements are initialized by their default constructor (which is 0 for fundamental data types).
valarray::valarray (const T& value, size_t num)
Creates a valarray that contains num elements.
The elements are initialized by value.
Note that the order of parameters is unusual. All other classes of the C++ standard library provide an interface in which num is the first parameter and value is the second parameter.
valarray::valarray (const T* array, size_t num)
Creates a valarray that contains num elements.
The elements are initialized by the values of the elements in array.
The caller must ensure that array contains num elements; otherwise, the behavior is undefined.
valarray::valarray (const valarray& va)
The copy constructor.
Creates a valarray as a copy of va.
valarray::~valarray ()
The destructor.
Destroys all elements and frees the memory.
In addition, you can create valarrays initialized by objects of the internal auxiliary classes slice_array, gslice_array, mask_array, and indirect_array. See pages 575, 577, 578, and 579, respectively, for details about these classes.
valarray& valarray::operator = (const valarray& va)
Assigns the elements of the valarray va.
If va has a different size, the behavior is undefined.
The value of an element on the left side of any valarray assignment operator should not depend on the value of another element on that left side. In other words, if an assignment overwrites values that are used on the right side of the assignment, the result is undefined. This means you should not use an element on the left side anywhere in the expression on the right side. The reason for this is that the order of the evaluation of valarray statements is not defined. See page 557 and page 554 for details.
valarray& valarray::operator = (const T& value)
Assigns value to each element of the valarray.[6]
[6] In earlier versions single values were assigned by the member function fill().
The size of the valarray is not changed. Pointers and references to the elements remain valid.
In addition, you can assign values of the internal auxiliary classes slice_array, gslice_array, mask_array, and indirect_array. See pages 575, 577, 578, and 579, respectively, for details about these classes.
Class valarray provides the following member functions.
size_t valarray::size () const
Returns the actual number of elements.[7]
[7] The member function size() was called length() in earlier versions.
void valarray::resize (size_t num)
void valarray::resize (size_t num, T value)
Both forms change the size of the valarray to num.
If the size grows, the new elements are initialized by their default constructor or with value respectively.
Both forms invalidate all pointers and references to elements of the valarray.
These functions are provided only to enable the creation of arrays of valarrays. After creating them with the default constructor you should give them the correct size by calling this function.
T valarray::min () const
T valarray::max () const
The first form returns the minimum value of all elements.
The second form returns the maximum value of all elements.
The elements are compared with operator < or >. Thus, these operators must be provided for the element type.
If the valarray contains no elements, the return value is undefined.
T valarray::sum () const
Returns the sum of all elements.
The elements are processed by operator +=. Thus, this operator has to be provided for the element type.
If the valarray contains no elements, the return value is undefined.
valarray valarray::shift (int num) const
Returns a new valarray in which all elements are shifted by num positions.
The returned valarray has the same number of elements.
Elements of positions that were shifted are initialized by their default constructor.
The direction of the shifting depends on the sign of num:
If num is positive, it shifts to the left/front. Thus, elements get a smaller index.
If num is negative, it shifts to the right/back. Thus, elements get a higher index.
valarray valarray::cshift (int num) const
Returns a new valarray in which all elements are shifted cyclically by num positions.
The returned valarray has the same number of elements.
The direction of the shifting depends on the sign of num:
If num is positive, it shifts to the left/front. Thus, elements get a smaller index or are inserted at the back.
If num is negative, it shifts to the right/back. Thus, elements get a higher index or are inserted at the front.
valarray valarray::apply (T op (T)) const
valarray valarray::apply (T op (const T&)) const
Both forms return a new valarray with all elements processed by op().
The returned valarray has the same number of elements.
For each element of *this, it calls op(elem) and initializes the corresponding element in the new returned valarray by its result.
T & valarray::operator [ ] (size_t idx)
T valarray::operator [ ] (size_t idx) const
Both forms return the valarray element that has index idx (the first element has index 0).
The nonconstant version returns a reference. So, you can modify the element that is specified and returned by this operator. The reference is guaranteed to be valid as long as the valarray exists, and no function is called that modifies the size of the valarray.
Unary valarray operators have the following format:
valarray valarray :: unary-op () const
A unary operator returns a new valarray that contains all values of *this modified by unary-op.
unary-op may he any of the following:
operator + operator - operator ~ operator !
The return type for operator ! is valarray<bool>.
The binary operators for valarrays (except comparison and assignment operators) have the following format:
valarray binary-op (const valarray& va1, const valarray& va2)
valarray binary-op (const valarray& va, const T& value)
valarray binary-op (const T& value, const valarray& va)
These operators return a new valarray with the same number of elements as va, va1, or va2. The new valarray contains the result of computing binary-op for each value pair.
If only one operand is passed as a single value, it is combined with each element of va.
binary-op may be any of the following:
operator + operator - operator * operator / operator % operator ~ operator & operator | operator << operator >>
If va1 and va2 have different numbers of elements, the result is undefined.
The logical and comparison operators follow the same schema. However, their return values are a valarray of Boolean values:
valarray<bool> logical-op (const valarray& va1, const valarray& va2)
valarray<bool> logical-op (const valarray& va, const T& value)
valarray<bool> logical-op (const T& value, const valarray& va)
These operators return a new valarray with the same number of elements as va, va1, or va2. The new valarray contains the result of computing logical-op for each value pair.
If only one operand is passed as a single value, it is combined with each element of va.
logical-op may be any of the following:
operator == operator != operator < operator <= operator > operator >= operator && operator ||
If va1 and va2 have different numbers of elements, the result is undefined.
Similarly, computed assignment operators are defined for valarrays:
valarray& valarray::assign-op (const valarray& va)
valarray& valarray::assign-op (const T& value)
Both forms call for each element in *this assign-op with the corresponding element of va or value, respectively, as the second operand.
They return a reference to the modified valarray.
assign-op may be any of the following:
operator += operator -= operator *= operator /= operator %= operator ^= operator &= operator |= operator <<= operator >>=
If *this and va2 have different numbers of elements, the result is undefined.
References and pointers to modified elements stay valid as long as the valarray exists, and no function is called that modifies the size of the valarray.
valarray abs (const valarray& va)
valarray pow (const valarray& va1, const valarray& va2)
valarray pow (const valarray& va, const T& value)
valarray pow (const T& value, const valarray& va)
valarray exp (const valarray& va)
valarray sqrt (const valarray& va)
valarray log (const valarray& va)
valarray log10 (const valarray& va)
valarray sin (const valarray& va)
valarray cos (const valarray& va)
valarray tan (const valarray& va)
valarray sinh (const valarray& va)
valarray cosh (const valarray& va)
valarray tanh (const valarray& va)
valarray asin (const valarray& va)
valarray acos (const valarray& va)
valarray atan (const valarray& va)
valarray atan2 (const valarray& va1, const valarray& va2)
valarray atan2 (const valarray& va, const T& value)
valarray atan2 (const T& value, const valarray& va)
All of these functions return a new valarray with the same number of elements as va, va1, or va2. The new valarray contains the result of the corresponding operation called for each element or pair of elements.
If va1 and va2 have different numbers of elements, the result is undefined.
This subsection describes the subset classes for valarray in detail. However, these classes are very simple and do not provide many operations, thus I provide only their declarations along with a few remarks.
Objects of class slice_array are created by using a slice as the index of a nonconstant valarray:
namespace std { template<class T> class valarray { public: ... slice_array<T> operator[] (slice); ... }; }
The exact definition of the public interface of class slice is as follows:
namespace std { class slice { public: slice (); // empty subset slice (size_t start, size_t size, size_t stride); size_t start() const; size_t size() const; size_t stride() const; }; }
The default constructor creates an empty subset. With the start(), size(), and stride() member functions, you can query the properties of a slice.
The class slice_array provides the following operations:
namespace std { template <class T> class slice_array { public: typedef T value_type; void operator= (const T&); void operator= (const valarray<T>&) const; void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator~= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<<=(const valarray<T>&) const; void operator>>=(const valarray<T>&) const; ~slice_array(); private: slice_array(); slice_array(const slice_array&); slice_array& operator=(const slice_array&); ... }; }
Note that class slice_array<> is intended purely as an internal helper class for slices and should be transparent to the user. Thus, all constructors and the assignment operator of class slice_array<> are private.
Objects of class gslice_array are created by using a gslice as the index of a nonconstant valarray:
namespace std { template<class T> class valarray { public: ... gslice_array<T> operator[] (const gslice&); ... }; }
The exact definition of the public interface of gslice is as follows:
namespace std { class gslice { public: gslice (); // empty subset gslice (size_t start, const valarray<size_t>& size, const valarray<size_t>& stride); size_t start() const; valarray<size_t> size() const; valarray<size_t> stride() const; }; }
The default constructor creates an empty subset. With the start(), size(), and stride() member functions you can query the properties of a gslice.
The class gslice_array provides the following operations:
namespace std { template <class T> class gslice_array { public: typedef T value_type; void operator= (const T&); void operator= (const valarray<T>&) const; void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator~= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<<=(const valarray<T>&) const; void operator>>=(const valarray<T>&) const; ~gslice_array(); private: gslice_array(); gslice_array(const gslice_array<T>&); gslice_array& operator=(const gslice_array<T>&); ... }; }
As with slice_array<>, note that class gslice_array<> is intended purely as an internal helper class for gslices and should be transparent to the user. Thus, all constructors and the assignment operator of class gslice_array<> are private.
Objects of class mask_array are created by using a valarray<bool> as the index of a nonconstant valarray:
namespace std { template<class T> class valarray { public: ... mask_array<T> operator[](const valarray<bool>&); ... }; }
The class mask_array provides the following operations:
namespace std { template <class T> class mask_array { public: typedef T value_type; void operator= (const T&); void operator= (const valarray<T>&) const; void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator^= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<<=(const valarray<T>&) const; void operator>>=(const valarray<T>&) const; ~mask_array(); private: mask_array(); mask_array(const mask_array<T>&); mask_array& operator=(const mask_array<T>&); ... }; }
Again, note that class mask_array<> is intended purely as an internal helper class and should be transparent to the user. Thus, all constructors and the assignment operator of class mask_array<> are private.
Objects of class indirect_array are created by using a valarray<size_t> as the index of a nonconstant valarray:
namespace std { template<class T> class valarray { public: ... indirect_array<T> operator[](const valarray<size_t>&); ... }; }
The class indirect_array provides the following operations:
namespace std { template <class T> class indirect_array { public: typedef T value_type; void operator= (const T&); void operator= (const valarray<T>&) const; void operator*= (const valarray<T>&) const; void operator/= (const valarray<T>&) const; void operator%= (const valarray<T>&) const; void operator+= (const valarray<T>&) const; void operator-= (const valarray<T>&) const; void operator~= (const valarray<T>&) const; void operator&= (const valarray<T>&) const; void operator|= (const valarray<T>&) const; void operator<<=(const valarray<T>&) const; void operator>>=(const valarray<T>&) const; ~indirect_array(); private: indirect_array(); indirect_array(const indirect_array<T>&); indirect_array& operator=(const indirect_array<T>&); ... }; }
As usual, class indirect, array <> is intended purely as an internal helper class and should he transparent to the user. Thus, all constructors and the assignment operator of indirect_array<> are private.
| I l@ve RuBoard |


§353B-6 Interstate transfer fee. The judiciary may assess a fee not to exceed $200 for each application made by a parolee or probationer for a transfer out of the State; provided that the fees collected shall be deposited into the probation services special fund established in section 706-649. [L 2008, c 172, §1; am L 2012, c 303, §1]


Steve's Cafe |
|
Whether you’re walking around the trendy shops or biking the Burke-Gilman Trail, we invite you to stop on by, relax over a hearty meal, and enjoy a cup of our freshly brewed coffee.
We like to think of ourselves as more than just a neighborhood cafe; we want you to be part of our family.


Kleenex - Home
Header
Nav
Home
About
Process
Beer
Contact
Home
About
Process
Beer
Contact
Hero
Guides
About
Process
Beer
Contact


The Ivy Road College Prep
Experience & Expertise
Our team is comprised of seasoned education professionals, including a veteran teacher and writing tutor, and a former Director of Admissions at New York University. Together we bring decades of experience in various academic spaces.
We provide tailored assistance to students applying to colleges, ensuring that their applications are both well-written and impressive. Most importantly, we work together to craft essays that will help you stand out among the crowd of applicants.
Our Services
For students who have already written a draft essay for the Common Application:
For students who have yet to begin writing:
For students who have yet to begin writing and require extra support:
Additional rounds of edits may be added for $200 per hour


Now this was a very interesting experience with both substances, never done LSA or nutmeg before. The nutmeg was consumed at about 10:30 one evening a couple of weeks back, waited around for about an hour for anything... Nothing in the slightest happened. 11:00 had come around and I was anxious to try the morning glory seeds (heavenly blue and pearly gates) so I went to my bathroom spoke to the plants that I have growing asking for there permission and then ingested about 250 to 300 seeds.
That night I stayed awake until about 12:30 or 1:00a.m. being extremely tired I crashed in my room, beside my ever present dog with incense and the tube going (Evil Dead 2). The reason that I crashed so early is because in the past on my Dextromethorphan excursions I could go to sleep and awaken in about an hour as it started to kick in. My dog like I said is with me whenever I do any psychotropic, because she knows she can sense my altered state, and helps keep me from drifting to the dark side.
Unfortunately the time never came for me to wake up until the next morning... Man was I in for a surprise. I awoke around 5:00a.m., (the thing is though that I knew what time it was before I even opened my eyes) but anyway I awoke to the thought of just being extremely tired for some reason, this however was not true. I slowly came to the realization that the dizziness and odd sensation that I had was from the nutmeg/LSA. The walls seemed to rumble not move but rumble, candles to block negative energy were quickly lit as well as incense.
The fear overtook me though my first/worst bad trip. This was the only time that I ever was thrown into the hurling chaos of a 'bummer' I was able to hold it of for around 2 hours through guided meditation and speaking through my minds eye with my dog. Quickly overtaken for the next few hours of existence by visions of death and failure, being sent off to jail losing all hope of everything.
Even though it was a horrible experience, I am planning on doing both again, but no entangling of the two one or the other. I do consider myself lucky though, if it hadn't have been for that experience then I would still be doing synthetics.
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.


BLOC
Copyright (c) 2005 Jorge Nuno Silva
This game is played on a NxM square board, with the following checkered setup:
- GROUP - Two or more orthogonally connected stones of the same color.
- TURN - On each turn, each player must move an unmarked stone into an orthogonally (no diagonals) adjacent cell with an enemy unmarked stone, thus capturing it.
- Initially, all stones are unmarked.
- When a player creates a new group, he marks one of the friendly stones from that group.
- If a stone joins a group already with one marked stone, the player may move the mark to any other friendly stone from that group.
- If two groups join together, the player removes both markers, and mark just one stone from the group.
- GOAL - The player who makes the last move, wins
So, each group have one and just one marked stone. Marked stones cannot move or be captured.
An example Black's turn. He may win the game by capturing d5 with any black stone (thus, creating a new group) and then place the mark at d5. White does not have any valid move and loses the game.
This game was inspired on Clobber.


Crowded House reunion tour 2020: tickets, presale details and date for the Manchester concert
by Ross McindoeFor the first time in over a decade, iconic Aussie rockers Crowded House will be touring Europe with a reunion show in 2020.
Read More: Aerosmith tour 2020: tickets, date and pre-sale details for the Manchester show
With an arsenal packed full of hit songs like “Don't Dream it's Over” and “Fall at your Feet”, the band's 2020 tour is sure to be one of the hottest tickets in town. Here's everything you need to know about it.
Did Crowded House get back together?
The band's first incarnation lasted from 1985 to 1995, and they produced four studio albums: Crowded House, Temple of Low Men, Woodface and Together Alone. They performed their final show at the Sydney Opera House in 1996 in front of 150,000 people.
In 2005, following the tragic death of drummer Paul Hester, Neil and Nick reformed Crowded House to put some more good history, as they described it, into the story of the band.
Drafting in new drummer Matt Sherrod and with long time touring member Mark Hart, they released the album Time On Earth to critical acclaim and toured the world.
Another album, Intriguer, was recorded in 2009 and Crowded House was inducted into the Aria Hall of Fame in 2016, at the same time reprising its Farewell shows at the Sydney Opera House with three nights of performances.
In 2020, founding members Neil Finn and Nick Seymour will continue the band's legacy with the help of Finn's sons Liam and Elroy, and Mitchell Froom.
Neil Finn has just come off a hugely successful world tour with Fleetwood Mac, and the band are primed to hit some of Europe's biggest venues as they travel all over the continent.
When is the tour?
The European tour will run from 16 June until 10 July, beginning in Cardiff and ending in Barcelona.
All told, it will see them playing in 13 cities across the continent.
When is the Manchester show?
The band will be playing in Manchester at the Castlefield Bowl on Thursday 2 July.
They will also be appearing throughout the UK and Ireland, with dates set for Birmingham, London, Manchester, Cork and Dublin.
The full list of UK gigs is as follows:
- 16 Jun – Motorpoint Arena, Cardiff
- 17 Jun – SSE Hydro Arena, Glasgow
- 18 Jun – Arena Birmingham
- 2 Jul – Castlefield Bowl, Manchester
- 4 Jul – Roundhouse, London
- 5 Jul – Roundhouse, London
What songs will they play?
During their European tour in 2020, the band is likely to play songs from their eponymous debut album Crowded House, with hits like Don't Dream It's Over - one of the most covered songs of the last 20 years - and Something so Strong.
Other famous tracks you're likely to hear are Fall at your Feet, Four Seasons in One Day, and Weather With You from the band's 1991 album Woodface, and Better Be Home Soon from the 1988 record Temple of Low Men.
In addition to touring, the band also recently noted that they are spending time in the studio with new music on the horizon - so there may be some new material performed on the tour as well.
How can I get tickets?
Tickets go on general sale at 9am on Friday 13 December and are available from Ticketmaster.
O2 Priority customers can get in ahead of the crowds, with access to tickets from 9am on Wednesday 11 December, while Live Nation's presale begins on Thursday 12 December at 9am.


Sell your music on online stores/platforms like iTunes, Spotify, Apple Music, Deezer, Youtube, Boomplay, Notjustok and over 90+ Websites. A Music Distribution Company in Nigeria for African Creatives. Guaranteed 100% Royalty
We sell your music digitally to more than 90 online music platforms including Spotify, Apple Music, Boomplay, MTN Music Plus, Deezer, Shazam, NotJustOk, TooXclusive, etc.
We help you monetize your music on Youtube (even if it was not uploaded by you) and get paid as people listen. Fresible has been an official YouTube partner since 2018 and has access to the YouTube Content-ID system.
We help you promote your music to a target audience all over the world through a powerful marketing and promotion strategy within a specified period.


Patient List
Getting patient list using FHIR.
Patient Details
| Allergy | Type | Category | Criticality |
|---|
| Measure | Value | Unit | Date Time |
|---|
| Test | Value | Unit | Date Time |
|---|
| Vaccine | Occurrence Date Time |
|---|
Getting patient list using FHIR.
| Allergy | Type | Category | Criticality |
|---|
| Measure | Value | Unit | Date Time |
|---|
| Test | Value | Unit | Date Time |
|---|
| Vaccine | Occurrence Date Time |
|---|


CAN'T HARDLY WAIT (1998) A Film Review by Ted Prigge Copyright 1998 Ted Prigge
Writers/Directors: Harry Elfont and Deborah Kaplan Starring: Ethan Embry, Jennifer Love Hewitt, Peter Facinelli, Lauren Ambrose, Charlie Korsmo, Seth Green, Michelle Brookhurst, Erik Palladino, Melissa Joan Hart, Breckin Meyer, Donald Adeosun Faison, Jerry O'Connell, Jenna Elfman
The most interesting part of "Can't Hardly Wait" just happens to be not only the most human, but for many of us, the one part that many of us can easily relate to. That is the character of Denise (Lauren Ambrose), the film's sole sarcastic member who mocks everything that goes on in the film, and at one point sits down on a couch and looks totally bored. The film wisely holds over this moment, nicely showing her alienation in the midst of a large high school party...almost too nicely. For some members of the audience (read: me), this is basically a mirror of what's going on with them watching this film. We sit there wondering why we've even bothered to see a film about a long high school party we probably never felt the desire to go to in the first place.
I would actually highly recommend this film if it satirized all of this.  Everyone's here: the Jock, the Homecoming Queen, the Nerd (and his dominions of Trekkies and X-Philes), the Alienated Wannabe Writer, the School Spirit Girl, the Pothead(s), the Wigger, etc, etc, etc, and weirdly enough this film shows them as superficial, lame, and basically as a bunch of losers. Except for Denise, who rolls her eyes at everything, and easily becomes the most likable character even before she speaks (her yearbook entry, something which is done for each main character, quotes Oscar Wilde - definite pointers there).
Unfortunately, the writers and directors take several major misteps on the way to making this into an admirable and even likable film. The film, as I said, portrays most of its characters as superficial and just totally ignorant to everything. However, instead of sticking with this, perhaps even going a bit further with it, they let this lie, and actually make these characters into our heroes. We follow several of them, all a bunch of moronic stereotypes with only a shread of humanity and realism, and tries to tell boring and overly melodramatic tales about them as if we actually cared and/or identified with them. And if we did, we certainly don't want to revisit that state of being.
Here's a quick low-down: it's graduation, and we follow a bunch of seniors on the last night, otherwise known as the "American Grafitti" or, to a lesser extent, the "Dazed and Confused" cliche.  "Can't Hardly Wait" just opts for a big indoor keg party, and a little bit of aimless driving, albeit of the I'm-whining-because-I-can't-get-a-girl-I-want brand. We follow many people around, but mostly we trail Preston (Ethan Embry, of "That Thing You Do!"), the Alienated Writer, who's been pining over the Homcoming Queen, Amanda (the totally overrated Jennifer Love Hewitt), for the entirety of High School because he thinks they shared a moment their freshman year over a freaking Pop Tart. Now that she's broken up with her football player boyfriend, Mike (Peter Facinelli), he decides to go to the party with a note he's written declaring his "love" for her in the hopes he'll build up the guts to give it to her...even though he's leaving for a multi-week intensive writing program hosted by none other than Kurt Vonnegut (okay: the ingenius Vonnegut or some icky Noxema spokesperson?).
Since that plot is incredibly lame and a track record of what goes on with it wouldn't be able to carry a commercial let alone a feature film, and because it's a party, there are some more main characters, such as: William (Charlie Korsmo, finally surfacing after "Dick Tracy"), the Nerd (and his dominions) who has come up with a ridiculous plan to publically sabotage Mike, who's humiliated him for years, but gets too caught up in drinking to do it; Kenny (Seth Green), the Wigger, who has decided that this party will be where he will finally get laid (uh huh); and Denise, the only exceptional character, who unfortunately gets stuck in a bathroom (don't ask) with Kenny where the two characters let down their characters and are allowed to follow the laws of plot cliches from point A to point B with nary a bit of characterization involved after awhile. Ugh.
The main comparison this film is getting to another film is actually not "American Grafitti" or "Dazed and Confused," two films that embraced and ultimately made humans out of many of its high schoolers (not to mention were extremely entertaining), but to John Hughes films of the 80s, most notably "Sixteen Candles." The big difference in the two is that that film managed to not only embrace but even satirize its main characters, and did so equally and in an entertaining fashion. This film forgets to satirize its characters, and ultimately tells a story about a bunch of uninteresting stereotypes...and then says that it's all okay. We can't take this film seriously, nor can we take this as fun, so really what good is it?
But I will tell you some things I did like: I liked the direction, except for a couple too-over-the-top features, like way-too-glossy jump cuts (it's like an oxymoron) and other obscurities.  I actually did like Seth Green, for once in about a decade (when he played a very young Woody Allen in "Radio Days") - his desintegration of his Wigger character was almost believable...almost. And, of course, Lauren Ambrose is wonderful as Denise, the one character we could have used some more of, even though it would have changed the entirety of the film.
However, the character of Denise really doesn't work with the film, when really thought about. She's far too witty and realized (at least for the first half) to belong in this film, and whenever she appears, she automatically gives everything a delightfully satirical tone. She's not just The Cynic or The Intellectual; she's just a very interesting character who provides entertainment even if it further damages other already damaged characters. She may ruin the film more, but at least when she's on screen we can sit up and think to ourselves "Well, at least we'll be entertained."
A couple other things that just don't work: Mike's character, who suffers an epiphany throughout the film but in the end acts as though he has forgotten everything: too much the sacrificial lamb for the film in general; the aimless, bitchy driving by Preston to try and get over his inability to shack up with Amanda - give me a break; and perhaps the one thing that just doesn't work at all: Jenna Eflman's uncredited cameo as an angel - just didn't work, but nice try.
 We don't feel for these characters because for most of us, we aren't stereotypes going through the motions to worn subplots. The acid test for high school movies is: does it at all capture the feel of what it's portraying? The answer for this film is no. Nice try, though.
MY RATING (out of 4): *1/2
Homepage at: http://www.geocities.com/Hollywood/Hills/8335/
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The New York Times lists 36 questions you can ask someone if you want to fall in love. (Or make your love even stronger.) This site provides the ideal experience for exploring these questions, so grab some wine, sit down with someone you want to love & let’s get started.
Quick instructions: read one question aloud to your partner, then both of you answer. Swap roles for the next question. Answering all 36 questions should take around one hour, but time isn't important…
Congratulations, you've answered all the questions! Now for the hard part.
In order to solidify your love, you have to look into your partner's eyes for four minutes. In silence. It's hard, and you'll squirm, but you'll learn an incredible amount. Good luck…


All your files in one secure location, accessible anywhere.
Fylo stores your most important files in one secure location. Access them wherever you need, share and collaborate with friends,family, and co-workers.
 Fylo has you
covered for all of your file storage needs.
Securely share files and folders with friends, family and colleagues for
live collaboration. No email attachments required!
Fylo has improved our team productivity by an order of magnitude. Since making the switch our team has become a well-oiled collaboration machine.
Kyle Burton
Founder & CEO, HuddleGet early access today
It only takes a minute to sign up and our free starter tier is extremely generous. If you have any questions, our support team would be happy to help you.


Buffering .NET Console Output
Here. The one where I can't believe that .NET Console output isn't buffered by default, then come to appreciate why they did it that way and finally figure out how to turn buffering back on at will, keeping the best of all worlds.


Hello, I’m Maxime Euzière, JS developer for EQCSS.
In parallel to this documentation, let me suggest you to see the source code of EQCSS here: github.com/eqcss/eqcss/blob/gh-pages/EQCSS.js
You can find a lot of documentation about EQCSS’s history, usage and philosophy out there:
When we started this project, the requirements for EQCSS were:
Element Queriesallowing to style elements based on their size, their content or their state (most of the syntax proposals we could find online didn’t suit us)
What a great challenge!
After a lot of discussion and thinking, here’s how we organized the project and algorithm:
We have a global object EQCSS containing 2 functions:
EQCSS.load()
, called automatically when the DOM is ready. Its role is to find all the EQCSS code present in the page, gather it and parse it in order to extract all the useful parts. It can also be called manually if new EQCSS sources are added to the page after page load.EQCSS.apply()
, called automatically when the DOM is ready (after EQCSS.load), but also when the user interacts with the page. Its role is to test all the Element Queries parsed by EQCSS.load()
and apply their respective styles into the page if it is applicable. It’s called after resizeevents by default, but developers can also decide to call it after events like click, text input, scroll (like at the end of the test page), or manually as soon as the display needs to be updated.
Ex: apply EQCSS after keydown events:
window.addEventListener("keydown", function(){
EQCSS.apply();
});
EQCSS code can be written alongside regular CSS code. Its syntax @element (...) { ... }
is custom enough to stay ignored by browsers when they parse CSS. Although, it’s clean enough to be colored by syntax highlighters. Ex: codepen.io/tomhodgins/pen/yYVdBq
That’s why we allow to write EQCSS code directly in style
blocks (for embedded style) and link rel=stylesheet href=...
links (for external CSS files).
If you want to keep your EQCSS code separated from regular CSS, you can also include it in a script type="text/eqcss"
block (for embedded style) or script type="text/eqcss" src=...
includes (for external files)
EQCSS.load()
fetches all these elements into the page, and gather their content into a string: EQCSS.code
Embedded styles are read via innerHTML, external files are read via a synchronous AJAX request.
EQCSS.code
is then cleaned by a bunch of RegExps that remove all the comments, trim extra spaces and put each query on a separate line.
Before (HTML):

After (JS):
EQCSS.code =
"@element ".class1" and (max-width: 40%){ .class1 { background: yellow; } }
@element ".class2" and (min-width: 250px) and (max-width: 300px){ .class2 { background: yellow; } }"
Then, another bunch of RegExps parse these lines and separate the selectors, conditions and styles into an object called EQCSS.data:
EQCSS.data = [
{
selector: ".class1",
conditions: [
{
measure: "max-width,
value: "40",
unit: "%"
}
],
style: ".class1 { background: yellow; }";
},
{
selector: ".class2",
conditions: [
{
measure: "min-width",
value: "250",
unit: "px"
},
{
measure: "max-width",
value: "300",
unit: "px"
}
],
style: ".class2 { background: yellow; }";
}
]
We now have a collection of EQCSS selectors, conditions and styles to apply. The first thing we can do with it is to query the page’s DOM to retrieve all the elements corresponding to the selectors, and mark them with a GUID
: a custom and unique attribute: data-eqcss-X-Y
.
X represents the current Element Query, and Y the current element matching this query.
The parent of each matched element is also marked with a custom attribute, or parent GUID
, in the form of data-eqcss-X-Y-parent
. Here’s an example:
Before:

After:

<div

(NB: as you can see, an element can belong to multiple Element Queries (and thus, carry multiple GUIDs), and if multiple elements share a common parent, the parent will have multiple parent GUIDs.)
Then, a style
block is created in the page’s HEAD for each GUID (and the GUID becomes the id of the style
block).
Ex:

(NB: These style blocks are created once, at the first call of EQCSS.apply()
. During the next calls, they are just reused if they already exist)
Then, for each query, and for each element matching the query, we have to test if all the query’s conditions are met.
We save the element’s computedStyle
as well as it’s parent’s computedStyle
, because they will be required to test the conditions.
A big JS switch allows to test each condition’s measure (ex: "min-width"
, "max-width"
, etc.) and compare it to the condition’s value and unit (ex: "40%"
, "250px"
).
All computed styles are defined by default in px, so to support other units (like %
, em
, vw
, vh
, etc.), we first need to convert these units into pixels. Depending on the unit chosen, this conversion requires the element’s own computedStyle
, or its parent’s, or the root element’s (html
).
There are also conditions that use units but not computedStyle
, like min(or max)-scroll-x(or y) that use the element’s scrollTop
and scrollLeft
instead.
Finally, some conditions (like min/max-children or min/max-characters) require no units and no computedStyle
at all. They just depend on the element’s content.
Anyway, if all the conditions of a query are met by an element, then EQCSS will fetch the style
block associated to this element (in the page’s head
) and fill it with the query’s css.
Ex: if the element [data-eqcss-1-0]
matches the query 1, then the head will contain this:

And the browser will instantly apply this style on all the page.
At the contrary, if all the conditions are NOT met, the style
block is emptied and the corresponding style disappears into the page.
Special keywords are handled like this:
:self
into the query. The trick here is to replace :self
with [data-eqcss_X_Y]
before copying the css code into the style
block. This produced a CSS selector that matches only the element having the current GUID, i.e. the current element, that we want to call :self
.:parent
is quite similar: EQCSS replaces it with [data-eqcss-X-Y-parent]
in the CSS code before applying it.$root
is replaced by html
eval("abcd")
or eval("oneFunction()")
, it evaluates the expression inside (in JavaScript) the parenthesis and replaces it with the value returned. Ex: if abcd = 40
, width: eval("abcd")px
becomes width: 40px
.Many polyfills were included into EQCSS to allow a good compatibility between browsers:
domready(func)
: calls the function passed in parameter as soon as the DOM is ready (it happens before onLoad)EQCSS-polyfills.js
also contains polyfills specific for IE < 9:addEventListener()
getComputedStyle()
/ getPropertyValue()
document.querySelector()
and querySelectorAll()
(just a basic version that works with ids, classes and tag names)element.textcontent


Welcome to Make My Vape, The number 1 DIY E Liquid store. We specialise only in providing you with the ingredients to make the best quality e-liquid at a fraction of the cost.


The KCECH Smash Brothers Tourney will be held on Saturday, November 6th @ 7PM in the 1938 Lounge (click
here for directions).
There will be both a Super Smash Brothers Brawl singles tournament and a doubles tournament.
The following are the rules we will use for both the singles and doubles tournaments:
- Single elimination, 1 match, 3 stocks, 8 minute time limit
- All items turned off
- Gentleman's rule for stage selection: If both parties can agree on a stage, then that stage will be played. If the two parties cannot come to an agreement in a timely fashion, then a random stage will be chosen from the following list:
- Battlefield
- Yoshi's Island
- Smashville
- Final Destination
- Castle Siege
- Pokemon Stadium (Melee)
- Lylat Cruise
- If there is a controller malfunction detected during the match, the match will be restarted.
- Extending Meta Knight's Dimensional Cape is banned
- Stalling is banned (i.e. using chain grabs against a wall beyond 300%, using Sonic's Neutral B repeatedly underneath a stage)
- Purposefully freezing an opponent is banned.
- Either of the above three actions or doing anything that prevents the match from completing will result in instant disqualification.
- If a party is not present for a match, then other matches will be scheduled (when possible). However, if either a) four other matches have been scheduled OR b) there are no other matches left to schedule and 10 minutes pass, then the missing party will be disqualified.
Additional rules for the doubles tournament are below:
- Friendly fire is turned off
- Stock sharing is allowed (i.e. if one party member dies first, he or she is allowed to take stocks from the surviving party member when possible)


Alice UMULISA
Full Stack Software Developer
This is a flask webapp that retrieves data from the news api and this enables a user to select on the news source they would want to view an article from, after selecting the news source they want, a user can also choose the article they want to read from.
Github repoThis is a web app which helps end users to read some emotional and inspiratinal quotes, and it enables users to share their favorite quotes.
Github repoThis is a web app which helps end users from github to access some information of github users, like their public repositories, names, profiles and so on.
Github repoThis is an application that allows users to use one minute wisely by saying something meaningful. This is achieved by creating a pitch. The users will submit their one minute pitches and other users will vote on them and leave comments to give their feedback on them.
Github repoPhotoGallery is a simple web application to show beautiful pictures. Users get to view photos updated by the site admin. Users can see photos based on the location, by clicking on the listed locations in the menu. They can also copy the link to a photo to paste at their discretion. The search functionality will search photos based on the categories.
Github repoCopyright 2018 | Alice.U.portfolio | All Rights Reserved


This ephemeris calculator converts time in Earth years to the number of years on all the planets in Earth's solar system based on how long each planet takes to orbit the sun. Enter your age to see how old you are on Mars, Venus, and more!
You can also view your life expectancy on other planets. Impress your friends by telling them that you expect to live hundreds more years... on Mercury! Enter your age to see how many more years you can expect to live!


---
layout: post
title: "Where you can find me on the web"
---
BrianKirsten.com
Flickr
FindParadise (travel blog I try to keep updated)
Twitter (this is my mini-blog for FindParadise)
LinkedIn
MySpace
ComicSpace
You can also check out the projects I'm part of at Brain Scan Studios, and download all of the comics we publish over at Wowio.


| MATLAB File Help: prtPreProcLogDisc |
prtPreProcLogDisc Histogram equalization processing LOGDISC = prtPreProcLogDisc creates a logistic discriminant pre processing object. A prtPreProcLogDisc object processes the input data so that each feature dimension is scaled between 0 and 1 to best match the data set class labels. prtPreProcLogDisc has no user settable properties. A prtPreProcLogDisc object also inherits all properties and functions from the prtAction class Example: dataSet = prtDataGenUnimodal; % Load a data set logDisc = prtPreProcLogDisc; % Create a pre processing object logDisc = logDisc.train(dataSet); % Train dataSetNew = logDisc.run(dataSet); % Run % Plot subplot(2,1,1); plot(dataSet); title('Original Data'); subplot(2,1,2); plot(dataSetNew); title('LogDisc Data');
| Superclasses | prtPreProcClass |
| Sealed | false |
| Construct on load | false |
| prtPreProcLogDisc | Allow for string, value pairs |
| dataSet | The training prtDataSet, only stored if verboseStorage is true. |
| dataSetSummary | Structure that summarizes prtDataSet. |
| isCrossValidateValid | True |
| isSupervised | False |
| isTrained | Indicates if prtAction object has been trained. |
| name | 'Logistic Discriminant' |
| nameAbbreviation | LogDisc |
| showProgressBar | |
| userData | User specified data |
| verboseStorage | Specifies whether or not to store the training prtDataset. |
| crossValidate | Cross validate prtAction using prtDataSet and cross validation keys. | |
| get | get the object properties | |
| kfolds | Perform K-folds cross validation of prtAction | |
| optimize | Optimize action parameter by exhaustive function maximization. | |
| run | Run a prtAction object on a prtDataSet object. | |
| set | set the object properties | |
| train | Train a prtAction object using training a prtDataSet object. |


Woman walks into wildfire to save badly burnt koala
Rescuer Toni Doherty said it was her ‘natural instinct’ to pull the animal from the burning trees.
A woman in Australia walked into a wildfire to save a badly burnt koala.
The koala named Lewis was given water and wrapped in a blanket after being found on a road in the New South Wales state town of Wauchope.
Rescuer Toni Doherty told Network Nine it was her “natural instinct” to rescue the koala from the fire.
She said she “immediately thought just get to him, put the fire out”.
The 14-year-old animal was taken to the nearby Port Macquarie Koala Hospital for treatment for severe burns to his feet, chest and stomach.
The hospital commented on its Facebook page: “She (Ms Doherty) is an absolute legend for capturing this male koala who was so disorientated by the flames and unfortunately was burnt further as he headed back into active fire.
“He has been treated and is now in the five-star accommodation at the Koala Hospital.”
Wildfires in South Australia and New South Wales have prompted fire officials to issue emergency warnings.


1. Emily Adams, Third Place Books, Lake Forest, WA
2. Greg Berry, Elliott Bay Book Co., Seattle, WA
3. Anmiryam Budner, Main Point Books, Bryn Mawr, PA
4. Raul Chapa, BookPeople, Austin, TX
5. Ed Conklin, Chaucer’s, Santa Barbara, CA
6. Sheryl Cotleur, Copperfield’s, Sebastopol, CA
7. James Crossley, Island Books, Mercer Island, WA
8. Alan Dishman, Diesel Oakland, Oakland, CA
9. Heather Duncan, Tattered Cover, Denver, CO
10. Kevin Elliott, 57th St. Books, Chicago, IL
11. Jeremy Ellis, Brazos Bookstore, Houston, TX
12. Ezra Goldstein, Community Bookstore, Brooklyn, NY
13. Rebekah Hendrian, Book Nook, Montague, MI
14. Sara Hinckley, The Hudson Group, Marietta, GA
15. Chris Hsiang, Books Inc, San Francisco, CA
16. Stan Hynds, Northshire Manchester, Manchester, VA
17. Geoffrey Jennings, Rainy Day Books, Kansas City, KS
18. Kathi Kirby, Powell’s, Portland, OR
19. Kris Kliendienst, Left Bank Books, St. Louis, MO
20. Peter Matyskiela, Doylestown Bookshop, Doylestown, PA
21. Chris Phipps, Diesel, Oakland, CA
22. Steve Salardino, Skylight Books, Los Angeles, CA
23. Lisa Sharp, Nightbird Books, Fayetteville, AR
24. Lacy Simons, Hello Hello Books, Rockland, ME
25. Julie Slavinsky, Warwick’s, La Jolla, CA
26. Mary Wolf, Collected Works, Santa Fe, NM
27. Dylan Soltis, WORD Jersey City, Jersey City, NJ
28. Jonathon Welch, Talking Leaves, Buffalo, NY


Genesis 1 New Revised Standard Version Catholic Edition (NRSVCE)
Six Days of Creation and the Sabbath
1 In the beginning when God created [ a] the heavens and the earth, 2 the earth was a formless void and darkness covered the face of the deep, while a wind from God [ b] swept over the face of the waters. 3 Then God said, “Let there be light”; and there was light. 4 And God saw that the light was good; and God separated the light from the darkness. 5 God called the light Day, and the darkness he called Night. And there was evening and there was morning, the first day.
6 And God said, “Let there be a dome in the midst of the waters, and let it separate the waters from the waters.” 7 So God made the dome and separated the waters that were under the dome from the waters that were above the dome. And it was so. 8 God called the dome Sky. And there was evening and there was morning, the second day.
9 And God said, “Let the waters under the sky be gathered together into one place, and let the dry land appear.” And it was so. 10 God called the dry land Earth, and the waters that were gathered together he called Seas. And God saw that it was good. 11 Then God said, “Let the earth put forth vegetation: plants yielding seed, and fruit trees of every kind on earth that bear fruit with the seed in it.” And it was so. 12 The earth brought forth vegetation: plants yielding seed of every kind, and trees of every kind bearing fruit with the seed in it. And God saw that it was good. 13 And there was evening and there was morning, the third day.
14 And God said, “Let there be lights in the dome of the sky to separate the day from the night; and let them be for signs and for seasons and for days and years, 15 and let them be lights in the dome of the sky to give light upon the earth.” And it was so. 16 God made the two great lights—the greater light to rule the day and the lesser light to rule the night—and the stars. 17 God set them in the dome of the sky to give light upon the earth, 18 to rule over the day and over the night, and to separate the light from the darkness. And God saw that it was good. 19 And there was evening and there was morning, the fourth day.
20 And God said, “Let the waters bring forth swarms of living creatures, and let birds fly above the earth across the dome of the sky.” 21 So God created the great sea monsters and every living creature that moves, of every kind, with which the waters swarm, and every winged bird of every kind. And God saw that it was good. 22 God blessed them, saying, “Be fruitful and multiply and fill the waters in the seas, and let birds multiply on the earth.” 23 And there was evening and there was morning, the fifth day.
24 And God said, “Let the earth bring forth living creatures of every kind: cattle and creeping things and wild animals of the earth of every kind.” And it was so. 25 God made the wild animals of the earth of every kind, and the cattle of every kind, and everything that creeps upon the ground of every kind. And God saw that it was good.
26 Then God said, “Let us make humankind [ c] in our image, according to our likeness; and let them have dominion over the fish of the sea, and over the birds of the air, and over the cattle, and over all the wild animals of the earth, [ d] and over every creeping thing that creeps upon the earth.”
27 So God created humankind
[
e] in his image,
in the image of God he created them;
[
f]
male and female he created them.
28 God blessed them, and God said to them, “Be fruitful and multiply, and fill the earth and subdue it; and have dominion over the fish of the sea and over the birds of the air and over every living thing that moves upon the earth.” 29 God said, “See, I have given you every plant yielding seed that is upon the face of all the earth, and every tree with seed in its fruit; you shall have them for food. 30 And to every beast of the earth, and to every bird of the air, and to everything that creeps on the earth, everything that has the breath of life, I have given every green plant for food.” And it was so. 31 God saw everything that he had made, and indeed, it was very good. And there was evening and there was morning, the sixth day.
Footnotes:
- Genesis 1:1 Or when God began to create or In the beginning God created
- Genesis 1:2 Or while the spirit of God or while a mighty wind
- Genesis 1:26 Heb adam
- Genesis 1:26 Syr: Heb and over all the earth
- Genesis 1:27 Heb adam
- Genesis 1:27 Heb him
New Revised Standard Version Bible: Catholic Edition, copyright © 1989, 1993 the Division of Christian Education of the National Council of the Churches of Christ in the United States of America. Used by permission. All rights reserved.


Moderate quake hits near Guatemalan coast, no reports of damage
GUATEMALA CITY: A moderate 5.5-magnitude earthquake struck deep beneath the sea floor off the coast of Guatemala on Wednesday (Nov 13), according to the US Geological Service (USGS).
Guatemala's emergency services agency said there were no immediate reports of damage from the quake, which was also felt in neighbouring El Salvador.


| Bandit |
| Maggot |
| Rad Maggot |
| Big Maggot |
| Scorpion |
| Gold Scorpion |
| Bandit Boss |
| Rat |
| Rat King |
| Fast Rat |
| Gator |
| Exploder |
| Super Frog |
| Frog Queen |
| Melee |
| Raven |
| Salamander |
| Sniper |
| Big Dog |
| Spider |
| New Cave Thing (MISSING) |
| Laser Crystal |
| Hyper Crystal |
| Snow Bandit |
| Snowbot |
| Wolf |
| Snowtank |
| Lil Hunter |
| Freak |
| Explo Freak |
| Rhino Freak |
| Necromancer |
| Turret |
| Technomancer |
| Guardian |
| Explo Guardian |
| Dog Guardian |
| Nothing |
| Nothing 2 |
| Bone Fish |
| Crab |
| Turtle |
| Molefish |
| Molesarge |
| Fireballer |
| Super Fireballer |
| Jock |
| Inv Spider |
| Inv Laser Crystal |
| Mimic |
| Super Mimic |
| Grunt |
| Inspector |
| Shielder |
| Crown Guardian |
| Explosion |
| Small Explosion |
| Trap Fire |
| Shield |
| Toxic Gas |
| Horror |
| Barrel |
| Toxic Barrel |
| Gold Barrel |
| Car |
| Venus Car |
| Venus Car Fixed |
| Venuz Car 2 |
| Frozen Car |
| Frozen Car Thrown |
| Mine |
| Crown2 |
| Rogue Strike |
| Blood Nader |
| Blood Cannon |
| Blood Hammer |
| Disc |
| Curse |
| Scrap Boss Missile |
| Spooky Bandit |
| Lil Hunter Dead |
| Nothing Death |
| Jungle Bandit |
| Jungle Assassin |
| Jungle Fly |
| Crown of Hatred (MISSING) |
| Ice Flower |
| Cursed Ammo Pickup (MISSING) |
| Underwater Lightning (MISSING) |
| Elite Grunt |
| Blood Gamble |
| Elite Shielder |
| Elite Inspector |
| Last |
| Van |
| Buff Gator |
| Generator |
| Lightning Crystal |
| Gold Tank |
| Green Explosion |
| Small Generator |
| Gold Disc |
| Scrap Boss Dead |
| Popo Freak |
| Nothing 2 Death |
| Oasis Boss |