Files CCore/inc/Array.h CCore/src/Array.cpp
Subfolders CCore/inc/array CCore/src/array
There are several types that are used to specify the constructor behavior.
/* words */ enum DoBuildType { DoBuild }; enum DoReserveType { DoReserve };
DoBuild and DoReserve are words. They designate the build and the reserve variant of the constructor respectively.
template <int Sw> class DoSomething { ulen len; ulen maxlen; public: explicit DoSomething(ulen len); // maxlen == len DoSomething(ulen len,ulen maxlen); // maxlen >= len ulen getLen() const { return len; } ulen getMaxLen() const { return maxlen; } }; using DoRaw = DoSomething<1> ; using DoFill = DoSomething<2> ; using DoCopy = DoSomething<3> ; using DoCast = DoSomething<4> ; using DoSwap = DoSomething<5> ; using DoCreate = DoSomething<6> ;
DoRaw, DoFill, DoCopy, DoCast, DoSwap, DoCreate are not words, but Small Data Types. They designate the correspondent variant of the constructor and carry two parameters: the array length and the reserved length. When the array is being created, the reserved length determines the memory space to be allocated, and the length is the number of elements to be created. An exception is thrown, if len is greater than maxlen.
Array is a container, where multiple items comprise a continuous range. The simplest such "container" is the embedded type "array of" T[Len]. Unfortunately, this type lacks many abilities, required in applications, so we need a variety of Arrays. We don't use STL vector, because it also has many deficiencies. CCore Arrays use the CCore heap with its extra functionality. They also customizable using an Algorithm Package of array algorithms.
CCore Arrays implement Range Access Interface. They also provide the index access to elements through the overloaded operator [] and the checked index access with the method at().
Constant CCore Arrays give constant access to its elements.
Allocation errors and index check errors throw exceptions. Default constructors are no-throw.
The method apply() applies the functor, given by a Functor Init, to array elements. If the array is constant, then element references are constant too. The variant apply_const() also enforces constantness. It also may return a functor result.
The method applyReverse() applies the functor, given by a Functor Init, to array elements in the reverse order. If the array is constant, then element references are constant too. The variant applyReverse_const() also enforces constantness.
Arrays can be used with most types, there is no hard restrictions on type properties. The only strong requirement is: the type destructor must be no-throw. Some operations, however, require additional type properties. For example, to use cloneTo() methods the type must be copyable.
All CCore Arrays available through the header CCore/inc/Array.h.
TempArray is the simplest of Arrays. It is applicable only to POD types. This container combines stack storage and dynamic storage to speed up the array construction/destruction for a short lengths. Use this Array if you need a temporary buffer with expected short length in the most cases.
template <class T,ulen StackLen>
class TempArray : NoCopy
{
private:
T *ptr;
ulen len;
T buf[StackLen];
public:
// constructors
TempArray() noexcept;
explicit TempArray(ulen len);
~TempArray();
// methods
bool isEmpty() const;
bool notEmpty() const;
void provide(ulen len);
void reset(ulen len);
bool extend(ulen len);
void erase();
// range access
T * getPtr() { return ptr; }
const T * getPtr() const { return ptr; }
const T * getPtr_const() const { return ptr; }
ulen getLen() const { return len; }
// index access
T & operator [] (ulen index);
const T & operator [] (ulen index) const;
T & at(ulen index);
const T & at(ulen index) const;
// apply
auto apply(FuncInitArgType<T &> func_init);
auto apply(FuncInitArgType<const T &> func_init) const;
auto apply_const(FuncInitArgType<const T &> func_init) const;
auto applyReverse(FuncInitArgType<T &> func_init);
auto applyReverse(FuncInitArgType<const T &> func_init) const;
auto applyReverse_const(FuncInitArgType<const T &> func_init) const;
};
If the array length is not greater than StackLen, then TempArray uses the internal buffer. Otherwise, the space for elements is dynamically allocated.
provide() ensures the array has at least the given length, reallocating it if required. The previous array content may be lost. The new content is not initialized.
reset() recreates the array with the given length, reallocating it if required. The previous array content may be lost. The new content is not initialized.
extend() extends the array up to the given length. If len is less or equal than the current array length, the method does nothing and returns false. Otherwise it extends the array, preserving the current content, and returns true. The new content is not initialized. An exception is thrown if there is no memory.
erase() erases the array.
Other methods are standard array methods.
SimpleArray is another "simple array". It is applicable to (almost) any types.
The second template argument of SimpleArray is an Algorithm Package of array algorithms. SimpleArray uses only two of them: Create_default() and Destroy(). See below about array algorithms.
template <class T,class Algo=ArrayAlgo_mini<T> >
class SimpleArray : NoCopy
{
T *ptr;
ulen len;
public:
// constructors
SimpleArray() noexcept;
explicit SimpleArray(ulen len);
~SimpleArray();
// std move
SimpleArray(SimpleArray<T,Algo> &&obj) noexcept;
SimpleArray<T,Algo> & operator = (SimpleArray<T,Algo> &&obj) noexcept;
// methods
bool isEmpty() const;
bool notEmpty() const;
void erase();
// range access
T * getPtr() { return ptr; }
const T * getPtr() const { return ptr; }
const T * getPtr_const() const { return ptr; }
ulen getLen() const { return len; }
// index access
T & operator [] (ulen index);
const T & operator [] (ulen index) const;
T & at(ulen index);
const T & at(ulen index) const;
// apply
auto apply(FuncInitArgType<T &> func_init);
auto apply(FuncInitArgType<const T &> func_init) const;
auto apply_const(FuncInitArgType<const T &> func_init) const;
auto applyReverse(FuncInitArgType<T &> func_init);
auto applyReverse(FuncInitArgType<const T &> func_init) const;
auto applyReverse_const(FuncInitArgType<const T &> func_init) const;
// swap/move objects
void objSwap(SimpleArray<T,Algo> &obj);
explicit SimpleArray(ToMoveCtor<SimpleArray<T,Algo> > obj);
};
SimpleArray allocates space dynamically.
SimpleArray is std movable. The original object is nullified during the move.
Unlike TempArray, SimpleArray is swappable and movable.
DynArray is the "main" of Arrays. It stores elements in a memory space with some reserved memory behind. It can extend the range of elements, if there is an extra memory. If not and the type T supports moving, then the array extension can be performed with either the memory block extension (using MemExtend()) or the total reallocation with the content moving. You can also release the extra memory. All details of the array functionality can be customized using the second template argument, which is an Algorithm Package of array algorithms.
Alone with standard methods, DynArray has a bunch of methods to initialize and control the array content.
template <class T,class Algo=ArrayAlgo<T> >
class DynArray : NoCopy
{
....
public:
// constructors
DynArray() noexcept ;
template <class S>
explicit DynArray(std::initializer_list<S> il);
explicit DynArray(ulen len);
DynArray(ulen len,ulen maxlen);
DynArray(DoReserveType,ulen maxlen);
explicit DynArray(DoRaw dotype);
template <class ... SS>
explicit DynArray(DoFill dotype,SS && ... ss);
DynArray(DoCopy dotype,const T src[]);
template <class S>
DynArray(DoCast dotype,const S src[]);
DynArray(DoSwap dotype,T objs[]);
DynArray(DoCreate dotype,CreatorType<T> creator);
DynArray(DoBuildType,BuilderType<T> builder);
~DynArray();
// std move
DynArray(DynArray<T,Algo> &&obj) noexcept;
DynArray<T,Algo> & operator = (DynArray<T,Algo> &&obj) noexcept;
Non-default constructors reserve some space and build some elements. The DoRaw, ..., DoCreate arguments carry the length and the reserved length of the array to be used.
Non-default constructors work the same way as the correspondent extend...() methods.
DynArray(std::initializer_list<S> il) uses the initialization list to "cast" elements from the given.
DynArray(ulen len) creates the array of the len elements using the default constructor.
DynArray(ulen len,ulen maxlen) also performs the default initialization of the len elements, but reserves a space for the maxlen elements. An exception is thrown, if len is greater than maxlen.
DynArray(DoReserveType,ulen maxlen) just reserves a space.
DynArray(DoRaw dotype) performs the "raw" initialization. If the T is a POD type, elements are not initialized. If not, the default initialization is performed.
DynArray(DoFill dotype,SS && ... ss) creates new elements using some constructor, the specified arguments are forwarded to this constructor.
DynArray(DoCopy dotype,const T src[]) creates new elements using the copy constructor, src is a range of length dotype.getLen(), its members are copied memberwise.
DynArray(DoCast dotype,const S src[]) creates new elements using the "cast" constructor, src is a range of length dotype.getLen(), its members are casted memberwise.
DynArray(DoSwap dotype,T objs[]) creates new elements using the "swap move" approach. I.e. new elements are created using the default constructor and swapped with members of the range objs.
DynArray(DoCreate dotype,CreatorType<T> creator) uses the given Creator object to create new elements.
DynArray(DoBuildType,BuilderType<T> builder) uses the given Builder object to create new elements.
DynArray is std movable. The original object is nullified during the move.
// range access T * getPtr(); const T * getPtr() const; const T * getPtr_const() const; ulen getLen() const; ulen getMaxLen() const; ulen getExtraLen() const; // index access T & operator [] (ulen index); const T & operator [] (ulen index) const; T & at(ulen index); const T & at(ulen index) const;
Range access and index access methods are standard. Two additional methods report memory allocation.
getMaxLen() returns the reserved array length (in objects).
getExtraLen() is the extra space available (in objects).
// methods bool isEmpty() const; bool notEmpty() const; void cloneTo(DynArray<T,Algo> &ret) const; void reserve(ulen extra_len); void erase();
isEmpty() returns true iff the array is empty.
notEmpty() returns true iff the array is not empty.
cloneTo() clones the array. The reserved length is also preserved. The type T must be copyable.
reserve() reserves the space for extra_len objects.
erase() erases the array, it gets to the null state, with no objects and no memory allocated.
// shrink ulen shrink(ulen delta_len); bool shrink_one(); ulen shrink_all(); void shrink_extra(); void shrink_reserve(ulen maxlen); void shrink_reserve();
shrink() destroys the last up to delta_len elements of the array. It returns the number of elements destroyed.
shrink_one() destroys the last element (if any). It returns true, if the element is destroyed, and false if the array is empty.
shrink_all() destroys all array elements. It returns the number of elements destroyed.
These three methods doesn't change the reserved array length.
shrink_extra() shrinks the memory block, returning the extra memory to the heap. After this method the reserved array length becomes equal to the array length.
shrink_reserve(ulen maxlen) may shrink the memory block to store the given number of elements. It gives a more precise control over the reserved memory. It works only if the following natural condition satisfied: maxlen<getMaxLen() and maxlen>=getLen().
shrink_reserve() works as shrink_reserve(ulen maxlen) with maxlen equals "double size" of the actual array length.
// extend PtrLen<T> extend_raw(ulen delta_len); PtrLen<T> extend_default(ulen delta_len); template <class ... SS> PtrLen<T> extend_fill(ulen delta_len,SS && ... ss); PtrLen<T> extend_copy(ulen delta_len,const T src[]); PtrLen<T> extend_copy(PtrLen<const T> src); template <class S> PtrLen<T> extend_cast(ulen delta_len,const S src[]); template <class S> PtrLen<T> extend_cast(PtrLen<const S> src); PtrLen<T> extend_swap(ulen delta_len,T objs[]); PtrLen<T> extend_swap(PtrLen<T> objs); PtrLen<T> extend(ulen delta_len,CreatorType<T> creator); PtrLen<T> extend(BuilderType<T> builder); template <class S,FuncInitType<T,S> FuncInit> PtrLen<T> extend_transform(PtrLen<S> src,FuncInit func_init); template <class S,FuncInitType<T,S> FuncInit> PtrLen<T> extend_transform_nothrow(PtrLen<S> src,FuncInit func_init);
extend...() is a family of methods, which extends the array with number elements. They differ in element construction ways. All of them, except the last, has the first argument delta_len, which is the number of new elements. The return value is the range of these new elements. extend...() are transactional, i.e. if the method has failed, then the array remains in the original state, an exception is thrown.
extend_raw() for POD types leaves new elements uninitialized. For other types it works like extend_default().
extend_default() creates new elements using the default constructor.
extend_fill() creates new elements using some constructor, the specified arguments are forwarded to this constructor.
extend_copy() creates new elements using the copy constructor, src is a range of length delta_len, its members are copied memberwise.
extend_cast() creates new elements using the "cast" constructor, src is a range of length delta_len, its members are casted memberwise.
extend_swap() creates new elements using the "swap move" approach. I.e. new elements are created using the default constructor and swapped with members of the range objs.
Two following extend() are generic. The first of them uses the given Creator object to create new elements, and the second uses the Builder. See below explanations about Creators and Builders.
extend_transform() and extend_transform_nothrow() extends array on transformed output from the given range. The second argument is a functor, it is called per each element of the input range — the first argument. The resulting sequence of objects extends the array. Use nothrow variant if the functor is "nothrow".
// append T * append_raw(); T * append_default(); template <class ... SS> T * append_fill(SS && ... ss); T * append_copy(const T &src); T * append_swap(T &obj); T * append(CreatorType<T> creator);
append...() is a family of methods to append one element to the array. They are similar to the correspondent extend...() methods and do exactly the same with delta_len equals 1. The return value is a pointer to the created element.
// apply auto apply(FuncInitArgType<T &> func_init); auto apply(FuncInitArgType<const T &> func_init) const; auto apply_const(FuncInitArgType<const T &> func_init) const; auto applyReverse(FuncInitArgType<T &> func_init); auto applyReverse(FuncInitArgType<const T &> func_init) const; auto applyReverse_const(FuncInitArgType<const T &> func_init) const;
apply...() methods are standard.
// swap/move objects void objSwap(DynArray<T,Algo> &obj); explicit DynArray(ToMoveCtor<DynArray<T,Algo> > obj); };
DynArray is swappable and movable.
RefArray and AtomicRefArray are copyable arrays with efficient copy constructors. It's assumed, the type T is copyable. Multiple copies of arrays may share the same state. The state has a reference counter, which is used to end its life-time. The only difference between RefArray and AtomicRefArray is the former uses the atomic reference counting to be viable in a multi-threaded environment.
RefArray has a simulated value semantic. It means, that you may consider different copies of an array as independent variables, despite they may share the state. That is because RefArray provides only a constant access to elements. So far you don't violate this constantness (using the const-cast, for example), you may safely assume that each copy is different. To modify the array you have to call the method modify() (or modifyReverse()). This method "unshares" the array, if necessary, and gives a non-constant access to elements. modifyReverse() is doing the same thing as modify(), but gives a "reversed" range of elements.
template <class T,class Algo=ArrayAlgo<T> >
class RefArray
{
....
public:
// constructors
RefArray() noexcept;
template <class S>
explicit RefArray(std::initializer_list<S> il);
explicit RefArray(ulen len);
RefArray(ulen len,ulen maxlen);
RefArray(DoReserveType,ulen maxlen);
explicit RefArray(DoRaw dotype);
template <class ... SS>
explicit RefArray(DoFill dotype,SS && ... ss);
RefArray(DoCopy dotype,const T src[]);
template <class S>
RefArray(DoCast dotype,const S src[]);
RefArray(DoSwap dotype,T objs[]);
RefArray(DoCreate dotype,CreatorType<T> creator);
RefArray(DoBuildType,BuilderType<T> builder);
~RefArray();
// range access
const T * getPtr() const;
const T * getPtr_const() const;
ulen getLen() const;
ulen getMaxLen() const;
ulen getExtraLen() const;
// index access
const T & operator [] (ulen index) const;
const T & at(ulen index) const;
// methods
bool isEmpty() const;
bool notEmpty() const;
PtrLen<T> modify();
PtrLenReverse<T> modifyReverse() { return RangeReverse(modify()); }
void cloneTo(RefArray<T,Algo> &ret) const;
void reserve(ulen extra_len);
void erase();
// shrink
ulen shrink(ulen delta_len);
bool shrink_one();
ulen shrink_all();
void shrink_extra();
void shrink_reserve(ulen maxlen);
void shrink_reserve();
// extend
PtrLen<T> extend_raw(ulen delta_len);
PtrLen<T> extend_default(ulen delta_len);
template <class ... SS>
PtrLen<T> extend_fill(ulen delta_len,SS && ... ss);
PtrLen<T> extend_copy(ulen delta_len,const T src[]);
PtrLen<T> extend_copy(PtrLen<const T> src);
template <class S>
PtrLen<T> extend_cast(ulen delta_len,const S src[]);
template <class S>
PtrLen<T> extend_cast(PtrLen<const S> src);
PtrLen<T> extend_swap(ulen delta_len,T objs[]);
PtrLen<T> extend_swap(PtrLen<T> objs);
PtrLen<T> extend(ulen delta_len,CreatorType<T> creator);
PtrLen<T> extend(BuilderType<T> builder);
template <class S,FuncInitType<T,S> FuncInit>
PtrLen<T> extend_transform(PtrLen<S> src,FuncInit func_init);
template <class S,FuncInitType<T,S> FuncInit>
PtrLen<T> extend_transform_nothrow(PtrLen<S> src,FuncInit func_init);
// append
T * append_raw();
T * append_default();
template <class ... SS>
T * append_fill(SS && ... ss);
T * append_copy(const T &src);
T * append_swap(T &obj);
T * append(CreatorType<T> creator);
// apply
void apply_modify(FuncInitArgType<T &> func_init func_init);
void apply(FuncInitArgType<const T &> func_init) const;
void applyReverse_modify(FuncInitArgType<T &> func_init);
void applyReverse(FuncInitArgType<const T &> func_init) const;
// swap/move objects
void objSwap(RefArray<T,Algo> &obj);
explicit RefArray(ToMoveCtor<RefArray<T,Algo> > obj);
};
The RefArray methods are mostly the same as DynArray methods. The differences are: index and range access methods gives only the constant access, and new class-specific methods modify() and modifyReverse() exist.
apply_modify() applies the functor, given by a Functor Init, to array elements. The array is unshared first.
applyReverse_modify() applies the functor, given by a Functor Init, to array elements in the reverse order. The array is unshared first.
apply() applies the functor, given by a Functor Init, to array elements. This is a constant method.
applyReverse() applies the functor, given by a Functor Init, to array elements in the reverse order. This is a constant method.
AtomicRefArray methods shrink_extra() and shrink_reserve() are not working, if the array is shared.
AtomicRefArray has an extra special constructor
template <ulen MaxLen> requires ( MaxLen>0 ) static constexpr ulen StaticMemLen = Base::template StaticMemLen<MaxLen> ; template <class S> AtomicRefArray(void *mem,ulen maxlen,std::initializer_list<S> il) requires ( TrivDtorType<T> ) // mem is aligned , maxlen > 0 , il.size() <= maxlen , static object ! : AtomicRefArrayBase<T,Algo>(mem,maxlen) { Base::Extend_cast(ptr.getPtr(),il.size(),il.begin()); }
This constructor can be used to create a static AtomicRefArray with unlimited life-time. The type T must have a trivial destructor, however. You must supply a statically allocated memory, aligned and proper size. You also must supply a maximum number of elements (>0) and an intializer list. To calculate the required memory size use the meta constant StaticMemLen. The object state, created with this constructor, lives forever and contains the initial object array, initialized from the given intializer list.
Collector is not an array! The purpose of this container is to be an efficient collector of elements. This container stores a sequence of elements in a list of arrays. So appending and extending operations are the most efficient. At desired moment you can copy or move this sequence into true array. Or you can "flat" the Collector itself.
template <class T,class Algo=ArrayAlgo<T> >
class Collector : NoCopy
{
....
public:
// constructors
static constexpr ulen DefaultBlockLen = 1024 ;
static constexpr ulen MinBlockLen = 10 ;
explicit Collector(ulen block_len=DefaultBlockLen) noexcept;
~Collector();
// std move
Collector(Collector<T,Algo> &&obj) noexcept;
Collector<T,Algo> & operator = (Collector<T,Algo> &&obj) noexcept;
The argument of the Collector constructor is the number of elements in the single element block. The default value is 1024.
Collector is std movable. The original object is nullified during the move.
// methods bool isEmpty() const; bool notEmpty() const; ulen getLen() const; void erase(); template <class Container> void extractTo(Container &ret) { Container temp(DoBuild,Extractor(this)); Swap(temp,ret); } template <class Container> void copyTo(Container &ret) const { Container temp(DoBuild,Copyrator(this)); Swap(temp,ret); } PtrLen<T> flat();
Collector does not provide a direct access to its content.
isEmpty() returns true iff the array is empty.
notEmpty() returns true iff the array is not empty.
getLen() is the number of the collected elements.
erase() cleanup the container and put it into the null state.
extractTo() moves the content to another (array) container. The target container must have the Build constructor. Collector becomes empty after this operation.
copyTo() copies the content to another (array) container. The target container must have the Build constructor.
flat() rebuilds the internal data storage, making it continuous. It returns the range of elements. This range remains valid after extend or append operations (but may become invalid after any other modifying operations).
// shrink ulen shrink(ulen delta_len); bool shrink_one(); ulen shrink_all(); void shrink_extra(); // extend PtrLen<T> extend_raw(ulen delta_len); PtrLen<T> extend_default(ulen delta_len); template <class ... SS> PtrLen<T> extend_fill(ulen delta_len,SS && ... ss); PtrLen<T> extend_copy(ulen delta_len,const T src[]); PtrLen<T> extend_copy(PtrLen<const T> src); template <class S> PtrLen<T> extend_cast(ulen delta_len,const S src[]); template <class S> PtrLen<T> extend_cast(PtrLen<const S> src); PtrLen<T> extend_swap(ulen delta_len,T objs[]); PtrLen<T> extend_swap(PtrLen<T> objs); PtrLen<T> extend(ulen delta_len,CreatorType<T> creator); PtrLen<T> extend(BuilderType<T> builder); template <class S,FuncInitType<T,S> FuncInit> PtrLen<T> extend_transform(PtrLen<S> src,FuncInit func_init); template <class S,FuncInitType<T,S> FuncInit> PtrLen<T> extend_transform_nothrow(PtrLen<S> src,FuncInit func_init); // append T * append_raw(); T * append_default(); template <class ... SS> T * append_fill(SS && ... ss); T * append_copy(const T &src); T * append_swap(T &obj); T * append(CreatorType<T> creator);
shrink...(), extend...() and append...() methods are the same as for DynArray.
// swap/move object void objSwap(Collector<T,Algo> &obj); explicit Collector(ToMoveCtor<Collector<T,Algo> > obj); };
Collector is swappable and movable.
CCore Array implementation is based on the Array Algorithm Packages. The default package is the ArrayAlgo.
template <class T,class Flags=GetNoThrowFlags<T> > struct ArrayAlgo;
The exact implementation depends on the kind of T.
If the type T defines the inner type ArrayAlgoType, then this type will be used as the package.
Otherwise there are two variants: one for the POD types, another for the other (class) types.
ArrayAlgo_class is the generic (class) variant. The template argument Flags provides two flags: Default_no_throw and Copy_no_throw. The flag is true, if the correspondent constructor (default or copy) is no-throw or does not exist. It's an obligation of the class. The flag MoveTo_exist is true for replaceable types. For such types an array can grow above the initial memory allocation length.
template <NothrowDtorType T,class Flags=GetNoThrowFlags<T> >
struct ArrayAlgo_class : ArrayAlgoBase<T>
{
enum PropFlagType
{
Default_no_throw = Flags::Default_no_throw,
Copy_no_throw = Flags::Copy_no_throw,
MoveTo_exist = Meta::PoorFlag<T, ReplaceableType<T> >
};
static PtrLen<T> Create_raw(Place<void> place,ulen len) requires ( DefaultCtorType<T> ) ;
static PtrLen<T> Create_default(Place<void> place,ulen len) requires ( DefaultCtorType<T> ) ;
template <class ... SS>
static PtrLen<T> Create_fill(Place<void> place,ulen len,SS && ... ss) requires ( ConstructibleType<T,SS...> ) ;
static PtrLen<T> Create_copy(Place<void> place,ulen len,const T src[]) requires ( CopyCtorType<T> ) ;
template <class S>
static PtrLen<T> Create_cast(Place<void> place,ulen len,const S src[]) requires ( ConstructibleType<T,const S> ) ;
static PtrLen<T> Create_swap(Place<void> place,ulen len,T objs[]) requires ( DefaultCtorType<T> ) ;
//
// Single
//
static T * Create_swap(Place<void> place,T &obj) noexcept( Default_no_throw ) requires ( DefaultCtorType<T> ) ;
//
// ProvideLen() : double extension
//
static ulen ProvideLen(ulen len,ulen maxlen,ulen extra_len);
//
// MoveTo() : no-throw
//
static PtrLen<T> MoveTo(T *ptr,ulen len,Place<void> place) noexcept requires ( ReplaceableType<T> ) ;
};
The package has the following members.
Flags Default_no_throw and Copy_no_throw are copied from the Flags.
Flag MoveTo_exist is true for replaceable types.
Create_...() creates a range of objects of the type T at the given place. To create an object, the correspondent constructor is called. Objects are created in the ascending order. If some constructor throw an exception, then the previously constructed objects are destroyed and the exception is propagated. The range of the created objects is returned. The first two arguments are: the place to construct and the number of elements to construct. The place must be properly aligned and the memory space must be large enough to contain the required number of objects.
Create_raw() and Create_default() use the default constructor.
Create_fill() uses a constructor with the given set of arguments for each object.
Create_copy() uses the copy constructor. The arguments are memberwise selected from the provided range of objects.
Create_cast() uses the "cast" constructor. The arguments are memberwise selected from the provided range of objects.
Create_swap() uses the default constructor and the swap operation to create objects. The arguments for the swap are memberwise selected from the provided range of objects.
The single Create_swap() function "creates-swap" a single object.
ProvideLen() is used to reallocate an array. It is called if there is no sufficient memory to extend the array. The len is the array length, the extra_len is the number of extra objects to be constructed, the maxlen is the allocated length. The length returned is sufficient to extend the array and at least double of the maxlen. An exception is thrown in case of overflow.
MoveTo() moves the given range to a new place. The old place becomes a raw memory. The range of new objects is returned.
Other members are inherited from the ArrayAlgoBase<T>.
ArrayAlgo_pod is the POD variant.
template <PODType T>
struct ArrayAlgo_pod : ArrayAlgoBase_nodtor<T>
{
enum PropFlagType
{
Default_no_throw = true,
Copy_no_throw = true,
MoveTo_exist = true
};
static PtrLen<T> Create_raw(Place<void> place,ulen len);
static PtrLen<T> Create_default(Place<void> place,ulen len);
template <class ... SS>
static PtrLen<T> Create_fill(Place<void> place,ulen len,SS && ... ss) requires ( ConstructibleType<T,SS...> ) ;
static PtrLen<T> Create_copy(Place<void> place,ulen len,const T src[]);
template <class S>
static PtrLen<T> Create_cast(Place<void> place,ulen len,const S src[]) requires ( ConstructibleType<T,const S> ) ;
static PtrLen<T> Create_swap(Place<void> place,ulen len,T objs[]);
//
// Single : no-throw
//
static T * Create_swap(Place<void> place,T &obj) noexcept;
//
// ProvideLen() : double extension
//
static ulen ProvideLen(ulen len,ulen maxlen,ulen extra_len);
//
// MoveTo() : no-throw
//
static PtrLen<T> MoveTo(T *ptr,ulen len,Place<void> place) noexcept;
};
Flags Default_no_throw, Copy_no_throw and MoveTo_exist are all true.
Create_raw() is not using default initialization. It leaves the memory uninitialized.
Other members are inherited from the ArrayAlgoBase_nodtor<T>.
ArrayAlgo_mini is the mini variant without object moving. It is assumed only, that the destructor ~T() is no-throw. Swap and move are not used.
template <class T,class Flags>
struct ArrayAlgo_mini : ArrayAlgoBase<T>
{
enum PropFlagType
{
Default_no_throw = Flags::Default_no_throw,
Copy_no_throw = Flags::Copy_no_throw,
MoveTo_exist = false
};
static PtrLen<T> Create_raw(Place<void> place,ulen len) requires ( DefaultCtorType<T> ) ;
static PtrLen<T> Create_default(Place<void> place,ulen len) requires ( DefaultCtorType<T> ) ;
template <class ... SS>
static PtrLen<T> Create_fill(Place<void> place,ulen len,SS && ... ss) requires ( ConstructibleType<T,SS...> ) ;
static PtrLen<T> Create_copy(Place<void> place,ulen len,const T src[]) requires ( CopyCtorType<T> ) ;
template <class S>
static PtrLen<T> Create_cast(Place<void> place,ulen len,const S src[]) requires ( ConstructibleType<T,const S> ) ;
};
The flag MoveTo_exist is false.
Other members are inherited from the ArrayAlgoBase<T>.
The following functions: Create_swap(), ProvideLen(), MoveTo() are omitted. Array, constructed with this algorithm package, cannot be extended beyond the initial memory allocation length.
To use this package with the DynArray you can use the following type:
template <class T>
using MiniDynArray = DynArray<T,ArrayAlgo_mini<T> > ;
ArrayAlgoBase is a common package for all ArrayAlgos. It has two variants: common and specialized ArrayAlgoBase_nodtor for types with the trivial destructor.
template <NothrowDtorType T>
struct ArrayAlgoBase : ArrayAlgoMemBase
{
//
// Guards
//
class BuildGuard;
class CreateGuard;
class CreateGuard_nothrow;
template <bool no_throw> class CreateGuardNoThrow;
//
// Create() : clean on throw
//
template <CreatorType<T> Creator>
static PtrLen<T> Create(Place<void> place,ulen len,Creator creator) noexcept( Creator::NoThrow ) ;
//
// single Destroy() : no-throw
//
static void Destroy(T *ptr) noexcept;
//
// Destroy() : no-throw
//
static void Destroy(T *ptr,ulen len) noexcept;
};
template <NothrowDtorType T> requires ( TrivDtorType<T> )
struct ArrayAlgoBase<T> : ArrayAlgoBase_nodtor<T> {};
Create() uses the given creator for the object creation. See below about creators.
Single Destroy() destroys the object (but don't free the memory).
Range Destroy() destroys the given range of objects.
There are four inner "guard" classes. They are used to created a range of objects. Guards are responsible for the object destruction in case of failure.
class BuildGuard : NoCopy
{
Place<void> place;
T *ptr;
ulen len;
public:
explicit BuildGuard(Place<void> place_) : place(place_),ptr(place_),len(0) {}
~BuildGuard() { if( len ) Destroy(ptr,len); }
Place<void> at() const { return place; }
void operator ++ () { place+=sizeof (T); len++; }
PtrLen<T> disarm() { return Range(ptr,Replace_null(len)); }
};
BuildGuard is used to create a range of objects. The constructor argument is the place for the range. It must be properly aligned and the memory space must be large enough to store the range.
at() is the current place for the object creation.
operator ++ () must be called after the successful creation of an object at the current position, it moves to the next object position.
disarm() is called after the desired number of objects are created. It "disarms" the guard and returns the created range.
The BuildGuard destructor destroys the created objects. It must be disarmed to prevent the destruction.
class CreateGuard : public BuildGuard
{
public:
CreateGuard(Place<void> place,ulen /*final_len*/) : BuildGuard(place) {}
~CreateGuard() {}
};
CreateGuard is used for creation a range of objects with the given length. Constructor's arguments are: the place of the range and the final number of objects. The remaining methods are the same as for BuildGuard. Using CreateGuard you must create the exact number of objects.
class CreateGuard_nothrow : NoCopy
{
Place<void> place;
T *ptr;
ulen final_len;
public:
CreateGuard_nothrow(Place<void> place_,ulen final_len_) : place(place_),ptr(place_),final_len(final_len_) {}
Place<void> at() const { return place; }
void operator ++ () { place+=sizeof (T); }
PtrLen<T> disarm() { return Range(ptr,final_len); }
};
CreateGuard_nothrow is a "no-throw" variant of the CreateGuard. It is used for the creation of a range of objects with the given length, if there will be no exceptions during the objects construction.
template <bool no_throw>
class CreateGuardNoThrow : NoCopy
{
public:
CreateGuardNoThrow(Place<void> place,ulen final_len);
~CreateGuardNoThrow();
};
CreateGuardNoThrow is the one of the CreateGuard and CreateGuard_nothrow, depending on the no_throw template parameter.
Below is the implementation of the generic Create, it uses the CreateGuardNoThrow.
template <CreatorType<T> Creator>
static PtrLen<T> Create(Place<void> place,ulen len,Creator creator) noexcept( Creator::NoThrow )
{
CreateGuardNoThrow<Creator::NoThrow> guard(place,len);
FunctorTypeOf<Creator> func(creator);
for(; len ;len--,++guard) func(guard.at());
return guard.disarm();
}
ArrayAlgoBase_nodtor<T> provides the same set of algorithms, but implemented with respect to destructor triviality.
template <TrivDtorType T>
struct ArrayAlgoBase_nodtor : ArrayAlgoMemBase
{
//
// Guards
//
class BuildGuard;
class CreateGuard;
class CreateGuard_nothrow;
template <bool no_throw> class CreateGuardNoThrow;
//
// Create()
//
template <CreatorType<T> Creator>
static PtrLen<T> Create(Place<void> place,ulen len,Creator creator) noexcept( Creator::NoThrow ) ;
//
// single Destroy() : empty
//
static void Destroy(T *) noexcept
{
}
//
// Destroy() : empty
//
static void Destroy(T *,ulen) noexcept
{
}
};
Creator is a functor, creating objects. It looks like this:
class Creator // copy efficient { .... public: enum NoThrowFlagType { NoThrow = .... }; Creator(....); T * operator () (Place<void> place) noexcept(NoThrow); };
Or like this:
class Creator // copy efficient functor initializer { .... public: enum NoThrowFlagType { NoThrow = .... }; Creator(....); class FunctorType : NoCopy // heavy functor { .... public: explicit FunctorType(Creator init); ~FunctorType(); T * operator () (Place<void> place) noexcept(NoThrow); }; };
You may use a Creator in a generic array "Creator" constructors and methods.
Builder is a functor, creating a range of objects. It looks like:
class Builder // copy efficient { public: Builder(....); ulen getLen() const; PtrLen<T> operator () (Place<void> place) const; // may create up to getLen() objects };
Or like this:
class Builder // copy efficient functor initializer { public: Builder(....); ulen getLen() const; class FunctorType : NoCopy // heavy functor { .... public: explicit FunctorType(Builder init); ~FunctorType(); PtrLen<T> operator () (Place<void> place) const; // may create up to getLen() objects }; };
Builder reports the maximum object number it will create through the method getLen(). operator () gets the place for the range of getLen() elements, it either creates the range of objects up to this length and returns it, or leaves the memory raw and throws an exception.
You may use a Builder in a generic array "Builder" constructors and methods.
There are two concepts for creators and builders:
template <class Creator,class T> concept bool CreatorType = .... ; template <class Builder,class T> concept bool BuilderType = .... ;
There is a list of standard creators.
/* struct Creator_default<T,bool no_throw> */ template <class T,bool no_throw> struct Creator_default { enum NoThrowFlagType { NoThrow = no_throw }; Creator_default() {} T * operator () (Place<void> place) noexcept( no_throw ) { return new(place) T(); } }; /* struct Creator_fill<T,SS> */ template <class T,class ... SS> struct Creator_fill { enum NoThrowFlagType { NoThrow = false }; ForwardTuple<SS...> ss; explicit Creator_fill(SS && ... ss_) : ss( std::forward<SS>(ss_)... ) {} T * operator () (Place<void> place) { return ss.call( [place] (SS && ... ss) { return new(place) T( std::forward<SS>(ss)... ); } ); } }; /* struct Creator_copy<T,bool no_throw> */ template <class T,bool no_throw> struct Creator_copy { enum NoThrowFlagType { NoThrow = no_throw }; const T *src; explicit Creator_copy(const T *src_) : src(src_) {} T * operator () (Place<void> place) noexcept( no_throw ) { return new(place) T(*(src++)); } }; /* struct Creator_cast<T,S> */ template <class T,class S> struct Creator_cast { enum NoThrowFlagType { NoThrow = false }; const S *src; explicit Creator_cast(const S *src_) : src(src_) {} T * operator () (Place<void> place) { return new(place) T(*(src++)); } }; /* struct Creator_swap<T,Algo> */ template <class T,class Algo> struct Creator_swap { enum NoThrowFlagType { NoThrow = Algo::Default_no_throw }; T *objs; explicit Creator_swap(T *objs_) : objs(objs_) {} T * operator () (Place<void> place) noexcept( Algo::Default_no_throw ) { return Algo::Create_swap(place,*(objs++)); } }; /* struct Creator_transform<T,S,FuncInit,bool NoThrow> */ template <class T,class S,FuncInitType<T,S> FuncInit,bool NoThrow_> struct Creator_transform { enum NoThrowFlagType { NoThrow = NoThrow_ }; S *src; FuncInit func_init; Creator_transform(S *src_,const FuncInit &func_init_) : src(src_),func_init(func_init_) {} struct FunctorType : NoCopy { S *src; FunctorTypeOf<FuncInit> func; explicit FunctorType(Creator_transform init) : src(init.src),func(init.func_init) {} T * operator () (Place<void> place) noexcept(NoThrow) { return new(place) T( func(*(src++)) ); } }; };
All default algorithm packages inherit the base class ArrayAlgoMemBase.
struct ArrayAlgoMemBase
{
static void * MemAlloc(ulen len) { return ::CCore::MemAlloc(len); }
static bool MemExtend(void *mem,ulen len) { return ::CCore::MemExtend(mem,len); }
static bool MemShrink(void *mem,ulen len) { return ::CCore::MemShrink(mem,len); }
static void MemFree(void *mem) { ::CCore::MemFree(mem); }
};
This class defines default memory-management functions, used by arrays to allocate, extend, shrink and release memory blocks. If you define a custom algorithm package for your purpose, you may define custom memory allocation functions with the following semantic.
MemAlloc() allocates a memory block of the required length. The block is aligned. An exception is thrown in case of error.
MemFree() releases the previously allocated memory block. The function is never called with the null argument.
MemExtend() tries to extend the previously allocated memory block length to be at least the given argument. If the return value is true, then the attempt was successful.
MemShrink() shrinks the memory block length to be at least the given argument. The return value is never used.
Insert or delete array elements in the middle of the array are not natural array methods. They have a linear complexity. But sometimes they are necessary. These algorithms are implemented as free functions.
/* del functions */ template <class A> bool ArrayCopyDel(A &a,ulen ind); template <class A> bool ArraySwapDel(A &a,ulen ind); template <class A> void ArrayCopyDel_guarded(A &a,ulen ind); template <class A> void ArraySwapDel_guarded(A &a,ulen ind);
These functions delete an element from the array at the given index. The first two return false if the index is invalid. The last two throw an exception in such case. CopyDel copies elements, SwapDel uses swapping.
/* del range functions */ template <class A> ulen ArrayCopyDelRange(A &array,ulen ind,ulen count); template <class A> ulen ArraySwapDelRange(A &array,ulen ind,ulen count); template <class A> void ArrayCopyDelRange_guarded(A &array,ulen ind,ulen count); template <class A> void ArraySwapDelRange_guarded(A &array,ulen ind,ulen count);
These functions delete a range of elements from the array. The first two return the count of deleted elements. The last two throw an exception if the subrange does not fit the array range. CopyDel copies elements, SwapDel uses swapping.
/* ins functions */ template <class A,class ... SS> bool ArraySwapIns(A &a,ulen ind,SS && ... ss); template <class A,class ... SS> bool ArrayCopyIns(A &a,ulen ind,SS && ... ss); template <class A,class ... SS> auto ArraySwapIns_guarded(A &a,ulen ind,SS && ... ss); template <class A,class ... SS> auto ArrayCopyIns_guarded(A &a,ulen ind,SS && ... ss);
These functions insert an element to the array at the given index. The valid index range is [0,len], where len is the array length. The first two cap the index and return false if the index is out of range. The last two throw an exception in such case. They also return the pointer to the inserted object. CopyIns copies elements, SwapIns uses swapping. Extra arguments are used to call an element constructor.
/* ins range functions */ template <class A> auto ArrayInsRange_default(A &array,ulen ind,ulen count); template <class A,class ... SS> auto ArrayInsRange_fill(A &array,ulen ind,ulen count,SS && ... ss); template <class A> auto ArrayInsRange_copy(A &array,ulen ind,ulen count,const T *src); // const T * == decltype(array.getPtr_const()) template <class A> auto ArrayInsRange_copy(A &array,ulen ind,PtrLen<const T> src); // const T == Meta::PtrObjType<decltype(array.getPtr_const())> template <class A,class S> auto ArrayInsRange_cast(A &array,ulen ind,ulen count,const S src[]); template <class A,class S> auto ArrayInsRange_cast(A &array,ulen ind,PtrLen<const S> src); template <class A> auto ArrayInsRange_swap(A &array,ulen ind,ulen count,T *objs); // T * == decltype(array.getPtr()) template <class A> auto ArrayInsRange_swap(A &array,ulen ind,PtrLen<T> objs); // T == Meta::PtrObjType<decltype(array.getPtr())> template <class A> auto ArrayInsRange(A &array,ulen ind,ulen count,CreatorType<T> creator); // T == Meta::PtrObjType<decltype(array.getPtr())> template <class A> auto ArrayInsRange(A &array,ulen ind,BuilderType<T> builder); // T == Meta::PtrObjType<decltype(array.getPtr())>
All these functions insert a range of elements into the array. ind determines the index of insertion. The range (as PtrLen) of created elements if returned. If ind exceeds the array length, elements are created at the end of the array.
/* ins range prepare functions */ template <class A> void ArrayInsRangeGuard(A &array,ulen ind); template <class A> void ArrayInsRangeFill(A &array,ulen ind); template <class A> void ArrayInsRangeFill(A &array,ulen ind,ulen count);
These functions can be used to "prepare" the array for an element insertion. They are intended to be used with conjunction of insertion functions.
ArrayInsRangeGuard() throws an exception if ind exceeds the array length.
ArrayInsRangeFill() extends the array if ind exceeds the array length to equalize them. The second variant reserves additional memory behind for further extension by count elements.


shebang
`Prev `__
S
`Next `__
--------------
**shebang**: /sh@·bang/, n.
[possibly a portmanteau of “sharp bang”] The character sequence “#!”
that frequently begins executable shell scripts under Unix. Probably
derived from “shell bang” under the influence of American slang “the
whole shebang” (everything, the works).
--------------
+--------------------------------------+----------------------------+------------------------------+
| `Prev `__ | `Up <../S.html>`__ | `Next `__ |
+--------------------------------------+----------------------------+------------------------------+
| sharing violation | `Home <../index.html>`__ | shelfware |
+--------------------------------------+----------------------------+------------------------------+


Image Classifier
Input
Learning
Edit
Train
0
samples
Edit
Train
0
samples
Edit
Train
0
samples
Edit
Train
0
samples
Edit
Train
0
samples
+ Add a class
Output
Class 1
0%
Class 2
0%
Class 3
0%
Class 4
0%
Class 5
0%
Loading Model...
Please wait, the application is loading the modal...


Neil loves to travel and he was so fond of forests.  To celebrate his son’s second birthday, he decided to stay and enjoy the celebration in woods, located at the lap of a mountain. He with his family and friends, reached the village located near the woods and had his stay in a cottage. The cottage was located at the entrance of a dense forest, where the guests could view animals roaming in the nearby place.
Neil’s son saw a dog at the door and offered him a biscuit. The dog was happy and very soon the little boy befriended the dog. On second day, the birthday of the boy was celebrated grandly in the woods within the beautiful mother nature. The dog did not leave the boy even for a minute and they both became close pals.
The next day, Neil, his wife and others decided to go for hunting in the forest and they arranged for a babysitter to take care of their little son for half a day.
After three hours, all the elders returned to the cottage and they seemed very tired. The dog saw Neil and others, it rushed to them and licked Neil’s shoes. The cottage was open and nobody was there.   Everyone was shocked to see the blood-spattered mouth and started to lash the dog. The dog screamed in pain. Neil hit the dog with his gun and it was wounded badly. Hearing the dog’s screaming noise, the babysitter rushed to the entrance with Neil’s son.They were all speechless and enquired what happened to the dog and why there were blood stains around the dog’s mouth.
The babysitter told that the boy was about to get attacked by a wolf which roamed near the house, but luckily it was killed by the dog. She showed the dead wolf to them. They felt so bad and offered first aid to the wounded dog.


--- title: A quick step-by-step guide to build your own website using Blogdown, Github, Netlify author: Xidan Chen date: '2018-11-05' slug: build-website-R categories: - R tags: - R - blogdown - github - netlify - website - tutorial ---
If you are interested in creating your own website through RStudio, but don’t want to spend time reading the book blogdown: Creating Websites with R Markdown, and have no idea about version control, data managment, etc. Here is the step-by-step guide for you:
First, log into your github account, creat a new repository. If you don’t have github account, create one.
In RStudio, create a new project:
Doing so, you now linked your github repository(myrepo) to your RStudio project(myweb).
This step is adopted from section 1.7 of xie yihui’s blogdown book.
Commit and push the changes to github
In RStudio, you will have a screen like this
click Commit, a new window will open
if you’ve made lots of changes to the theme, instead of ticking the boxes of Staged, click Tools > Shell, type git add . This will select all the changes you would like to add. Then commit and push.
Next is to publish your site with Netlify.
click the green button New site from Git
type HUGO_VERSION for the key, 0.50 for the Value
click the Deploy site, now your site is live.
sometimes although following the same procedure, netlify won’t deploy your website, Click on Deploys, Trigger deploy manually, try it several times. Check the Deploy settings, make sure Build command is set to hugo, Publish directory is set to public.
netlify will assign a random Site name to you, go to Settings, change Site name, if you would like to have a unique domain name, check out Domain management. You can purchase one on netlify or get one somewhere else for free. Use your search engine.
Now you have your won website! go back to RStudio, make changes to your website. commit and push the changes to your github account. netlify will automatically publish your new site.
Don’t know how to modify the theme? search xie yihui’s book blogdown: Creating Websites with R Markdown, documentation of your selected theme, online tutorials, etc.
add google analytics to your site: http://cloudywithachanceofdevops.com/posts/2018/05/17/setting-up-google-analytics-on-hugo/#step-1-adding-your-site-to-google-analytics
add a contact form on your website: https://medium.com/@flobin/how-to-set-up-a-contact-form-on-a-static-website-62c2267bacfb
add social sharing using AddThis: https://gohugohq.com/partials/add-this-social-sharing/


Welcome to FullPageOS
Setup instructions in the link below - scan or type
http://bit.ly/setup2019apr16
background by
pagesolar cc-by-nc-sa-2.0


&; Nsp OpenUrl SARS-CoV- structure CrossRef SARS-CoV MERS-CoV NendoU Science chain Abstract FREE Text active site Web RNA protein sequence Acta Biol (PDB Bhardwaj Biol. Crystallogr. Crystallogr., H-CoV-E coronavirus hexamer proteins residues Bozzoni, Caffarelli, Nsps Sect buffer catalytic data domain structures virus Mol PDB Virol determined identity middle structural using Download EndoU Fig. Figure Kao, Laneve, National Open Respiratory SARS Sci Ser Syndrome Ziebuhr, conserved data-hide-link-title=""> data-icon-position="" endoribonuclease enzyme expression figure gene ion lysis metal new protease report shown similarity tab viral (pink), (teal, ;<;span Acad Bhardwaj, C-terminal Guarino, His, Ivanov Joachimiak, Li, Liu, MERS Natl Proc Richardson, SARS- Zhang, activity atom collection coronaviruses family good large loop processing refinement role shows similar subunit work xmlns=";http://www.w.org//xhtml";


{% extends "base.html" %} {% load static i18n %} {% block content %}
Please feel free to contact us to add other missing resources
| Name | Description | PubMed |
|---|---|---|
| GonadSAGE | A comprehensive SAGE database for transcript discovery on male germ cell development | |
| GermSAGE | A comprehensive SAGE database for transcript discovery on male embryonic gonad development | |
GermOnline |
A genomics gateway for germline development | |
SGV |
The Saccharomyces Genomics Viewer | |
| The Ovarian Kaleidoscope Database | An online resource for the ovarian research community | |
GUDMAP |
An online resource for the ovarian research community | |
GermlncRNA |
A unique catalogue of long non-coding RNAs and associated regulations in male germ cell development | |
SpermatogenesisOnline |
A resource for spermatogenesis based on manual literature curation and genome-wide data mining | |
Follicle Online |
An integrated database of follicle assembly, development and ovulation | |
| SpermBase | A database for Sperm-Borne RNA Contents |
Please feel free to contact us to add other missing resources
| Name |
|---|
| The Male Fertility Gene Atlas |
| RGD GBrowse session |
| MGI Mouse JBrowse |
| StaphyloBase |
| EdwardsiellaBase |
| NGSmethDB |
| PlantGDB |


{% extends "base.html" %} {% block content %}
Thank you for signing up! NurseConnect will send you clinical information and tips about working in maternal and child health.
Send this link to a friend that wants to sign up.


Home Page
Adding New Store Info
Location Name:
Min Hourly Customers:
Max Hourly Customers:
Avg Cookies Per Customer:
Salmon Cookies Sales Data
Cookies sold per hour


A first project, initiated as part of the Free Code Camp curriculum. It is a fairly simple page, though not without its flaws. I consider it a work in progress, as I am writing for myself. When I originally wrote it, I was more concerned with the layout than the content.
FCC Portfolio
A second project for the Free Code Camp curriculum. You are currently looking at it; I spent a lot of cycles deciding on the design before I really started coding. I will likely refactor the whole project, only because I feel it could be much cleaner.
Next Project
The third project for the Free Code Camp curriculum. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nam luctus vel elit eu cursus. Nullam vel consectetur velit, non ornare nisi. Sed nec diam et metus imperdiet sodales ac condimentum.


Simple Simon Says
pattern matching game!
The current level is: 0
Off
Strict Mode Off
Reset
Turn on to play


4 Reasons to you need an online fax service
If you have worked in an office that utilizes faxes we all have that love / hate with our fax machines. Whether it is a trusty old machine that never fails or some fancy copier integrated fax that, despite it being brand new, still suffers failures and odd error codes and at times you want to bash it to pieces out in the parking lot during a smoke break. We have been there.
It might be time to move on to something better. Online Faxing.
Here are 3 reasons it makes sense to make the switch:
- Money. plain and simple. Fax machines need toner, paper, occasional replacement and a dedicated phone line. This adds up depending on your usage. $100’s a month just to keep that machine working.
- Security. A physical fax machine can be a security risk as anyone with access to it can see incoming and outgoing faxes. Online faxing is much more secure and faxes can be specifically routed to any individual or group that needs it.
- Convenience and availability. Being able to send / receive and manage faxes using any computer or mobile device makes managing your faxing much easier. No longer are you bound to the office. One can receive and send a fax from any device.
- Enhanced workflow. With online faxing such as WestFax you can route incoming faxes to certain individuals or group email boxes. With the FaxForward functionality you can allow anyone in your organization to send a fax as easily as sending and email. No more having to fill out cover letters and printing off documents. Just attach the document in the email and send it. Easy and no need to deal with busy signals or hardware issues.
Regardless of the reason your fax machine will eventually break and the time and money spent on paper, ink and the landline cost


This file provide the file operating functions.
"use strict";
always first :)
'use strict'
_ = require 'lodash'
colors = require 'colors'
fs = require 'fs'
path = require 'path'
readline = require 'readline'
List a single file.
Used for -l
.
Since this function will be called by a async find,
it only need to handle a single file.
list = (file) ->
console.log 'Found: '.green + file
Just like #list()
, it only need to rename a single file.
rename = (file, renameTo, verbose) ->
newName = path.join(path.dirname(file), path.basename(file, path.extname(file))) + '.' + renameTo
fs.rename file, newName, ->
if verbose
console.log 'File: ' + file.yellow + '\n To: ' + newName.cyan
But this one is different. Since deleting is too dangerous, we want double confirm with the user. So it will be a sync flow.
remove = (files, verbose) ->
if files.length is 0
console.log 'No file to delete, cheers!'.cyan
else
files.forEach (file) ->
console.log file
console.log 'The above files ('.yellow + files.length.toString().red.bold + ' at all) will be removed PERMANENTLY!'.yellow
console.log 'Please double check and make sure you will never want to see them again!'.yellow
console.log 'Input the full path of the first file listed above to continue:'.yellow.bold
expected = path.resolve files[0]
confirmWithUser expected, ->
files.forEach (file) ->
console.log 'Deleting: '.red + file if verbose
fs.unlinkSync file
console.log 'Deleted! Hopefully you will never repent'.green.bold
Or maybe the user don’t want to do such a complex confirmation…
removeSilently = (files, verbose) ->
if files.length is 0
console.log 'No file to delete, cheers!'.cyan
else
files.forEach (file) ->
console.log file
console.log 'The above files ('.yellow + files.length.toString().red.bold + ' at all) will be removed PERMANENTLY!'.yellow
console.log 'Are you really sure? (Y/N)'
confirmWithUser 'Y', ->
files.forEach (file) ->
console.log 'Deleting: '.red + file if verbose
fs.unlinkSync file
console.log 'Deleted! Hopefully you will never repent'.green.bold
Ask user for a confirmation. Used before deleting files.
confirmWithUser = (expected, cb) ->
rl = readline.createInterface
input: process.stdin
output: process.stdout
rl.setPrompt 'I say: ', 7
rl.prompt()
rl.on 'line', (input) ->
try
isCorrect = input.trim() is expected
catch e
isCorrect = false
if isCorrect
rl.close()
cb?()
else
console.log 'Wrong! Try again? Or press Ctrl-C to abort'.yellow
rl.prompt()
module.exports =
list: list
rename: rename
remove: remove
removeSilently: removeSilently


| # | Sample Name | Round Name | Total Enrolled Labs | Total Unresponded | Total Responded | Total Evaluated | Total Unevaluated | Response % |
|---|---|---|---|---|---|---|---|---|
| {{$index+1}} | {{sample.sample.batchName}} | {{sample.round.roundName}} | {{sample.totalLabsAndSamples}} | {{sample.totalUnresponded}} | {{sample.totalResponded}} | {{sample.totalTotalEvaluated}} | {{sample.totalTotalUnevaluated}} | {{sample.responseRate}} |


Hello everybody. This is just a flashlight of what Kwort 3 will be. Kwort 3 brings a whole new era of Kwort Linux, Kwort public might change now, I'm not focusing anymore in inexperienced users, but on intermediate-advanced users and up.
Why is that? Well, kinda I'm forced to do that. Kwort's most important problem was always the kernel, not because Linux is bad, but because some drivers are. For example, wireless drivers tend to suck... I mean, WTH is that closed source microcode needed for most drivers? That's just plain wrong. I'm not talking here about making it free software, but open source would help everybody to make better drivers. Also there are tons of wireless cards out there unsupported (or half supported) because companies not releasing specifications, we are not even talking about open source anything here. COME ON! I'm not going to take this to the free software vs. open source vs. closed software, people who know me, knows that I hate those topics and I leave those to politicians and software philosophers.
Despite of that, some other things are not easy (as it should be) to support, and inexperienced users tend to not know what they want (first they want a desktop, then they want to be able to configure a web server with a GUI (that I'm not going to write) for some php scripting , then they want to create a RAID or LVM). Kwort was always meant to be for the desktop, and the desktop only, not a web server not a redundant file server, etc. And the funny part is: If you don't provide packages for what they want, they get pissed off and I've also got insults because of this. People, what is going on here? It's not like you're paying me (and if you would, that doesn't even give you the right to insult me), you can ask for something. I develop Kwort in my free time. So, advanced users tend to know a lot more, from the work that takes to do something like Kwort, to how to check logs and write or hack some script to do what they want (for example a network configuration script).
So... Kwort 3 is now based on CRUX which will make it more advanced. I'm not changing it to CRUX because I want it to be hard and for truly advanced users, but because Slackware has become a really multi-purpose distribution, and strip out all the "unneeded" stuff for Kwort would take me a lot of time. Also the init system has changed and the way it is configured too. Don't worry about all this, it is already well documented in the new website (this new one is really cool, with tons of information as it always should be but never was). There's no more wizards tools like knm (Kwort network manager) and kum (Kwort user manager), but a console and the chosen editor. Despite of that kum and knm will still be maintained and developed (kind of).
Anyways, Kwort 3 is almost ready be released. There's a beta release already that everyone can test (there are some testers already doing a great job that helped me a lot).
Sorry for not having you all up to date related to Kwort, but I've been working a lot and in my free time I try to develop Kwort. For example, now, I'm in my lunch time, and I passed out lunch in order to write something for you about the new direction of this project.
Cheers.
Hello everybody, It's been so long since my last post here. There's so much to talk about, but today I'm going to talk about Thunar. As some of you might know, thunar is the file manager used in Xfce, written by Benedikt Meurer, and nowadays maintained by Jannis Pohlmann. I really like thunar, but the fact that hard drive partitions are left to the distribution itself when hal can manage them and because of that the file manager also can, isn't really nice, as you can browse your partitions in newer versions of GTK's (with Gvfs) GtkFileChooser. An ugly workaround would be to mount them and add some gtk bookmarks, but you would like to set an emblem to differentiate them from normal bookmarks, and emblems are not part of the gtk library, so you wouldn't see emblems in a GtkFileChooser. Another issue would be that isn't dynamic, so if someone change partitions that would be a total mess. So IMHO the best solution to this is: Hard Drive partitions managed by hal (DeviceKit in the future) and let Thunar show them in the left pane. And this is what I actually did.
So, as everybody loves screenshots and you probably want to see how this looks:
And finally, the patch: http://nomius.github.io/content/patches/Thunar-1.0.0-hd-partitions.diff
Enjoy!
I'm happy to announce that Kwort 2.4.1 final is here!
This version took a year to develop and provides a lot of changes from 2.4 release, including a new, more cleaned up than usual, base system, whole new tool chain, new configuration tools and lots of new things.
Good things in this new version:
As in every old version now comes the things that I look forward to improving:
People who I would like to thank: Andreas Schipplock as always for making and maintaining the website, mirroring the Kwort iso image, and kind of playing a role of resources manager that allows me to develop easily Kwort. Sebastian Reisse for writing the kpkg manpage, and for taking a lot of his time testing every release candidate, if it wasn't for him, this release would come with several bugs. The Aircable people for their donations as they helped me to buy some hardware I was needing for develop Kwort. The mirror providers as usual, the people from PGHosting and Ricardo Brisighelli for the package mirror in the UNR. Finally, but not less important a very big THANKS to Patrick Volkerding for Slackware Linux, the system Kwort is based on. The Xfce developers (core and goodies) who made 4.6 a lot more simple to configure for distributions and provided help when needed. The people who develop every project Kwort includes. I hope I didn't forget anyone.
As usual, if you need support, help, or you just feel like talking about Kwort (or anything else), or you just want to meet the people who is behind Kwort, you can join us on IRC or our Google group:
IRC: irc://irc.oftc.net/Kwort
Google Group: http://groups.google.com/group/kwort-linux
Well, it's been 3 months since my last post, and I've been doing a lot...
Let's start with Kwort. Well we're just there from the release, lots of new improvements are being done around it, and something really interesting is the new network manager and the new user manager I wrote from scratch with a completely new design using gtkdialog.
The new network manager allows you to configure your ethernet and wireless network, supporting static and dhcp, for wireless network, support for several encryption mode are available, from wep to wpa2:
The user manager stills very simple but with a very simple and smooth interface:
So, as you can see we have almost everything, since looking at the screenshot the Xfce settings manager is in it, so Xfce is kinda there, so you might be questioning "What are you waiting for a release?" Well, Xfce 4.6 is in release candidate time, so when they release it final we'll see how's the Mozilla people going with Firefox 3.1, since it would be really cool to ship it with Kwort 2.4.1. I wouldn't matter to ship a beta 3 with 2.4.1, but we'll see, since beta 3 should be released already according to Mozilla's Firefox schedule, and their delivery meeting is schedule to the end of the month (February 25th), which is just around the corner.
Resuming, lots of improvements are going on and I'm trying to make it pretty cool and easy for the end user.
That's just for Kwort, now... Some friends saw I was migrating to git, and yeah, I did, since in the past I used git with gitorious.org which didn't convinced me, I came back to darcs. But now, I discovered GitHub which is really cool, fast and easy to use and with lots of guides around, so you can see and follow my work at: http://github.com/nomius.
I have to admit here that I was influenced at work by warlock, which is the author of the wbar, to move from darcs to git, so I found a darcs2git python script and it was like charm.
Also, I implemented lots of cool new features for kpkg, and I merged kpkg with the kwort network manager and user manager making a "big" project called kwtools. Looking right now at the master tree page, you'll see this: "Implemented kpkg search /all with csv support" and you might be asking "What the hell is this guy making with kpkg implementing stuff like this?", well, I hope this feature is just enough, but basically, it is because a friend, x-ip, and I we are writing a graphical interface for kpkg, at the moment the interface is pretty rough but does show the idea, of course, icons and all that stuff is going to be implemented with also a more eye-candy interface, so you can see a preview of the application here:
As I said before and as you can see, the interface looks pretty rough, but give us some time and you'll see how cool it looks. I doubt we get in time to include this new tool in Kwort 2.4.1, we'll try, but I really doubt it since I'm just learning python, which is the language we use to write this, and x-ip is just learning wxPython with me, which is the framework we use for this.
Please, if you have any ideas for Kwort or any of the tools/applications I write, please write me, it would be nice to hear (read) about you and your ideas, and also, I don't know... help maybe? :-)
We'll, this post is already becoming large so I'm off to bed now. Have a nice week and see you around guys.
Well, it's been a long time in the road since my last post here. This weblog isn't over, but I been doing a lot of things and didn't got the time to write something.
Ok, things I've been doing: * I wrote a new network manager for Kwort 2.4.2 (I'm already working on a new Kwort version), screenshots are coming * I also wrote a new user manager for next Kwort also. Screenshots are ON the way. :-D * A friend of mine (Jp) is working on a new init system which is very cool, so Kwort will use it. * Bought a pretty cool (4 cores) new computer (Desktop). I would like to thank to the aircable.net people who helped me to buy my new computer with a donation. (A BIG THANKS TO YOU GUYS) * Working... :-)
Anyways, I want here to point this link from my good old friend Andreas Schipplock, he made a small list of interesting links to read and/or hear.
Btw, I took a position at iProgrammers and I'm working at Accenture now as a Senior Programmer.
I'm just releasing NQqueue 0.3 beta. This is just a bug fix release and it is beta because of the new spamassassin plugin; I wrote this one on sunday, but since I don't use spamassassin (I have servers running dspam), I can't test it.
This is just a release asking for people to flood my inbox with feedback on the spamassassin plugin, the configuration parameters are the same used with the dspam plugin, so only "pass" parameter is allowed, or empty.
So, get latest NQqueue release here: http://europa.fapyd.unr.edu.ar/releases/NQqueue-0.3b.tar.gz
Well, the people of wicd asked me for some modifications in ktsuss so they could support it as they do with gksu. These modifications were made in the weekend; also bug fixes has been done, and as it looks very stable I'm writing a post release announce here. :-)
Changelog can be found here
Also, you can follow ktsuss development in my darcs server here
Latest ktsuss download link here
Bugs and feature requests are always welcome :-)
Cheers!
Well, I just tagged NQqueue as 0.2. Several changes has been done from 0.1. For those who doesn't know, NQqueue is a threaded queue for qmail with support for plugins. Full details of what nqqueue is can be found here: http://nomius.blogspot.com/2008/06/nqqueue-what-is-that.html
Download the latest release version here: http://europa.fapyd.unr.edu.ar/releases/NQqueue-0.2.tar.gz
Changelog can be found here: http://europa.fapyd.unr.edu.ar/darcs/NQqueue/Changelog
If you want to get nightly builds packages. Use this link: http://europa.fapyd.unr.edu.ar/darcs/NQqueue/NQqueue.tar.gz
Darcs repository: http://europa.fapyd.unr.edu.ar/darcs/NQqueue
NQqueue stills in development, it is stable enough, but there are some things that must be fixed before the next release.
Plugins included:
General plugins:
black - Parameters:
clamav - Parameters:
User plugins:
dspam - Parameters:
quarantine - Parameters:
Example of common usage: This example shown here will block an incoming email from<EMAIL_ADDRESS>put emails containing virus to general quarantine (in /var/qmail/nqqueue/quarantine/domain/user), and deliver spam considered emails in Maildir/.Spam/new (which is the personal user spam directory in his vpopmail home).
<EMAIL_ADDRESS>dspam=pass;quarantine=clamav,q=general;quarantine=dspam,q=vquad(.Spam)
I hope people start using nqqueue, since it is fast, secure, flexible and very easy to use.
As some people asked me the last few weeks what I've been doing I've decided to take some time to write this and explain what NQqueue (aka nqq) is all about. Well, some of you maybe listened (or read) me telling that queues for qmail are bloated. We don't have several choices, there is just plain qmail-queue which is unfeatured, qmail-scanner (aka give me my CPU back) which is the bloatest one, and simscan which is kind of featured, fast, but not extensible at all, both of the last ones are buggy when getting an email with several Rcpts (they only analyze one. Which is a big bug). So, because of all this, I've been using simscan, I actually extended it from those 2000 lines to 4000 adding features. But it became so big, that it is hard to maintain and to trace errors in it.  Well, NQqueue is the result of this self asked question.
Let me show you and tell you some of the features of NQq:
Plugins: Well, some of you might be asking "Dude, nice, but how do I write a plugin for NQq?". Well, first of all, I have to tell you that there are two types of plugins: 1st. we have the general plugins. Those plugins are run to an email before to trigger all the threads for every rcpt. Why is this? Well, it would be dumb to call for example a clamav plugin for every user (in every thread). So for example we can write a plugin that should not care about the Rcpts and/or From, like clamav, since it depends on a general database. 2nd. besides of general plugins, there are also per user plugins. These plugins are run in every thread. This is the example of a spam plugin, since it depends on a special per user database.
So now I can show you a small general plugin to block a Sender:
/* vim: set sw=4 sts=4 : */
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <nqqueue.h>
#define PLUGIN_VERSION "1.0"
#define PLUGIN_NAME "black"
#define REJECTED_MESSAGE "Message rejected because of black list"
char *plugin_name()
{
return strdup(PLUGIN_NAME);
}
char *plugin_version()
{
return strdup(PLUGIN_VERSION);
}
/* Parameters:
* params = a char pointer with parameters used to call the module (in this case, the email address to block).
* mail = It's a char pointer to the filename that contains the email.
* From = a char pointer with the From email address. (if it matchs the param, the mail would be blocked)
* Rcpt = an union that contains space for a char pointer (if user pluing) or a pointer to a PUStruct
* struct (if general plugin).
* general = a pointer to a RSStruct struct, which is structure with all the plugins and its return values
* already runned by general plugins
* peruser = a pointer to a RSStruct struct, which is structure with all the plugins and its return values
* already runned by per user plugins
*/
struct ModReturn *plugin_init(char *params, const char *mail, const char *From, const union Tos Rcpt, \
struct RSStruct *general, struct RSStruct *peruser)
{
struct ModReturn *ret = malloc(sizeof(struct ModReturn));
ret->NewFile = NULL;
if (!strcmp(params, From)) {
ret->ret = 1;
ret->rejected = 1;
ret->message = strdup(REJECTED_MESSAGE);
}
else {
ret->ret = 0;
ret->rejected = 0;
ret->message = NULL;
}
return ret;
}
Looks easy don't you think? So, how do we make NQqueue to load our plugin? Simple: in /var/qmail/control/general.cfb put a line like this:
<EMAIL_ADDRESS>That will set the sender<EMAIL_ADDRESS>as a blocked server.  Now your question might be: And how can I block more? Well, you can call the plugin several times, like this:
:black=billgates<EMAIL_ADDRESS>Or you can modify the plugin_init function to allow more than one email (like black=billgates<EMAIL_ADDRESS>and do some simple parsing with strtok.
As you can see it is very easy to write plugins for NQqueue. I know it stills need a lot of documentation, since at it is now, it's very poor in this aspect. The only documentation in NQqueue so far is a configuration scheme in the NQqueue darcs in case you want to know how to configure it right (it's very easy).
So, those are some of the features in NQqueue there are more of course, but those are enough to mention. NQqueue needs a lot of testing, so I'm counting with all of you to run tests. Also documentation is needed, and it will take some time to me to write it, so people wanting to write documentation are welcome. Also people writing plugins, I wrote some which are already in my darcs server (a dspam, clamav, blacklist and quarantine) modules.
You can follow NQqueue's development in my darcs server at: http://europa.fapyd.unr.edu.ar/cgi-bin/darcsweb.cgi
This issue came up today with some people and I did affirmed that you can hang up your switch with some funny code... How this come? Well, very simple, switches and bridges has a small stack (10 bytes per host connected to it) where they save IP and MAC addresses to know where to send a package once the sender and the receiver are known. So, once the first package is sent, a new entry in the stack was made. So now you know the "theory" I'll leave you to think how could this help you to hang it (Let me give you a hint: OVERFLOW).
Anyways, get the code you'll need to produce this overflow from here: http://nomius.github.io/content/patches/pkinject
Keep in mind that you'll need the pktgen kernel module to run this. See also that I did this 3 years ago with bash, not even C code, so it shows how easy is to generate network packages to produce this effect, which isn't a big deal when it comes to reproduce it, but to create a security policy to avoid it.
Have fun.


What is a UH Grouping?
A grouping is a collection of members (e.g., all full-time Hilo faculty).
Create groupings, manage grouping memberships, control members' self-service options, designate sync destinations, and more.
Synchronize groupings email LISTSERV lists, attributes for access control via CAS and LDAP, etc.
Leverage group data from official sources, which can substantially reduce the manual overhead of membership management.
General Info
How do I request a new grouping?
A request form is available here.
Exactly what is a grouping?
General information about groupings can be found here. A grouping's components include the Basis, Include, and Exclude lists.
What is the Basis?
A grouping's Basis is the portion of the grouping membership that is automatically updated. It may be empty.
What is the Include members list?
A grouping's Include is the portion of the grouping membership that is manually updated. It may be empty.
What is the Exclude members list?
A grouping's Exclude overrides automatic and manual membership by explicitly not including anyone listed here. It may be empty.
What Happens If
I was an owner of just one grouping and someone (me or another owner) deleted my ownership while I was still logged in.
You will still see the Groupings menu option, but you will get an error message when you click on it. Next time you log in, the Groupings menu option will no longer appear, assuming that you don't reaquire the ownership of a grouping before then.
I was not an owner of any groupings and someone made me an owner while I was still logged in.
You will have to log out and then log back in again to see the Groupings menu option.
I was an admin and someone (me or another admin) deleted my admin role while I was still logged in.
You will still see the Admin menu option, but you will get an error message when you click on it. Next time you log in, the Admin menu option will no longer appear, assuming that you don't reaquire the Admin role before then.
Technical Information
Resources
Source code is available on GitHub.
Technologies
Apache Maven (Introduction)
Apache Tomcat (Welcome)
Java Spring Framework (Guide) (API)
Spring Boot (Guide)
JQuery (Current Version) (API)
Jasmine (Current Version) (Guide)
Jenkins (Documentation)
Underscore.js (Documentation)


--- layout: page title: Sales Forecasting ---
| Deliverable | Trained Sales Volume Forecasting Model |
| Machine Learning Task | Time Series Analysis |
| Target Variable | Monthly Sales Forecast |
| Control Metric | RMSE $11330 over a forecasted 6 month horizon |
This project showcases a time series visualization and sales volume prediction workflow. The challenge is to predict 6 months sales figure using time series analysis of historical sales data. The data used is a real-world anonymised dataset from e-commerce retailers.
Techniques are shown for visualizing time series data, for decomposing into trend and seasonality components and for testing for non-stationarity. Methods are presented for transforming a non-stationary series into a stationary series for analysis. This notebook provides a comparison of time-series sales forecasting methods of increasing complexity from simple moving averages to SARIMAX forecasting methods.
The quality of the forecasts is measured using the RMSE of 6 months forecasted sales data with actual/real sales values.
You can find the code for this project at: github repository


T
- the type of elements held in this queue that implements the
Serializable interface.public class SynchQueue<T extends java.io.Serializable>
extends java.lang.Object
ExecutionEngine
| Constructor and Description |
|---|
SynchQueue() |
SynchQueue(int queueLength) |
| Modifier and Type | Method and Description |
|---|---|
int |
getQueueLength() |
boolean |
isAvailableInQueue(T t) |
T |
poll()
Retrieves and removes the head of this queue if elements available in
queue, or waiting if this queue is empty until get the item to the queue.
|
boolean |
put(T t)
Inserts the specified element into this queue if it is possible to do so
immediately without violating capacity restrictions, notify to the queue
to release the waiting request upon success and throwing an
QueueException if no space is currently available.
|
int |
queuedCount(T t) |
void |
setQueueLength(int queueLength) |
public int getQueueLength()
public void setQueueLength(int queueLength)
queueLength
- public T poll()
public boolean put(T t) throws QueueException
t
- the element to add to the queue.QueueException
- if maximum limit in queue that specified by user is exceeded.public boolean isAvailableInQueue(T t)
t
- the element available in the queue.public int queuedCount(T t)
t
- the element available in the queue.


Apps
-
motorcycle
Delivery App
This app allows you to easily manage any request that your business may receive.
With this app any client that may buy in your business can contact you, make the order and
submit his request. You'll receive the request through your dashboard.
Author: Alex Weiber
This App will only be visible to users with roles: Admin, Manager or Employee
settings ic_get_app


--- layout: blog title: npm recipes redirect_to: "http://makerlog.org" ---
npm recipes is a new feature on Learn.js meant to showcase awesome modules found on npm.
You can read some of the tutorials on learnjs.io, and more will be released only in the book.
There are over 100,000 modules on npm, so there's a wildly big number of opportunities for checking out how various npm modules can work together.
Get the book for free here: npm recipes


--- layout: post title: First Ventures in Photoshop date: 2011-02-28 21:27:17.000000000 -05:00 type: post published: true status: publish categories: - arts and crafts - college - graphic design tags: - college - columbia - crafty blogs - graphic design - nom^3 - photo shop - poster meta: jabber_published: '1298942838' email_notification: '1298942839' tagazine-media: a:7:{s:7:"primary";s:61:"http://farm6.static.flickr.com/5211/5486995619_b490ce698c.jpg";s:6:"images";a:1:{s:61:"http://farm6.static.flickr.com/5211/5486995619_b490ce698c.jpg";a:6:{s:8:"file_url";s:61:"http://farm6.static.flickr.com/5211/5486995619_b490ce698c.jpg";s:5:"width";s:3:"400";s:6:"height";s:3:"500";s:4:"type";s:5:"image";s:4:"area";s:6:"200000";s:9:"file_path";s:0:"";}}s:6:"videos";a:0:{}s:11:"image_count";s:1:"1";s:6:"author";s:7:"9073083";s:7:"blog_id";s:7:"8808538";s:9:"mod_stamp";s:19:"2011-03-01 01:27:17";} _oembed_3c43f84e1da5a19e3ec6a6861f9a096b: author: login: sophie email<EMAIL_ADDRESS>display_name: Pika first_name: '' last_name: '' ---
Though an engineer by trade, art is something that runs in my blood (exhibit A: cousin Amanda) that I definitely can't deny.
For the longest time, I've been wanting to learn PhotoShop...here's my first project!

It's an ad for Nom^3, this awesome local/sustainable student catering group I'm in at Columbia. (Check out the website for more.)
I signed up as Web Master-in-training/Design team so watch out for more to come :)


Dashboard » Appearance » Themes » Add New
shadower-pro.zip
.
Dashboard » Settings » Permalinks
and click on the "Save Changes" button.
wp-content/themes
folder.
Dashboard » Appearance » Themes
and activate the theme.
If you can see an error message saying: "The uploaded file exceeds the upload_max_filesize directive in php.ini" or "Are you sure you want to do this? Please try again." The solution is as follows：
/wp-content/themes/
. Then you will have the theme in your Dashboard and you can activate it from there.
This is a common issue that can occur when installing a WordPress themes. For the details of solution, please have a look at this article.
Dashboard » Appearance » Themes
shadower-pro.zip
again.


As a user
I want to Login to website
and click on article
Before Hooks.before(Scenario)
Scenario Outline: Login with valid credential and validate article
Given I open 'straites'09s 282ms
Then click on login button03s 167ms
When I enter<EMAIL_ADDRESS>and "Anujag0308"18s 594ms
Then Verify the user has been logged in625ms
Then Verify that the main article has a picture/video099ms
And User Click on the main article07s 682ms
Then Verify page has been navigated to the main article, and the picture/video is present in the article094ms
After Hooks.after()


Time: 10 to 20 min
Puja details: Sankalpam with Gothram, Nakshatram, Name, etc., of devotee, 108 nama Archana, Ganapathi Pooja, New Baby Blessing List of items required: Fruits, Coconut, New clothes for baby. (Devotee to bring the required items)
Time: 20 min
Puja details: Sankalpam with Gothram, Nakshatram, Name, etc., for the baby, 108 nama Archana,Ganapathi Pooja, Annaprasana List of items required: Bananas 6, Coconuts 1, Flowers 2 bouquets (Chrysanthemum / Roses), Sweet rice. (Devotee to bring the required items)
Time: 40 min
Puja details: Sankalpam with Gothram, Nakshtram, Name, etc., for the baby, 108 nama Archana, Ganapathi Pooja, Annaprasana List of items required: Bananas 6, Coconuts 2, Rice – 2Kgs, Sweet rice prasadam, Flowers 2 bouquets ( Chrysanthemum / Rose) (Devotee to bring the required items)
Time: 20 min
Puja details: Sankalpam with Gothramm, Nakshtram, Name, etc., for the baby, 108 nama Archana, Ganapathi Pooja, Aksharabhyasam List of items required: Bananas 6, Coconuts 1, Flowers 1 bouquet(Chrysanthemum / Rose), Paddy – 2Kgs, Slates/Erasable/ReWritable slate & pen, Chalk Pieces (if bringing slate), Turmeric Sticks 2nos (Devotee to bring the required items)
Time: 45 to 60 min
Puja details: Abhisekam will relevant materials, Alankaram, Astothram and Aarthi List of items required: 1. Panchamritham with Banana, Sugar candy, Cashew nuts, Dry Grapes, Cardamom. 2. Turmeric Powder 2.Honey 3.Milk 4.Yogurt 5.Fruit – Orange / lemon 5.Coconuts 6.Sandal power 7.Rose water (All items are provided by temple)
Time: 45 to 60 min
Puja details: Sankalpam with Gothramm, Nakshtram, Name, etc., of the devotee with 1008 nama Archana List of items required: Ganapathi with Flowers preferably Chrysanthemum or Roses 2. Lakshmi with Kum Kum, 3. Saraswathi with Kum Kum
Time: 10 to 20 min
Puja details: Sankalpam with Gothram, Nakshatram, Name, etc., of devotee, 108 nama Archana, Ganapathi Pooja, Vahana Puja to Keys only List of items required: Kumkum 100gms, Lemon x 5, Camphor 100gms, Sandal powder 100gms (Devotee to bring the required items)
Time: 10 to 20 min
Puja details: Sankalpam with Gothram, Nakshtram, Name, etc., of the devotee with 108 nama Archana
Time: 10 to 20 min
Puja details: Sankalpam with Gothram, Nakshtram, Name, etc., of the devotee with 108 nama Archana
Time: 20 to 30 min
Puja details: Sankalpam with Gothram, Nakshtram, Name, etc., for the baby, 108 nama Archana, Ganapathi Pooja, Kalasa Puja List of items required: Mango / Beetle leaves x 10, Coconut x 2, Beetle nuts x 6, Bananas x 4, Flowers 2 bouquets (Chrysanthemum / Rose) (Devotee to bring the required items)
Time: 10 to 20 min
Puja details: Sankalpam with Gothram, Nakshatram, Name, etc., of devotee, 108 nama Archana, Ganapathi Pooja, KumKum Archana List of items required: Kumkum 200gms, Beetle leaves x 6, Coconuts x 2, Beetle nuts x 6, Banana x 4, Flowers x 2 bouquets (Chrysanthemum / Rose) (Devotee to bring the required items)
Time: 30 min
Puja details: Sankalpam with Gothram, Nakshtram, Name, etc., of the devotee, Deepa Pooja List of items required: Deepam, Fruits, Kumkum, Turmeric powder, Betelnut(paan) leaves, betelnuts, Incense sticks, Camphor, Banana, Coconuts, Sandalwood powder, Flowers ( preferably Chrysanthemum or Rose) (Devotee to bring the required items)£20


{%extends 'base.html'%} {% block content %} {{block.super}}
Description: {{photo.image_description}}
Location photo was taken: {{photo.location.location_name}}
Date uploaded: {{photo.upload_date}}


Media RSS demo using AngularJS, Google Feeds API, jQuery and Twitter bootstrap.
full screen by Joseph Oster, April 2013


Rush
This is an interactive game.
Start Game
About: This is an example game HTML5 Game Development video course.
Restart Game
Exit to Menu
Score:
0
How to Play?
Press the screen to jump.
Avoid the obstacles.
Collect the game coins.


PREPARATION H- phenylephrine hydrochloride, mineral oil and petrolatum ointment
Pfizer Canada Inc.
Disclaimer: Most OTC drugs are not reviewed and approved by FDA, however they may be marketed if they comply with applicable regulations and policies. FDA has not evaluated whether this product complies.
ACTIVE INGREDIENTS
Mineral oil 14%
Petrolatum 74.9%
Phenylephrine HCl 0.25%
PURPOSES
Protectant
Protectant
Vasoconstrictor
USES
- helps relieve the local itching and discomfort associated with hemorrhoids
- temporarily shrinks hemorrhoidal tissue and relieves burning
- temporarily provides a coating for relief of anorectal discomforts
- temporarily protects the inflamed, irritated anorectal surface to help make bowel movements less painful
WARNINGS
For external and/or intrarectal use only
Ask a doctor before use if you have
- heart disease
- high blood pressure
- thyroid disease
- diabetes
- difficulty in urination due to enlargement of the prostate gland
Ask a doctor or pharmacist before use if you are
presently taking a prescription drug for high blood pressure or depression.
When using this product
do not exceed the recommended daily dosage unless directed by a doctor.
Stop use and ask a doctor if
- bleeding occurs
- condition worsens or does not improve within 7 days
- introduction of applicator into the rectum causes additional pain
If pregnant or breast-feeding,
ask a health professional before use.
Keep out of reach of children.
If swallowed, get medical help or contact a Poison Control Center right away.
DIRECTIONS
- adults: when practical, cleanse the affected area by patting or blotting with an appropriate cleansing wipe. Gently dry by patting or blotting with a tissue or a soft cloth before applying ointment.
- when first opening the tube, puncture foil seal with top end of cap
- apply to the affected area up to 4 times daily, especially at night, in the morning or after each bowel movement
- intrarectal use:
- remove cover from applicator, attach applicator to tube, lubricate applicator well and gently insert applicator into the rectum
- thoroughly cleanse applicator after each use and replace cover
- also apply ointment to external area
- regular use provides continual therapy for relief of symptoms
- children under 12 years of age: ask a doctor
OTHER INFORMATION
store at 20-25°C (68-77°F)
INACTIVE INGREDIENTS
benzoic acid, butylated hydroxyanisole, corn oil, glycerin, lanolin, lanolin alcohols, methylparaben, mineral oil, paraffin, propylparaben, purified water, thymus vulgaris (thyme) flower/leaf oil, tocopherols excipient, white wax
QUESTIONS OR COMMENTS?
Call weekdays 9 AM to 5 PM EST at 1-800-99PrepH or 1-800-997-7374.
PRINCIPAL DISPLAY PANEL - 28 g Tube Label
THIS PACKAGE CONTAINS AN OUTER CARTON. DO NOT BUY IF OUTER CARTON IS MISSING.
PREPARATION H®
HEMORRHOIDAL OINTMENT
Prevents Further
Irritation
- Prompt, Soothing Relief from Painful
Burning, Itching and Discomfort
- Shrinks Swollen Hemorrhoidal Tissue
- Protects Irritated Tissue
- Relieves Internal and External Discomfort
NET WT 1 OZ (28 g)
PRINCIPAL DISPLAY PANEL - 28 g Tube Carton
PREPARATION H®
HEMORRHOIDAL OINTMENT
Prevents Further
Irritation
- Prompt, Soothing Relief from
Painful Burning, Itching and Discomfort
- Shrinks Swollen Hemorrhoidal Tissue
- Protects Irritated Tissue
- Relieves Internal and External Discomfort
NET WT 1 OZ (28 g)
Pfizer Canada Inc.


RT @JRubyConfEU: Ruby and GUI development? Do the two go together? @jasonrclark will show you how with @shoooesrb! http://2015.jrubyconf.eu/speakers/jasonrclark.html
6/24/2015, 10:56:08 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @JRubyConfEU: Ruby and GUI development? Do the two go together? @jasonrclark will show you how with @shoooesrb! http://2015.jrubyconf.eu/speakers/jasonrclark.html
6/24/2015, 10:56:08 AM
Favs: 0
Retweets: 0
link


[gecode-users] Determining equal set variables
Guido Tack
tack at ps.uni-sb.de
Wed Jul 15 09:47:36 CEST 2009
Chris Mears wrote:
> I can check if two IntViews are ground and equal like this:
>
> IntView &x = ...
> IntView &y = ...
> if (x.assigned() && y.assigned() && x.val() == y.val())
> ...
>
> Can I do the same thing for sets? There doesn't seem to be an
> equivalent to "val()" in the SetView class.
You'll have to use iterators:
GlbRanges<SetView> xr(x);
GlbRanges<SetView> yr(y);
if (x.assigned() && y.assigned() && Iter::Ranges::equal(xr,yr))
...
If this test is done very often and the sets are usually not equal,
you can check the cardinalities first in order to speed things up a bit:
if (x.assigned() && y.assigned() && x.cardMin()==y.cardMin() &&
Iter::Ranges::equal(xr,yr))
...
Cheers,
Guido
More information about the gecode-users
mailing list


Mp3 Mainia
Home
Albums
All Songs
Contact Us
Hit Movies Songs
Ablums
Teefa In Trouble
Item Number
Chal Ve
Sajna Door
Ishq Nachaunda
Zindagi Haseen Hai
ChulBul
Kitni Bar
Manqabat
Tutya Tara


| runExample {shinyjs} | R Documentation |
Launch a shinyjs
example Shiny app that shows how to
easily use shinyjs
in an app.
Run without any arguments to see a list of available example apps.
The "demo" example is also
available online
to experiment with.
runExample(example)
example |
The app to launch |
## Only run this example in interactive R sessions if (interactive()) { # List all available example apps runExample() runExample("sandbox") runExample("demo") }


Grazie inspection provides an extended spell and grammar checking. You can change inspection settings in
File | Preferences | Tools | Grazie
.


{% load static %}
Dashboard
User Profile
Table List
Typography
Icons
Maps
Notifications
Logout
Team Triple_H


(2 minute read)
If you’re looking for general-purpose computing with WebGL (specifically BLAS stuff) check out the amazing weblas library. This post is a bit old, and at the time using WebGL for general-purpose computing seemed like a painful dirty hack.
WebGL for general-purpose computing sounded like a good idea at first. Simply send data to the GPU as textures and perform the calculations there. Browsers can handle it, and very few people seemed to be doing this.
Turns out people weren’t doing this for several reasons, the main one being: weak support for float texture values. There’s an extension called oes_texture_float, which helps a lot, but it’s still a bit clumsy.
So if you’re not using oes_texture_float and want to to send float data to the shaders, the data has to be RGBA-encoded into a texture (on the JavaScript side), sent to the WebGL side and once there, decoded back into floats. Ouch. Not to mention reading back the float results on the JS side, which can also be painful.
Here’s an overview of 2 methods that do all of the above. Some issues are: performance bottlenecks, additional JavaScript and GLSL code, and errors associated with the float / RGBA conversions.
What about image processing and computer vision? The images / video frames can be processed by WebGL as regular textures, no need for float / RGBA conversions. It seemed like a better idea, and there were already a couple of cool projects using this approach (eg: webcam toy and glfx.js).
So I decided to do something along those lines and started working on NumGL - a WebGL image / video processing library. Here’s a couple of things you can do with it.
Greyscaling
The NumGL code for this effect is:
// "image" is the <img> tag ID.
var imageId = numgl.store_picture("image");
numgl.show_canvas(imageId)
numgl.grey(imageId);
numgl.do_it();
To apply this or any of the following effects on video / webcam, simply change the store_picture() function to store_video() and store_webcam(), respectively. Fiddle around with this code here:
Convolution kernel
Apply a convolution kernel to an image, video or webcam. The code is identical to the above example, just replace the numgl.grey() call with
// Apply convolution kernel to the stored image.
numgl.convolution(imageId, [-1,-1,-1,0,0,0,1,1,1]);
where the array [-1,-1,-1,0,0,0,1,1,1] corresponds to the following kernel
$$\begin{bmatrix}-1 & -1 & -1\\0 & 0 & 0\\1 & 1 & 1\end{bmatrix}$$JS Fiddle with it:
Thresholding
The function call is
// Threshold the stored image.
numgl.threshold(imageId, 80);
where 80 is the threshold value. JS Fiddles:
TL;DR
WebGL does image processing and computer vision stuff with ease and speed. NumGL is a WebGL image / video processing library. Fork me on Github. Also check it out for additional docs and examples.


  %}
Please contact me if you have any trouble resetting your password.
{% endblock %} {% block extra_body %} {% endblock %}


|
NanoMagMC
v0.2
Monte Carlo Simulation Software for Atomistic Models of Magnetic Materials
|
#include <param_read.hpp>
Public Attributes | |
| double | size |
| double | edgeSize |
| bool | isPerio |
| bool | isIsing |
| char | shape_code |
| double | J |
| double | K |
| double | H |
| double | k |
| double | T |
| double | beta |
| std::string | intFile |
| double stateOptions::beta |
| double stateOptions::edgeSize |
| double stateOptions::H |
| std::string stateOptions::intFile |
| bool stateOptions::isIsing |
| bool stateOptions::isPerio |
| double stateOptions::J |
| double stateOptions::K |
| double stateOptions::k |
| char stateOptions::shape_code |
| double stateOptions::size |
| double stateOptions::T |


Police dismantle kidnappers’ camps, arrest suspect in FCT
by The Eagle OnlineThe Police Command in the Federal Capital Territory on Monday said it has dismantled kidnappers camps and arrested a suspect along Kwali-Kwaita axis of the territory.
The Deputy Police Public Relations Officer in the FCT, ASP Mariam Yusuf disclosed this in a statement in Abuja.
She said the camps were dismantled during Counter-Kidnapping Operations in furtherance to the command’s efforts to wipe out kidnappers from the FCT, particularly along Kwali-Kwaita axis.
Yusuf said the operation, using overt/covert means dismantled the camps and dislodged the kidnappers bases prompting them to seek refuge.
“The fleeing kidnappers while scampering for safety entered the highway shot at an oncoming vehicle and killed four persons along that axis.
“The swift intervention of Police Operatives led to the immediate arrest of one of the suspected kidnappers while efforts are on top gear to apprehend his cohorts,” she said.
She said the command commiserate with the families of the deceased and pledged to provide maximum security in the territory to ensure hitch-free Yuletide.
Previous Post
EFCC recovers N300m from corrupt persons in Akwa Ibom in 2019 – Official
Next Post
FIRS: Buhari fails to renew Fowler’s tenure, names successor