Change Log: 2.063
Download D 2.063
released May 28, 2013
Language Changes
- Const and immutable fields with initializers are now warned about.
- Constructor qualifiers are taken into account when constructing objects.
- Struct members which require non-bitwise comparison are now properly compared.
- Array copy operations now always require using the slice syntax.
- Types no longer act as arguments in typeof expressions.
- The index variable in a foreach range is no longer implicitly a reference.
- Associative array entries are no longer default-initialized before assignment.
- The const attribute is no longer inherited in overriden methods.
- typeof(null) no longer implicitly converts to T[].
- The Template This Parameter now changes the member function qualifier.
- Array slices are now r-values.
- Accessing a non-static field without a this reference is only allowed in certain contexts.
- Arrays no longer implicitly convert to a pointer.
Language Enhancements
- Expressions which return unique objects can be implicitly casted to immutable.
- Static array of void can now be user-initialized.
- Aggregates can now contain multiple invariants.
- Methods of templated aggregates can now infer attributes.
- is expression no longer requires an identifier.
- Dynamic arrays of known size can be implicitly cast to static arrays in some contexts.
- Tuples can now be void-initialized.
- Tuples can now be compared for equality.
- Template constraints can now be put after the inheritance list.
- Fields with initializers can now be re-initialized in a const constructor.
- Added the isNested trait for discovery of aggregates and functions with context pointers.
- Templates can now be nested inside of functions.
- UFCS now works with scoped local imports.
- Added __FUNCTION__, __PRETTY_FUNCTION__ and __MODULE__.
- DDoc: Deprecated declarations are now wrapped in a DEPRECATED macro.
- Added documented unittest feature for verifiable code example generation.
Compiler Enhancements
Phobos Enhancements
List of all bug fixes and enhancements in D 2.063.
Language Changes
- Const and immutable fields with initializers are now warned about:
Eventually, they will be deprecated, and then will trigger an error. Such fields should now be changed to enum or static.
In a future release, a new behavior for them will be enabled:
Fields in an aggregate which are not static will always be addressable. This means they will occupy space in the object:
struct S { // used to be implicitly static in 2.062, now warns. In a future release it will become non-static. immutable int[] arr = [1, 2]; // ditto const int[] arr2 = [1, 2]; }
This means that code which accessed such declarations without the this reference will no longer compile. Additionally code which depended on the size of a structure with such fields will have to be fixed:
struct S { immutable int[] arr = [1, 2]; } void main() { auto x = S.arr; // becomes an error in a future release, 'arr' will require the 'this' reference. // S is size 1 in 2.062 and 2.063. In a future release this will change and the following static assert will pass. static assert(S.sizeof == size_t.sizeof + size_t.sizeof); // ptr + length for the array }
To make the field static again, simply use the static keyword. Alternatively make the field an enum to turn it into a manifest constant:
struct S { static immutable int[] arr = [1, 2]; enum arr2 = [1, 2]; }
Note however that manifest constants which are arrays are allocated on each usage, so you may prefer using static instead.
Rationale:
Making a field implicitly static based on whether it is const/immutable and has an initializer leads to confusion. The static keyword can be used to explicitly make any field static.
- Constructor qualifiers are taken into account when constructing objects:
A qualified constructor is now invoked when a const/immutable/shared aggregate object is instantiated, respectively:
import std.stdio; class C { this() { writeln("1"); } this() const { writeln("2"); } this() immutable { writeln("3"); } this() shared { writeln("4"); } } void main() { auto a = new C; // writes "1" auto b = new const C; // writes "2" auto c = new immutable C; // writes "3" auto d = new shared C; // writes "4" }
This has the consequence that aggregates which have only immutable or shared constructors can no longer be used to instantiate mutable objects:
class C { this() immutable { } this() shared { } } void main() { auto c1 = new C; // disallowed auto c2 = new immutable C; // ok auto c3 = new shared C; // ok }
On the other hand, aggregates which do not have shared or immutable constructors can no longer be used to construct shared or immutable objects, respectively:
class C { this() { } } void main() { auto c1 = new C; // ok auto c2 = new immutable C; // disallowed auto c3 = new shared C; // disallowed }
However, if an aggregate has a pure constructor it can be used to construct an object with any type constructor:
class C { this() pure { } } void main() { auto c1 = new C; // ok auto c2 = new immutable C; // ok auto c3 = new shared C; // ok }
- Struct members which require non-bitwise comparison are now properly compared.
In earlier releases some struct members such as arrays would be bitwise-compared in a comparison operation. This has now been changed to be a structural comparison instead:
struct S { char[] data; } void main () { auto s1 = S("foo".dup); auto s2 = S("foo".dup); assert(s1.data !is s2.data); // both are unique data assert(s1 == s2); // passes in 2.063 assert(s1.data == s2.data); // equivalent of above }
If an opEquals function is not present the compiler rewrites the expression s1 == s2 to s1.tupleof == s2.tupleof. Comparing .tupleof expressions is also a feature new to D in the 2.063 release.
- Array copy operations now always require using the slice syntax:
The right-hand-side of an array copy operation now requires using the slice syntax:
void main() { int[][2] x; int[] y; int[] z; x[] = z; // copies z (pointer + length) 2 times to x y[] = z; // copies each element of z into y (compiler emits warning) }
If the user intended to write such code they must use the slice syntax for both the source and target arrays:
void main() { int[][2] x; int[] y; int[] z; y[] = z[]; // copies each element of z into y (no warnings) }
Rationale:
The compiler will emit a warning to make the user aware that the copy operation is arbitrarily expensive.
- Types no longer act as arguments in typeof expressions:
A type can no longer be passed to a function as a value of that type:
T[] foo(T)(T t) { return null; } void main() { alias int Int; // used to work (only with an alias), now a compiler error alias typeof(foo(Int)) IntArray; }
If the user wants to pass an argument of a certain type, they can use the .init property:
T[] foo(T)(T t) { return null; } void main() { alias typeof(foo(int.init)) IntArray; // ok }
Rationale:
Treating types as expressions in special contexts only leads to confusion. Instead, the .init property can be used for such purposes.
- The index variable in a foreach range is no longer implicitly a reference:
The index variable in a foreach range is now by default a value type:
void main() { size_t count; foreach (n; 0 .. 10) { ++n; ++count; } assert(count == 10); // passes }
If the user wants to modify the index variable he must use the ref keyword:
void main() { size_t count; foreach (ref n; 0 .. 10) { ++n; ++count; } assert(count == 5); }
Rationale:
Making the index variable implicitly ref can introduce bugs that are hard to track down.
- Associative array entries are no longer default-initialized before assignment:
An associative array entry used to be default-initialized before assignment took place:
void main() { int[int] aa; aa[1] = aa[1] + 1; // no Error thrown in 2.062 assert(aa[1] == 1); // worked in 2.062 }
In 2.063, accessing an entry which does not exist will now throw a RangeError:
void main() { int[int] aa; aa[1] = aa[1] + 1; // RangeError thrown in 2.063 }
Rationale:
Default-initialization during assignment can be a source of bugs.
- The const attribute is no longer inherited in overriden methods.
Method overrides no longer inherit constness of the base method:
class A { void foo() const { } } class B : A { // used to work in 2.062, now an error override void foo() { } // note missing 'const' }
If the user wants to override a const method he has to mark the overriden method as const:
class A { void foo() const { } } class B : A { override void foo() const { } // ok }
The feature allows introducing new overloads based on the constness of the method:
class A { void foo() const { } } class B : A { // introduces new overload (not override!) void foo() { } // if the above overload is introduced the user must either: // a: re-introduce the const overload to prevent function hijacking alias super.foo foo; // without this you will get a compiler error // or b: provide a properly typed override: override void foo() const { } }
- typeof(null) no longer implicitly converts to T[]:
The following code used to be allowed:
void f(int[] function() del) { assert(!del()); // fails } typeof(null) g() { return null; } void main() { f(&g); f(() => null); }
However the implicit conversion would end up generating wrong code. To work around this, make sure the return type is typed properly, or use (T[]).init in the return expression of a lambda expression:
void f(int[] function() del) { assert(!del()); // passes } int[] g() { return null; } // fixed return type void main() { f(&g); // ok f(() => (int[]).init); // ok }
- The Template This Parameter now changes the member function qualifier:
The Template This Parameter can now be used to infer the qualifier of this to member functions:
struct S { void foo(this T)() { } } void main() { immutable S s; s.foo(); // makes S.foo immutable }
- Array slices are now r-values:
Array slices are no longer l-values. This means an address can no longer be taken of a slice, and slices cannot be passed by ref to functions:
void foo(ref int[] arr) { arr = new int[10]; } void main() { int[] arr; foo(arr); // ok assert(arr.length == 10); foo(arr[]); // disallowed in 2.063, the slice is an r-value auto ptr = &arr[1..2]; // disallowed in 2.063, cannot take address of r-value }
To work around this you can make your function take an r-value if it doesn't need to reassign and resize the slice, but only needs to read or modify its contents. Otherwise, to accept both l-values and r-values you can make your function take its argument by auto ref:
void take(int[] arr) { } void takeRef(ref int[] arr) { } void takeAutoRef(T)(auto ref T[] arr) { } void main() { int[] arr = [1, 2, 3, 4]; take(arr); // ok takeRef(arr); // ok takeAutoRef(arr); // ok int[] arr2 = arr[1 .. 2]; take(arr2); // ok, arr2 is a variable takeRef(arr2); // ditto takeAutoRef(arr2); // ditto take(arr[1 .. 2]); // ok takeRef(arr[1 .. 2]); // error, cannot pass r-value by reference takeAutoRef(arr[1 .. 2]); // ok }
Rationale:
Passing slices by reference had no observable effect when reassigning or resizing such a slice at the call site, therefore such slices should by default be r-values. For example, the following code used to be allowed but is now a compile-time error:
void reAssign(ref int[] arr) { arr = new int[2]; } void reSize(ref int[] arr) { arr.length = 10; } void main() { int[] arr = [1, 2, 3, 4]; reAssign(arr[0 .. 4]); // reassigning has no observable effect at the call site assert(arr == [1, 2, 3, 4]); reSize(arr[0 .. 4]); // resizing has no observable effect at the call site assert(arr.length == 4); }
- Accessing a non-static field without a this reference is only allowed in certain contexts:
Accessing non-static fields used to be allowed in many contexts, but is now limited to only a few:
- offsetof, init, and other built-in properties are allowed:
struct S { int field; } void main() { auto a = S.field.offsetof; // ok, statically known auto c = S.field.max; // ditto auto d = S.field; // disallowed, no `this` reference }
- When invoking static methods of a non-static field:
struct Foo { static struct Bar { static int get() { return 0; } } Bar bar; } void main() { static assert(Foo.bar.get() == 0); // ok, equivalent to `typeof(Foo.bar).get()` }
- When accessing static fields implicitly using an alias this expression:
struct Foo { static struct Bar { static int get() { return 0; } } Bar bar; alias bar this; } void main() { static assert(Foo.get() == 0); // ok, equivalent to 'typeof(Foo.bar).get()' }
- Arrays no longer implicitly convert to a pointer:
The implicit conversion of an array to a pointer was a deprecated feature:
void foo(int* p) { } void main() { int[] arr = [1, 2]; foo(arr); // ok if -d switch is used during compilation }
This feature has now been completely removed. The workaround is to either use the .ptr property, or explicitly pass the pointer to the first element:
void foo(int* p) { } void main() { int[] arr = [1, 2]; foo(arr); // compile error foo(arr.ptr); // ok foo(&arr[0]); // ok }
Language Enhancements
- Expressions which return unique objects can be implicitly casted to immutable:
Expressions such as new for objects and arrays, and dup for arrays, can now be inferred to be unique. This allows the compiler to implicitly convert such an expression to immutable:
class C { } void main() { immutable int[] arr1 = new int[](3); // ok immutable int[] arr2 = [1, 2, 3].dup; // ok in 2.063 immutable C[] arr3 = [new C, new C].dup; // ok in 2.063 }
- Static array of void can now be user-initialized.
A static array of void could not be initialized in user-code:
void main() { void[2] varr1; // error in 2.062 void[2] varr2 = (void[2]).init; // error in 2.062 void[2] varr3 = void; // ok in 2.062 }
In 2.063, an explicit initializer can be used:
void main() { void[2] varr1; // still an error in 2.063 void[2] varr2 = (void[2]).init; // ok in 2.063 void[2] varr3 = void; // ok in 2.063 }
The .init property effectively zero-initializes the array.
Rationale:
The restriction has been lifted to allow generic code to use .init without having to specialize for static void arrays.
- Aggregates can now contain multiple invariants:
If an aggregate type has multiple invariants, the invariants' bodies will be merged into a single invariant function and will be run in sequence. Note that the code in one invariant cannot reference code or data in another invariant:
struct S { int x; void foo() { } invariant() { int local; assert(x != 0); } invariant() { // local = 1; // invariant does not have access to the other invariant's body assert(x % 2 == 0); } } void main() { S s = S(2); s.foo(); // invoking public function triggers both invariants in sequence }
- Methods of templated aggregates can now infer attributes:
If a function with some attributes instantiates a templated aggregate, its member functions will infer those attributes:
struct S(T) { T square(T x) { return x * x; } } void main() pure { S!int s; // S!int.square becomes pure and callable from main() assert(s.square(2) == 4); // ok }
- is expression no longer requires an identifier:
In some cases the is expression required an identifier even when you didn't have a use for it:
void main() { alias AA = string[int]; static if (is(AA _ == V[K], V, K)) { pragma(msg, _); // prints string[int] pragma(msg, K); // prints int pragma(msg, V); // prints string } }
The identifier is no longer required, so the above can be rewritten to:
void main() { alias AA = string[int]; static if (is(AA == V[K], V, K)) { pragma(msg, AA); // prints string[int] pragma(msg, K); // prints int pragma(msg, V); // prints string } }
- Dynamic arrays of known size can be implicitly cast to static arrays in some contexts:
In some contexts the compiler knows the size of a dynamic array or of a slice of an array. In such a case the compiler will allow an implicit conversion to a static array of the same size:
void foo(int[4] x) { } void main() { int[] arr = [1, 2, 3, 4, 5, 6, 7, 8]; foo(arr[0 .. 4]); // ok }
Another example, where a string is converted to a reference to a static array:
string str = "aaaabbbbccccdddd"; void foo(ref const(char)[16] buf) { assert(buf.ptr is str.ptr); } void main() { foo(str[0..16]); // ok }
Limitations:
- This feature does not yet work with complex expressions where it might be reasonable to assume the size of a slice:
void foo(int[4] x) { } void main() { int[] arr = [1, 2, 3, 4, 5, 6, 7, 8]; foreach (i; 0 .. 4) { foo(arr[i .. i + 4]); // not yet supported } }
- Tuples can now be void-initialized:
You can now void-initialize a tuple variable:
template Tuple(T...) { alias T Tuple; } void main() { Tuple!(int, int) tup1 = void; // ok }
Upon such initialization the values in the tuple are undetermined.
- Template constraints can now be put after the inheritance list:
Template constraints used to be allowed only before the inheritance list, leading to code where the inheritance list could be hard to spot:
class Foo(T1, T2) if (is(T1 == int) && is(T2 == string)) : Base { }
This restriction has been lifted, so you can now write:
class Foo(T1, T2) : Base if (is(T1 == int) && is(T2 == string)) { }
- Tuples can now be compared for equality:
Example:
struct Tuple(T...) { T field; alias field this; } void main() { auto tup1 = Tuple!(int, int)(1, 2); auto tup2 = Tuple!(int, int)(1, 2); auto tup3 = Tuple!(int, int)(1, 3); assert(tup1 == tup2); // works since 2.063 assert(tup1 != tup3); // works since 2.063 }
This also means you can now compare ParameterStorageClassTuple instances from std.traits:
import std.traits; void func1(ref int x, ref int y) { } void func2(ref float x, ref float y) { } void main() { alias Storages = ParameterStorageClassTuple; assert(Storages!func1 == Storages!func2); }
In addition to that, builtin .tupleof expressions can be used to easily compare fields of an aggregate:
struct S { char[] a, b; // Implements equality test against another instance of this type. bool opEquals(S rhs) { return this.tupleof == rhs.tupleof; } } void main() { S s1 = S("a".dup, "b".dup); S s2 = S("a".dup, "b".dup); assert(s1 == s2); }
This also allows you to implement a structural equality test against an instance of a different type:
struct S1 { char[] a, b; // Implements a structural equality test against any other type T bool opEquals(T)(T rhs) { return this.tupleof == rhs.tupleof; } } struct S2 { string x, y; } void main() { auto s1 = S1("123".dup, "456".dup); auto s2 = S2("123", "456"); assert(s1 == s2); }
Since tuples can be sliced you can use this feature to compare a subset of tuples:
struct S { int a, b, c, d, e; bool opEquals(S rhs) { // compares a, b, d, and e return this.tupleof[0..2] == rhs.tupleof[0..2] && this.tupleof[3..5] == rhs.tupleof[3..5]; } } void main() { S s1 = S(1, 2, 0, 3, 4); S s2 = S(1, 2, 1, 3, 4); assert(s1 == s2); }
- Fields with initializers can now be re-initialized in a const constructor:
You can now initialize a field in a const constructor even if such a field already has an initializer:
struct S { bool field = true; this(int v) const { field = false; // ok } }
- Added the isNested trait for discovery of aggregates and functions with context pointers:
The new isNested trait allows you to discover whether an aggregate or function contains a context pointer:
void main() { int x; struct S1 { void f() { x++; } } static struct S2 { } void f1() { x++; } static void f2() { } static assert(__traits(isNested, S1)); static assert(__traits(isNested, f1)); static assert(!__traits(isNested, S2)); static assert(!__traits(isNested, f2)); }
- Templates can now be nested inside of functions:
- UFCS now works with scoped local imports:
Functions that are made available through a local import are now picked up when using Uniform Function Call Syntax:
module foo; string concat(string arg1, string arg2) { return arg1 ~ arg2; }
module test; void main() { import foo; assert("foo".concat("bar") == "foobar"); // UFCS now works }
This feature also works for imports within aggregates. Note that local imports have a higher precedence than module-scoped imports.
- Added __FUNCTION__, __PRETTY_FUNCTION__ and __MODULE__:
A new set of special keywords were added. Together with __FILE__ and __LINE__ they form a complete feature set that is useful in debugging code:
module test; import std.stdio; void test(string file = __FILE__, size_t line = __LINE__, string mod = __MODULE__, string func = __FUNCTION__, string pretty = __PRETTY_FUNCTION__) { writefln("file: '%s', line: '%s', module: '%s',\nfunction: '%s', pretty function: '%s'", file, line, mod, func, pretty); } int main(string[] args) { test(); return 0; }
The above will output:
file: 'test.d', line: '13', module: 'test', function: 'test.main', pretty function: 'int test.main(string[] args)'
- DDoc: Deprecated declarations are now wrapped in a DEPRECATED macro:
module test; /// sum function deprecated int sum(int x, int y) { return x + y; }
By default the macro expands to its argument. It can be overriden by the user, for example:
macros.ddoc:
DEPRECATED=<del>$0</del>
The above ddoc file can then be used when the documentation is being generated:
$ dmd -D -o- test.d macros.ddoc
- Added documented unittest feature for verifiable code example generation:
Documented unittests which follow any symbol declarations are now used to generate example sections for the symbol when generating DDOC documentation. Example:
/// sum function int sum(int x, int y) { return x + y; } /// unittest { assert(sum(2, 2) == 4); }
The body of the unittest will be part of the documentation of the sum function. This allows the implementor of the function to keep their examples always up-to-date.
For more information, see the documentation page of documented unittests.
void test() { template ArrayOf(T) { alias ArrayOf = T[]; } static assert(is(ArrayOf!int == int[])); }
Allowing templates inside of functions will enable better encapsulation and avoid the pollution of module-scoped symbol names.
Compiler Enhancements
- Added -main switch which adds an empty main function:
The -main switch is primarily useful when unittesting libraries:
module test; int sum(int a, int b) { return a + b; } unittest { assert(sum(2, 2) == 4); }
The above library would need a main() function for the unittests to run, and -main can be used for this purpose:
$ dmd -unittest -main -run test.d
- Added -cov=percentage switch for minimal coverage tests.
The -cov switch now has an optional percentage setting which makes the executable emit an error when the coverage doesn't meet the specified requirement:
module test; void test1() { int x = 5; } void test2() { int x = 5; } void test3() { int x = 5; } void main() { test1(); test2(); }
Example of coverage testing:
$ dmd -cov=90 test.d $ test Error: test.d is 80% covered, less than required 90%
- Added ability to override the mangling of a symbol with a compiler pragma:
The new pragma(mangle, ...) directive allows you to set a custom mangling for any symbol:
pragma(mangle, "module") extern(C) void module_();
The above allows linking to a C function named "module", which ordinarily we wouldn't be able to link to directly since "module" is a reserved D keyword.
Phobos Changes
- std.typecons.scoped implementation changed, potentially breaking some user-code:
User-code which used the std.traits.ReturnType trait to retrieve the type of a scoped call will have to be changed to use the typeof operator instead:
class A { this() {} this(int) {} } class B { // ReturnType!(scoped!A) a; // disallowed in 2.063 typeof(scoped!A()) a; // rewritten, compiles in 2.063 this() { a = scoped!A(1); // would not compile in 2.062, but works with syntax used for 2.063 } }
The reason for this change is that the ReturnType trait would retrieve the wrong type when a class had multiple constructors, and this would cause initializing the field to fail.
Another benefit of the new implementation is that scoped can now be aliased for usability purposes:
class A { this(int) { } } void main() { alias scoped!A scopeA; auto a = scopeA(1); }
Phobos Enhancements
- std.process has been redesigned from the ground up and introduces a new API and functionality:
The new std.process module introduces functionality for invoking processes with custom pipe redirection, the ability to wait for processes to finish, and the ability to kill processes. The full list of features can be found in the std.process documentation.
- std.getopt can now set booleans to false:
Example code:
void main(string[] args) { bool flag = true; getopt(args, &flag); }
When invoked via --flag=false, it will set flag to false.
- Added ownerTid property in std.concurrency:
It is now easier to send a message from a child thread to its owner thread. Simply use the ownerTid property to get the owner thread's Tid identifier:
void fun() { string res = receiveOnly!string(); assert(res == "Main calling"); ownerTid.send("Child responding"); // new } void main() { auto child = spawn(&fun); child.send("Main calling"); string res = receiveOnly!string(); assert(res == "Child responding"); }
If the owner thread has exited, accessing ownerTid from any of its child threads will throw a TidMissingException.
List of all bug fixes and enhancements in D 2.063:
DMD Compiler regressions
- Bugzilla 9130: Wrong codegen for compile time constructed struct
- Bugzilla 9258: opAssign with base class triggers "identity assignment operator overload" error
- Bugzilla 9526: ICE when compiling project with unittests
- Bugzilla 9536: IFTI fails when calling a static member from const member
- Bugzilla 9538: Regression (2.062): Can't use typeid on .ptr of static array
- Bugzilla 9539: Wrong implicit conversion of array to pointer
- Bugzilla 9545: [REG 2.063a] ICE with member template instantiation
- Bugzilla 9552: DMD crashed when taking member delegate from __traits(getOverloads)
- Bugzilla 9566: Regression (2.062): Cannot use struct .init when it contains a static array initialized from a single element.
- Bugzilla 9568: [64bit] wrong code for scope(exit)
- Bugzilla 9633: compiles trait wrongly returns true even when object method call actually does not compile
- Bugzilla 9650: __traits(compiles) + mixin
- Bugzilla 9663: [REG2.063a] ICE caused by issue 7444 change.
- Bugzilla 9672: mixin within cyclic import causes undefined properties
- Bugzilla 9689: std.typecons.Proxy breaks with @disable this(this)
- Bugzilla 9694: A member struct that has mutable opEquals reports weird error message
- Bugzilla 9739: Regression (1.077 git-head): DMD not considering ctor with default args as default ctor
- Bugzilla 9759: compiler segfault in StructLiteral::implicitConvTo(Type*) on invalid code
- Bugzilla 9764: Ddoc: Ddoc file name is incorrectly emphasized
- Bugzilla 9775: Can no longer create a const Date in CTFE if the variable is explicitly typed
- Bugzilla 9806: assertion failure in struct.c:668
- Bugzilla 9834: incorrect detection of lambda locality.
- Bugzilla 9846: regression of forward references
- Bugzilla 9858: const alias this fails when opAssign is present
- Bugzilla 9865: Crash on bogus import / circular reference
- Bugzilla 9890: Alias This + Alias Fields
- Bugzilla 9903: Broken ddoc in std.typecons and etc.c.sqlite3
- Bugzilla 9919: Regression (2.062): Symbol lookup fails with public import and mixin
- Bugzilla 9952: regression(HEAD): Attribute inference for virtual functions breaks subclasses
- Bugzilla 9957: [2.061 -> 2.062] Taking pointer of enum float array gives some garbage
- Bugzilla 9974: immutable class constructor is broken
- Bugzilla 9984: inout qualifier is skipped for constructor arguments (template constructor only)
- Bugzilla 9987: Declaring struct ModuleInfo should be allowed
- Bugzilla 10002: 2.062 -> 2.063 calling "remove" is impure
- Bugzilla 10003: void* UFCS regression
- Bugzilla 10016: Incorrect error gagging using RefCounted
- Bugzilla 10040: struct-related ICE
- Bugzilla 10041: ufcs writeln of associative array
- Bugzilla 10043: ICE with __traits(compiles)
- Bugzilla 10044: Wrong di generation for IsExp with TemplateParameterList
- Bugzilla 10047: opDispatch instantiation failure should be gagged for UFCS
- Bugzilla 10049: Spurious "Label already defined" error inside a foreach over a range aggregate
- Bugzilla 10050: Regression (git-head): RDMD no longer emits error messages from DMD
- Bugzilla 10053: struct member with pure dtor forces declared dtor to be pure, too
- Bugzilla 10055: Incorrect attribute merging in dtor/postblit building
- Bugzilla 10056: Strange Error with templates and string.format
- Bugzilla 10067: [REG] Recursive template instantiation
- Bugzilla 10073: Default opEquals depends on class declaration order with DMD HEAD
- Bugzilla 10076: expression.c:4310: virtual Expression* TypeExp::semantic(Scope*): Assertion 0 failed.
- Bugzilla 10089: Strange function call error message with specified module
- Bugzilla 10091: [HEAD] Cannot cast struct member string enum to static ubyte array of same size
- Bugzilla 10096: Regression (git-head): __traits(allMembers) triggers out of bounds error
- Bugzilla 10101: static if conditional cannot be at global scope using mixin template
- Bugzilla 10106: [ICE] Ice in glue.c:1215 + 2 error messages without lines
- Bugzilla 10134: Mutual referencing templates error
- Bugzilla 10142: [REG2.063a] enum value semantic problem that declared in class member
- Bugzilla 10144: Using enum inside final class occurs weird errors
- Bugzilla 10148: regression 062=>063: unjustified 'safe function cannot call system function'
- Bugzilla 10151: final: before enum is now an error.
- Bugzilla 10160: No line number "cannot modify struct ... with immutable members"
- Bugzilla 10166: XXX is not a template
- Bugzilla 10178: Compiler segfault with zero-length tuple comparison
DMD Compiler bugs
- Bugzilla 1520: TypeInfo_Const.opEquals is incorrect
- Bugzilla 1804: Severe GC leaks with repetitive array allocations
- Bugzilla 2356: array literal as non static initializer generates horribly inefficient code.
- Bugzilla 3789: [TDPL] Structs members that require non-bitwise comparison not correctly compared
- Bugzilla 4094: ICE(expression.c): recursive struct templates with type inference
- Bugzilla 4247: Cannot create default-constructed struct on heap when constructor is defined
- Bugzilla 4414: ICE(cgcs.c) Taking item of static array returned by function
- Bugzilla 4436: Double bug regarding Tuple.init
- Bugzilla 4479: Module Foo is in multiple files Foo
- Bugzilla 4617: Alias this'ed symbols cannot be passed to templates
- Bugzilla 4814: rdmd: Doesn't rebuild when using -of and turning an -L linker option on or off
- Bugzilla 5450: no match for implicit super() call in constructor
- Bugzilla 5625: std.format unittest disabled
- Bugzilla 6070: CTFE UFCS forward reference error
- Bugzilla 6089: __gshared with not static 2D array
- Bugzilla 6153: Inserting to An Array!T inside an Array!(Array!T) causes a segfault.
- Bugzilla 6312: template instance cannot use argument from enclosing template
- Bugzilla 6431: [RDMD] Modifying a library doesn't trigger a rebuild
- Bugzilla 6535: RDMD outputs broken library files
- Bugzilla 6539: Incomprehensible error message with failed template instantiation
- Bugzilla 6545: [CTFE] Hard-coded array operations not yet supported
- Bugzilla 6578: Ignored const with struct with constructor
- Bugzilla 6795: ICE(cgcs.c): Incrementing an enum array item
- Bugzilla 6852: Cannot compare instances of ParameterStorageClassTuple
- Bugzilla 7068: copying array of pointers calls memset instead of memcpy with -d
- Bugzilla 7437: DMD enters infinite loop during overload resolution
- Bugzilla 7569: cannot void initialize tuple declarations
- Bugzilla 7572: f.fn!(void) is not an lvalue
- Bugzilla 7719: enum forward reference error when enum is in braces
- Bugzilla 7980: Stack overflow / recursive expansion with alias this
- Bugzilla 8041: __gshared/static problem
- Bugzilla 8081: pure nothrow unittest problem in generated 'header' file
- Bugzilla 8130: Memory corruption because without *.def file DMD compiles DLL with assumption _tls_index = 0
- Bugzilla 8213: Incorrect error message with pointer to ubyte[] and front
- Bugzilla 8238: templates can create ghost fields
- Bugzilla 8245: UFCS doesn't work for pointers
- Bugzilla 8294: complex breaks calling in 64 bit DMD
- Bugzilla 8347: Parser bug with const placed after ~this() in decl
- Bugzilla 8366: Overriding const member function in conjunction with mutable overload causes a strange error
- Bugzilla 8589: Incorrect conversion of function returning typeof(null) to function returning an array
- Bugzilla 8609: A forward reference error with static arrays
- Bugzilla 8668: public selective import makes functions conflict when otherwise they don't
- Bugzilla 8670: IFTI fails from aliases
- Bugzilla 8697: Invalid error message: Forward reference of interface
- Bugzilla 8698: Forward reference error with interfaces
- Bugzilla 8827: Cannot move contents of R12
- Bugzilla 8828: Long compilation time of a destroy() on a large fixed-sized matrix
- Bugzilla 8833: Odd error with expression tuples
- Bugzilla 8902: Unexpected "duplicate union initialization for X" error
- Bugzilla 8945: Can't call static struct initializer or constructor without qualifier for templated inner struct
- Bugzilla 8953: Parser rejects qualifier after destructor i.e. ~this() <qualifier> { }
- Bugzilla 8989: cfloat argument passing broken
- Bugzilla 8998: 'inout pure' returns immutable, which in reality is mutable
- Bugzilla 9091: Using __traits(getMember) on template argument fails inside member function
- Bugzilla 9144: synchronized CRITSECSIZE should be a target constant
- Bugzilla 9199: Module level qualified functions should be rejected
- Bugzilla 9209: ice(symbol.c) with const struct heap allocation
- Bugzilla 9231: overriding inout funcion with attribute inference reports weird error
- Bugzilla 9232: Parsing error on some templated methods calls
- Bugzilla 9241: 2.061: Property call error message disappeared
- Bugzilla 9280: Runtime range violation with named capture groups in regex
- Bugzilla 9311: shared library file extension incorrectly modified
- Bugzilla 9345: CTFE fails when using std.string.format with imported string enum
- Bugzilla 9346: nested struct calls disabled postblit
- Bugzilla 9386: struct destructor called erroneously
- Bugzilla 9393: Partial template specialization and template lambda does not work
- Bugzilla 9401: destructor and nothrow syntax
- Bugzilla 9413: Incorrect modification inside contracts is not detected correctly
- Bugzilla 9414: Incorrect modification inside contracts is not detected on virtual function
- Bugzilla 9415: delegate inference should make function literal impure
- Bugzilla 9417: "no size yet for forward reference" error with nested structure
- Bugzilla 9428: Wrong array concatenation
- Bugzilla 9441: struct constructor missed on auto/type-inferred variable definition
- Bugzilla 9445: interpret.c:151: Assertion v->ctfeAdrOnStack >= 0 && v->ctfeAdrOnStack < stackPointer() failed.
- Bugzilla 9451: Listing abstract functions in diagnostic should show full signature
- Bugzilla 9473: Unittest docs should each be in their own section
- Bugzilla 9474: Ddoc'd unittests should work correctly with interspersed version(none)
- Bugzilla 9475: Should retain source formatting in ddoc's unittests
- Bugzilla 9480: The template name in the JSON output contains template and function arguments
- Bugzilla 9494: compiler stack overflow on invalid associative array
- Bugzilla 9495: Win64 vararg issue when first argument is > 8 byte
- Bugzilla 9508: RDMD doesn't generate new dependency list when a file is changed.
- Bugzilla 9540: Compiler crash on delegate context frame assignment
- Bugzilla 9561: Many error messages from std.format
- Bugzilla 9590: UFCS does not work with void lazy expressions
- Bugzilla 9613: Parser bug when using .init with type constructor
- Bugzilla 9617: ulong.max is wrongly accepted by smaller signed parameter
- Bugzilla 9619: Failed struct field typeof in inner function
- Bugzilla 9622: Range violation in rdmd
- Bugzilla 9649: DMD doesn't parse valid PostfixExpression . NewExpression syntax.
- Bugzilla 9652: __traits(getAttributes) doesn't work with manifest constants
- Bugzilla 9654: Template function cannot take string by ref T[len]
- Bugzilla 9656: Built-in dup result should behave as like unique array, if it is possible.
- Bugzilla 9658: Setting pre-initialized field should be allowed in qualified constructor.
- Bugzilla 9677: Crash on setting length property of array VC 2012 64 bit
- Bugzilla 9679: Refused const/immutable assignment in conditional
- Bugzilla 9692: __traits(allMembers) fails on module without a package
- Bugzilla 9700: std.typecons.Proxy with invaliant and in-place operation causes Access Violation
- Bugzilla 9712: IFTI does not support deducing static array types from array literal arguments
- Bugzilla 9713: Ddoc: Empty description suppress automatic example generation
- Bugzilla 9714: Ddoc: Combination of -D and -unittest reveals hidden unittest function
- Bugzilla 9720: OSX wrong code with -O Illegal instruction
- Bugzilla 9722: optimizer kills GOT to EBX load
- Bugzilla 9729: interface thunk doesn't set EBX to GOT
- Bugzilla 9735: Casting delegates to void* should be illegal
- Bugzilla 9736: VS2010 project file does full rebuild every time
- Bugzilla 9743: IFTI and polymorphic string literal should support implicit conversion to static array type
- Bugzilla 9744: Poor error message taking address of thread-local variable at compile time
- Bugzilla 9747: IFTI argument deduction fails for committed string literals which are implicitly converted to a static array
- Bugzilla 9755: JSON output is missing the protection attribute for templates
- Bugzilla 9757: Ddoc: documented unittest after ditto should work
- Bugzilla 9758: Ddoc: empty ddoc comment and unittest block generates no Examples section
- Bugzilla 9768: No line number for wrong foreach type
- Bugzilla 9773: ref parameter with default value should not compile
- Bugzilla 9774: Error message with __error using == on tuple members
- Bugzilla 9777: Calling final interface method leads to wrong code
- Bugzilla 9781: -inline will cause backend ICE
- Bugzilla 9788: -profile doesn't work if exceptions are thrown in the running program
- Bugzilla 9790: Internal error when compiling a invalid variable in template (in expression.c and backend\evalu8.c)
- Bugzilla 9791: [ICE] (struct.c line 668) map with a missing tuple import
- Bugzilla 9818: Constant folding for static array does not work with initializing by element
- Bugzilla 9829: rdmd passes '--' to dmd
- Bugzilla 9837: IFTI should consider enum base type
- Bugzilla 9844: DMD (-m64) int long initialisation bug
- Bugzilla 9845: enum value should be able to contain forward references in global scope
- Bugzilla 9863: Incorrect generation of SAHF instruction on 64 bits
- Bugzilla 9873: Built-in tuple should support equality comparison
- Bugzilla 9874: Function call syntax disuniformity in template constraints
- Bugzilla 9880: Redundant template instance displaying in error message
- Bugzilla 9883: Error on using property as new dynamic array size
- Bugzilla 9885: IFTI should consider known tuple types.
- Bugzilla 9892: [ICE] forward reference in enum declaration members causes compiler segfault
- Bugzilla 9899: struct with pure/nothrow destructor cannot be used as a struct member in pure/nothrow functions
- Bugzilla 9901: string return from inner template function error
- Bugzilla 9907: Struct literal with destructor should match to non-ref overload
- Bugzilla 9910: Scalar op vector is broken.
- Bugzilla 9928: ice with void* and function literal
- Bugzilla 9936: Wrong opBinary/opBinaryRight rewrite.
- Bugzilla 9939: allMembers trait doesn't returns members of nested anonymous enum
- Bugzilla 9940: ICE applying getProtection to a functions obtained using getOverloads.
- Bugzilla 9946: A UFCS disallowed in dynamic array allocation
- Bugzilla 9961: Using UFCS properties suppress actual errors
- Bugzilla 9965: Wrong Assembly For DIL, SIL Registers
- Bugzilla 9971: eponymous function is not an lvalue
- Bugzilla 9985: Postblit isn't called on local struct return
- Bugzilla 9990: templates with function alias cause forward reference error
- Bugzilla 9993: const ctor should be preferred than mutable for const obj creation
- Bugzilla 9994: Built-in generated opAssign should call dtor on assignment
- Bugzilla 10004: tuple comparison with side-effect should work
- Bugzilla 10005: struct variable declaration and const-correctness
- Bugzilla 10011: Wrong JSON "init" property output for class reference initializers
- Bugzilla 10029: Update list of reserved version identifiers.
- Bugzilla 10058: Inconsistent mangling between C++ and extern(C++).
- Bugzilla 10059: export doesn't work for variable declarations
- Bugzilla 10063: inout+pure results in ability to produce immutable reference to mutable data
- Bugzilla 10066: Template opEquals sometimes obstructs struct compilation
- Bugzilla 10102: @disable incompletely implemented
- Bugzilla 10103: template mixin with property overloads
- Bugzilla 10105: ICE when converting string literal to static char array in enum initializer
- Bugzilla 10115: More @disabled holes
- Bugzilla 10171: Unexpected error "cannot infer type from overloaded function symbol"
- Bugzilla 10180: offsetof doesn't work through function call alias this
DMD Compiler enhancements
- Bugzilla 3449: const and invariant struct members do not behave according to spec
- Bugzilla 3502: Fix for dropped Mac OS X 10.5
- Bugzilla 3673: inheritance + if clause = no go
- Bugzilla 4528: Better error message for private abstract method
- Bugzilla 5140: Add __FUNCTION__, __PRETTY_FUNCTION__, and __MODULE__
- Bugzilla 6185: Include non-global functions when resolving UFCS
- Bugzilla 6453: Allow multiple invariant per struct/class
- Bugzilla 6809: IFTI should imply const where inout is present on args, but not on return type
- Bugzilla 7444: Require [] for array copies too
- Bugzilla 7511: attribute inference should work for template functions
- Bugzilla 8220: invalid function call not detected during semantic analysis
- Bugzilla 8669: TemplateThisParameter should change member function's qualifier
- Bugzilla 8819: void static array should have init built-in propert
- Bugzilla 8959: IsExpression should support syntax which has no Identifier in all cases
- Bugzilla 9033: Remove __thread from the language
- Bugzilla 9136: Add isNested trait
- Bugzilla 9155: Ddoc: code section should strip leading spaces
- Bugzilla 9170: CTFE: Allow reinterpret casts float <-> int
- Bugzilla 9185: Add note about where -op is useful
- Bugzilla 9574: Diagnostic for old use of 'alias this = that' should be informative
- Bugzilla 9627: Not good enough error messages in some cases when using UFCS
- Bugzilla 9635: Improved error message for failed access of array field properties from static method
- Bugzilla 9676: Ddoc: Wrap deprecated declarations in a (DEPRECATED) macro
- Bugzilla 9680: Include entry point location in "dmd -v -o-" output
- Bugzilla 9723: Implement -main switch to inject a default main() function
- Bugzilla 9726: Add minimum % coverage required for -cov testing
- Bugzilla 9727: Documented unittest comment should appear before Example section
- Bugzilla 9745: Allow non-thread local static variables to have their address taken in CTFE
- Bugzilla 9778: RDMD: Support passing resource files to DMD
- Bugzilla 9789: Ddoc for aliases should use new "alias x=y" syntax
- Bugzilla 9866: movsxd not supported
- Bugzilla 9920: [Optimizer] Use mul/imul for integer division by constant
- Bugzilla 9941: [CTFE] Allow to store "newed" classes and structs in the data segment
- Bugzilla 9943: Allow to return typeid from CTFE
- Bugzilla 9963: Absurdly Inefficient Codegen For Adding Boolean Predicates
- Bugzilla 9977: Function local templates should be allowed
- Bugzilla 10030: Support '-l:' switch when passing default library to ld
- Bugzilla 10077: add pragma(mangle, "...") to override symbol mangle.
- Bugzilla 10109: add -transition compiler switch to aid in dealing with breaking changes
- Bugzilla 10150: Prefix method 'this' qualifiers should be just ignored anytime
- Bugzilla 10179: Tuple assignment should not cause "has no effect" error even if the length is zero
Phobos regressions
- Bugzilla 9122: std.concurrency send() fails with multiple arrays
- Bugzilla 9742: std.math.floor returns 0 for any value x > -1 and x < 0
- Bugzilla 10122: Appender doesn't work with disabled default construction
Phobos bugs
- Bugzilla 3795: Problem with phobos std.variant
- Bugzilla 4729: std.algorithm: strange iota behaviour
- Bugzilla 4798: std.algorithm.map unusable for ranges with const elements
- Bugzilla 4955: struct dirent.d_type is not a mask
- Bugzilla 5032: std.file.rename acts differently on Windows and Linux when the target file already exists.
- Bugzilla 5201: std.string.indexOf and std.algorithm.indexOf return different things for narrow strings
- Bugzilla 5310: Variant == const(Variant) doesn't compile
- Bugzilla 5359: std.traits.isDelegate should work for types and expressions
- Bugzilla 5360: calling rdmd from different folder
- Bugzilla 5514: Erroneous documentation and lacking randomization for topN
- Bugzilla 5658: Undocumented fields in std.typecons.Tuple
- Bugzilla 5924: schwartzSort of Tuple!(char)[]
- Bugzilla 8321: std.range.put doesn't work with RefCounted output range
- Bugzilla 8613: std.typecons.Proxy cannot work with operator 'in'
- Bugzilla 8655: bitfields and Typedef don't mix
- Bugzilla 9164: Can't easily assign one Nullable to another
- Bugzilla 9431: Tuple creation problem with array of array
- Bugzilla 9456: decodeFront is inconsistent in whether it pops elements off of the range or not
- Bugzilla 9512: std.regex: Incorrect parsing of hex sequences composed from capital letters.
- Bugzilla 9553: SOCKET should be 64 bit wide on Win64
- Bugzilla 9583: std.getopt.getopt does not consume options terminator "--" from args list, as docs claim
- Bugzilla 9612: std.range.Cycle.opSlice tests on the bounds are missing
- Bugzilla 9624: fullyQualifiedName fails for functions
- Bugzilla 9648: Missing std.random import for std.algorithm.topN
- Bugzilla 9753: std.string.translate precondition asserts
- Bugzilla 9794: std.json cannot handle delete character
- Bugzilla 9804: std.math.FloatingPointControl corrupts floating point state
- Bugzilla 9812: std.conv.parse string fails on certain escape characters.
- Bugzilla 9836: std.array.popFront does not work with alias this.
- Bugzilla 9950: std.json should return empty string/array instead of null on empty input
- Bugzilla 9956: hasElaborateAssign trait does not work with static arrays
- Bugzilla 9979: Regex bug with \b and look-behind
- Bugzilla 10116: stdio.File.byLine repeats last line forever, readln(ref C[],R) returns bad data
- Bugzilla 10167: Wrong Document Comment on std.format.d(181)
- Bugzilla 10182: std.bitmanip unit test has pointless/unused foreach loop
Phobos enhancements
- Bugzilla 4787: std.algorithm.bisectRight()
- Bugzilla 4921: Synopsis code in std.variant documentation throws an assertion error
- Bugzilla 5013: std.typecons.Tuple should have constructor for static arrays
- Bugzilla 5106: makeIndex should return SortedRange
- Bugzilla 5226: indexOf() which takes a pred but no needle
- Bugzilla 5401: std.socket updates and boost license
- Bugzilla 5507: countUntil should take Ranges... instead of R2
- Bugzilla 6224: Add an ownerTid property in std.concurrency
- Bugzilla 6486: std.math.abs(BigInt)
- Bugzilla 7405: std.algorithm.schwartzSort.release
- Bugzilla 9260: getopt should allow setting booleans to false
- Bugzilla 9265: Nullable fixed-sized array wrapper
- Bugzilla 9625: assertNotThrown should print exception msg if no msg is provided
- Bugzilla 9802: Add std.traits.{isNested,hasNested}.
- Bugzilla 9814: Add std.traits.isNestedFunction
- Bugzilla 9839: std.traits.Select should be able to select symbols
- Bugzilla 9888: Allow passing a generator to std.random.uniform for enums
Druntime bugs
- Bugzilla 4307: spawn()'ed thread doesn't terminate
- Bugzilla 6024: Document that Windows 2000 SP4 is no longer supported
- Bugzilla 10057: [2.063 beta] Module info overwritten in shared phobos.
- Bugzilla 10081: Incorrect char array comparison
Optlink bugs
- Bugzilla 6144: Unexpected OPTLINK Termination at EIP=00428DA3
Installer bugs
- Bugzilla 9343: Problem installing dmd-2.061-0.fedora.x86_64.rpm on Fedora 18
Website bugs
- Bugzilla 4847: std.algorithm.topN documentation
- Bugzilla 9544: D logo image is broken on non-root-level pages
- Bugzilla 9609: Ddoc tags for std.string.icmp seem wrong
- Bugzilla 10036: missing core.atomic docs on dlang.org


The SSTIntegratedComponent class Provides common functionality for converting an sst/macro standalone event_component into a a SST::Component compatible with integration.
More...
#include <integrated_component.h>
|
| virtual void | connect_input (sprockit::sim_parameters *params, int src_outport, int dst_inport, event_handler *mod)=0 |
| | connect_input All of these classes should implement the connectable interface More...
|
| |
| virtual void | connect_output (sprockit::sim_parameters *params, int src_outport, int dst_inport, event_handler *mod)=0 |
| | connect_output All of these classes should implement the connectable interface More...
|
| |
| virtual SST::Event::HandlerBase * | payload_handler (int port) const =0 |
| | payload_handler More...
|
| |
| virtual SST::Event::HandlerBase * | credit_handler (int port) const =0 |
| | credit_handler More...
|
| |
|
void | init_links (sprockit::sim_parameters *params) |
| |
|
|
| SSTIntegratedComponent (sprockit::sim_parameters *params, uint64_t id) |
| |
The SSTIntegratedComponent class Provides common functionality for converting an sst/macro standalone event_component into a a SST::Component compatible with integration.
| virtual void sstmac::SSTIntegratedComponent::connect_input |
( |
sprockit::sim_parameters * |
params, |
|
|
int |
src_outport, |
|
|
int |
dst_inport, |
|
|
event_handler * |
mod |
|
) |
| |
|
pure virtual |
connect_input All of these classes should implement the connectable interface
- Parameters
-
| params | |
| src_outport | |
| dst_inport | |
| mod | |
| virtual void sstmac::SSTIntegratedComponent::connect_output |
( |
sprockit::sim_parameters * |
params, |
|
|
int |
src_outport, |
|
|
int |
dst_inport, |
|
|
event_handler * |
mod |
|
) |
| |
|
pure virtual |
connect_output All of these classes should implement the connectable interface
- Parameters
-
| params | |
| src_outport | |
| dst_inport | |
| mod | |
| virtual SST::Event::HandlerBase* sstmac::SSTIntegratedComponent::credit_handler |
( |
int |
port | ) |
const |
|
pure virtual |
credit_handler
- Parameters
-
- Returns
- The handler that will receive credits from an SST link
| virtual SST::Event::HandlerBase* sstmac::SSTIntegratedComponent::payload_handler |
( |
int |
port | ) |
const |
|
pure virtual |
payload_handler
- Parameters
-
- Returns
- The handler that will receive payloads from an SST link
The documentation for this class was generated from the following files:


WATCH(1) User Commands WATCH(1) NAME watch - execute a program periodically, showing output fullscreen SYNOPSIS watch [options] command DESCRIPTION watch runs command repeatedly, displaying its output and errors (the first screenfull). This allows you to watch the program output change over time. By default, the program is run every 2 seconds. By default, watch will run until interrupted. OPTIONS -d, --differences [permanent] Highlight the differences between successive updates. Option will read optional argument that changes highlight to be permanent, allowing to see what has changed at least once since first itera‐ tion. -n, --interval seconds Specify update interval. The command will not allow quicker than 0.1 second interval, in which the smaller values are converted. -p, --precise Make watch attempt to run command every interval seconds. Try it with ntptime and notice how the fractional seconds stays (nearly) the same, as opposed to normal mode where they continuously increase. -t, --no-title Turn off the header showing the interval, command, and current time at the top of the display, as well as the following blank line. -b, --beep Beep if command has a non-zero exit. -e, --errexit Freeze updates on command error, and exit after a key press. -g, --chgexit Exit when the output of command changes. -c, --color Interpret ANSI color sequences. -x, --exec command is given to sh -c which means that you may need to use extra quoting to get the desired effect. This with the --exec option, which passes the command to exec(2) instead. -h, --help Display help text and exit. -v, --version Display version information and exit. NOTE Note that POSIX option processing is used (i.e., option processing stops at the first non-option argument). This means that flags after command don't get interpreted by watch itself. EXAMPLES To watch for mail, you might do watch -n 60 from To watch the contents of a directory change, you could use watch -d ls -l If you're only interested in files owned by user joe, you might use watch -d 'ls -l | fgrep joe' To see the effects of quoting, try these out watch echo $$ watch echo '$$' watch echo "'"'$$'"'" To see the effect of precision time keeping, try adding -p to watch -n 10 sleep 1 You can watch for your administrator to install the latest kernel with watch uname -r (Note that -p isn't guaranteed to work across reboots, especially in the face of ntpdate or other bootup time-changing mechanisms) BUGS Upon terminal resize, the screen will not be correctly repainted until the next scheduled update. All --differences highlighting is lost on that update as well. Non-printing characters are stripped from program output. Use "cat -v" as part of the command pipeline if you want to see them. Combining Characters that are supposed to display on the character at the last column on the screen may display one column early, or they may not display at all. Combining Characters never count as different in --differences mode. Only the base character counts. Blank lines directly after a line which ends in the last column do not display. --precise mode doesn't yet have advanced temporal distortion technology to compensate for a command that takes more than interval seconds to exe‐ cute. watch also can get into a state where it rapid-fires as many exe‐ cutions of command as it can to catch up from a previous executions run‐ ning longer than interval (for example, netstat taking ages on a DNS lookup). EXIT STATUS 0 Success. 1 Various failures. 2 Forking the process to watch failed. 3 Replacing child process stdout with write side pipe failed. 4 Command execution failed. 5 Closign child process write pipe failed. 7 IPC pipe creation failed. 8 Getting child process return value with waitpid(2) failed, or command exited up on error. other The watch will propagate command exit status as child exit status. AUTHORS The original watch was written by Tony Rems<EMAIL_ADDRESS>in 1991, with mods and corrections by Francois Pinard. It was reworked and new features added by Mike Coleman<EMAIL_ADDRESS>in 1999. The beep, exec, and error handling features were added by Morty Abzug<EMAIL_ADDRESS>in 2008. On a not so dark and stormy morning in March of 2003, Anthony DeRobertis<EMAIL_ADDRESS>got sick of his watches that should update every minute eventually updating many seconds after the minute started, and added microsecond precision. Unicode support was added in 2009 by Jarrod Lowe<EMAIL_ADDRESS>procps-ng June 2011 WATCH(1)


Namespace: options.scales[scaleId].ticks
| Name | Type | Default | Description |
|---|---|---|---|
align |
string |
'center' |
The tick alignment along the axis. Can be 'start' , 'center' , or 'end' . |
crossAlign |
string |
'near' |
The tick alignment perpendicular to the axis. Can be 'near' , 'center' , or 'far' . See Tick Alignment |
sampleSize |
number |
ticks.length |
The number of ticks to examine when deciding how many labels will fit. Setting a smaller value will be faster, but may be less accurate when there is large variability in label length. |
autoSkip |
boolean |
true |
If true, automatically calculates how many labels can be shown and hides labels accordingly. Labels will be rotated up to maxRotation before skipping any. Turn autoSkip off to show all labels no matter what. |
autoSkipPadding |
number |
3 |
Padding between the ticks on the horizontal axis when autoSkip is enabled. |
includeBounds |
boolean |
true |
Should the defined min and max values be presented as ticks even if they are not “nice”. |
labelOffset |
number |
0 |
Distance in pixels to offset the label from the centre point of the tick (in the x-direction for the x-axis, and the y-direction for the y-axis). Note: this can cause labels at the edges to be cropped by the edge of the canvas |
maxRotation |
number |
50 |
Maximum rotation for tick labels when rotating to condense labels. Note: Rotation doesn’t occur until necessary. Note: Only applicable to horizontal scales. |
minRotation |
number |
0 |
Minimum rotation for tick labels. Note: Only applicable to horizontal scales. |
mirror |
boolean |
false |
Flips tick labels around axis, displaying the labels inside the chart instead of outside. Note: Only applicable to vertical scales. |
padding |
number |
0 |
Padding between the tick label and the axis. When set on a vertical axis, this applies in the horizontal (X) direction. When set on a horizontal axis, this applies in the vertical (Y) direction. |


Home
How To Play
Player 1 Controls
W: Jump
A: Move Left
D: Move Right
R: Fire Bullet
Player 2 Controls
Up Arrow: Jump
Left Arrow: Move Left
Right Arrow: Move Right
Slash: Fire Bullet


Complete all the trades on your journey!
START
Trades Made:
Travel Completed
60% Complete
To make your trade in our port, please answer our simple question.
Submit Answer


Babylon is committed to feeding people in a way that is positive for communities and the environment, today and in the future. We build kitchen gardens where people live, which means our produce is fresher, has longer shelf life and shorter food miles. The Urban Farming mission is to create an abundance of food for people in need by supporting and encouraging the establishment of gardens on unused land and space while increasing diversity, raising awareness for health and wellness, and inspiring and educating youth, adults and seniors to create an economically sustainable system to uplift communities around the globe.
"Urban farm" may sound like an oxymoron,
but the concept has gone from being unimaginable to a
solid trend in the local foods movement. An urban farm is,
quite simply, a farm in an urban setting. More specifically,
an urban farm grows food in an urban area on land—usually
either a backyard or a vacant lot, but sometimes neglected
spaces such as street medians—that would not typically be
dedicated to producing food. They are most often found in
urban areas that have experienced some level of decline,
where space is available and inexpensive.
Full maintenance services are available to clients looking to maximize yield in whatever space is available at their home or business, whether on rooftops, ground level, or using indoor growing systems.
Our small-scale intensive approach to farming and gardening provides high yields, attractive garden and farm landscapes, and opportunities for hands-on engagement. Let Babylon help you grow food, anywhere.
Differentiate your property by providing on-site food production and engagement as a tenant amenity. Draw tenants outside to plant, maintain, and harvest organic produce from your building’s on-site farm or garden.
Babylon specializes in the design, installation and maintenance of organic, sustainable and food safety compliant gardens, farms and edible landscapes for any site, from residential to full-scale production farms.
Planting and picking
Makes strategic decisions
Helps everyone get along
Makes your garden look slick


Hi there! Nice to meet you!
I'm Amith: former .Net developer, now full time freelancer/blogger. My wife and I live in Bengaluru, India. I love a good book, a quiet getaway, and a good laugh.
Hi there! Nice to meet you!
I'm Amith: former .Net developer, now full time freelancer/blogger. My wife and I live in Bengaluru, India. I love a good book, a quiet getaway, and a good laugh.


Object Computing, Inc. (OCI) offers flexible, customizable open source support services with direct access to the architects and engineers who develop Micronaut and have spent their careers supporting and maturing other Frameworks, such as Grails.
The OCI team can assist you with:
- Architecture and design review
- Rapid prototyping, troubleshooting, and debugging
- Customizing, modifying, and extending the product
- Integration assistance and support
- Mentorship and architecture throughout the lifecycle of your project
Contact OCI to learn more.
12140 Woodcrest Executive Drive, Suite 300 Saint Louis, MO 63141, USA
Tel: 01*314*579*0066
Email: info@objectcomputing.com


Posted Articles
{% for article in articles %}
{% endfor %}
Posted Reviews
{% for review in reviews %}
My review
"{{ review.content }}"
{% endfor %}
Posted Replies
{% for reply in replies %}
My reply
"{{ reply.content }}"
{% endfor %}
Joined Groups
{% for group in user_group %}
{% endfor %}


AuthClient Extension for Yii 2
This extension adds OpenID, OAuth, OAuth2 and OpenId Connect consumers for the Yii framework 2.0.
For license information check the LICENSE-file.
Documentation is at docs/guide/README.md.
Installation ¶
The preferred way to install this extension is through composer.
Either run
composer require --prefer-dist yiisoft/yii2-authclient
or add
"yiisoft/yii2-authclient": "~2.1.0"
to the require
section of your composer.json.
Class Reference
| Class | Description |
|---|---|
| yii\authclient\AuthAction | AuthAction performs authentication via different auth clients. |
| yii\authclient\BaseClient | BaseClient is a base Auth Client class. |
| yii\authclient\BaseOAuth | BaseOAuth is a base class for the OAuth clients. |
| yii\authclient\ClientInterface | ClientInterface declares basic interface all Auth clients should follow. |
| yii\authclient\Collection | Collection is a storage for all auth clients in the application. |
| yii\authclient\InvalidResponseException | InvalidResponseException represents an exception caused by invalid remote server response. |
| yii\authclient\OAuth1 | OAuth1 serves as a client for the OAuth 1/1.0a flow. |
| yii\authclient\OAuth2 | OAuth2 serves as a client for the OAuth 2 flow. |
| yii\authclient\OAuthToken | Token represents OAuth token. |
| yii\authclient\OpenId | OpenId provides a simple interface for OpenID (1.1 and 2.0) authentication. |
| yii\authclient\OpenIdConnect | OpenIdConnect serves as a client for the OpenIdConnect flow. |
| yii\authclient\SessionStateStorage | SessionStateStorage provides Auth client state storage based on web session. |
| yii\authclient\StateStorageInterface | StateStorageInterface is an interface for Auth client state storage. |
| yii\authclient\clients\Facebook | Facebook allows authentication via Facebook OAuth. |
| yii\authclient\clients\GitHub | GitHub allows authentication via GitHub OAuth. |
| yii\authclient\clients\Google | Google allows authentication via Google OAuth. |
| yii\authclient\clients\GoogleHybrid | GoogleHybrid is an enhanced version of the yii\authclient\clients\Google, which uses Google+ hybrid sign-in flow, which relies on embedded JavaScript code to generate a sign-in button and handle user authentication dialog. |
| yii\authclient\clients\LinkedIn | LinkedIn allows authentication via LinkedIn OAuth. |
| yii\authclient\clients\Live | Live allows authentication via Microsoft Live OAuth. |
| yii\authclient\clients\Twitter | Twitter allows authentication via Twitter OAuth. |
| yii\authclient\clients\TwitterOAuth2 | TwitterOAuth2 allows authentication via Twitter OAuth 2. |
| yii\authclient\clients\VKontakte | VKontakte allows authentication via VKontakte OAuth. |
| yii\authclient\clients\Yandex | Yandex allows authentication via Yandex OAuth. |
| yii\authclient\signature\BaseMethod | BaseMethod is a base class for the OAuth signature methods. |
| yii\authclient\signature\HmacSha | HmacSha1 represents 'HMAC SHA' signature method. |
| yii\authclient\signature\HmacSha1 | |
| yii\authclient\signature\PlainText | PlainText represents 'PLAINTEXT' signature method. |
| yii\authclient\signature\RsaSha | RsaSha1 represents 'SHAwithRSA' (also known as RSASSA-PKCS1-V1_5-SIGN with the SHA hash) signature method. |
| yii\authclient\signature\RsaSha1 | |
| yii\authclient\widgets\AuthChoice | AuthChoice prints buttons for authentication via various auth clients. |
| yii\authclient\widgets\AuthChoiceAsset | AuthChoiceAsset is an asset bundle for yii\authclient\widgets\AuthChoice widget. |
| yii\authclient\widgets\AuthChoiceItem | AuthChoiceItem is a base class for creating widgets, which can be used to render link for auth client at yii\authclient\widgets\AuthChoice. |
| yii\authclient\widgets\AuthChoiceStyleAsset | AuthChoiceAsset is an asset bundle for yii\authclient\widgets\AuthChoice widget. |
| yii\authclient\widgets\GooglePlusButton | GooglePlusButton renders Google+ sign-in button. |


Do you have third party authentication server to consult
at? Specify it here
Before we submit this form, we'll test the connections first...
- Testing MongoDB Connection
- Testing MongoDB Admin User (Credential Check)
- Testing MongoDB Admin Power
- Testing Third-Party Login Server (connectivity / test curl)
Test successful
No issues! Form will now submit in 5 seconds...
Test failed
Please check the above issues. Form will not submit.


'Unfortunately' - Nottingham Forest boss Sabri Lamouchi reveals injury latest
Reds head coach with the latest injury news on Samba Sow, Yuri Ribeiro and Carl Jenkinson ahead of Middlesbrough clash
by Sarah ClapsonNottingham Forest will again be without the injured trio of Samba Sow, Yuri Ribeiro and Carl Jenkinson for tomorrow’s clash with Middlesbrough.
Midfielder Sow has been sidelined since October with a hamstring problem, while Jenkinson has been out since August with an ankle injury and fellow full-back Ribeiro (knee) since the clash with Derby County last month.
Head coach Sabri Lamouchi had been hoping for positive news on the injury front this week, ahead of successive home games with Boro and Sheffield Wednesday on Saturday.
“Unfortunately no,” he said, when asked if any of the absent players would be available for the midweek match.
“For Yuri, for Samba Sow, it is too early. Carl Jenkinson, as well.
“They need a few days.
“We will see for Saturday.”
Lamouchi will, though, have Ryan Yates back from suspension, following a three-match ban for a red card at Bristol City.
The midfielder was sent off for a two-footed challenge, but his manager says he has learnt from his mistake.
“It is good to have him back. Ryan is important for the squad,” said Lamouchi.
“He was an option before and he is an option for tomorrow, for sure.
“I hope he has learnt, but I don’t have any problem with that because Ryan is a clever guy.
Nottingham Forest latest
This is your round up of all things Forest; the one-stop shop that will keep you updated on the latest goings on at the City Ground and beyond.
Transfers, injuries, match-days and managers, we’ve got you covered.
We’ll be bringing the very latest on the Reds throughout the week and around the clock.
Make sure you keep yourself updated with our handy daily catch up...
Must reads...
- Forest and Premier League trio eye move for prolific striker - reports
- Forest's final Championship outcome predicted as rivals tipped for promotion
- 'A name that slams you' - Francois Modesto's pride at Forest role and looking for players
- Assombalonga hands Boro major blow ahead of Forest reunion
For all your latest NFFC news, opinion, analysis and transfer gossip, click here
You can follow our Reds reporter Sarah Clapson on Twitter, and her email address is<EMAIL_ADDRESS>“We must learn about our mistakes - not only Ryan; me first and all the players.
“At the end of the day, we want the same things, so we need to learn about our mistakes.
“It was a mistake, for sure. He knows that.
“It is not only him.
“The problem is if different players make the same mistake. It is not only Ryan who needs to learn, it is all the players in the squad.
“Why? Because the small details, at the end, they are so important for us.”


In this post, we will see the main technical ideas in the analysis of the mixing time of evolutionary Markov chains introduced in a previous post. We start by introducing the notion of the expected motion of a stochastic process or a Markov chain. In the case of a finite population evolutionary Markov chain, the expected motion turns out to be a dynamical system which corresponds to the infinite population evolutionary dynamics with the same parameters. Surprisingly, we show that the limit sets of this dynamical system govern the mixing time of the Markov chain. In particular, if the underlying dynamical system has a unique stable fixed point (as in asexual evolution), then the mixing is fast and in the case of multiple stable fixed points (as in sexual evolution), the mixing is slow. Our viewpoint connects evolutionary Markov chains, nature’s algorithms, with stochastic descent methods, popular in machine learning and optimization, and the readers interested in the latter might benefit from our techniques.
A Quick Recap
Let us recall the parameters of the finite population evolutionary Markov chain (denoted by $\mathcal{M}$) we saw last time. At any time step, the state of the Markov chain consists of a population of size $N$ where each individual could be one of $m$ types. The mutation and the fitness matrices are denoted by $Q$ and $A$ respectively. $X^{(t)}$ captures, after normalization by $N,$ the composition of the population is at time $t$. Thus, $X^{(t)}$ is a point in the $m$-dimensional probability simplex $\Delta_m$. Since we assumed that $QA>0$, the Markov chain has a stationary distribution $\pi$ over its state space, denoted by $\Omega \subseteq \Delta_m$; the state space has cardinality roughly $N^m$. Thus, $X^{(t)}$ evolves in $\Delta_m$ and, with time, its distribution converges to $\pi$. Our goal is to bound the time it takes for this distribution to stabilize, i.e., bound the mixing time of $\mathcal{M}$.
The Expected Motion
As a first step towards understanding the mixing time, let us compute the expectation of $X^{(t+1)}$ for a given $X^{(t)}$. This function tells us where we expect to be after one time step given the current state; in this paper we refer to this as the expected motion of this Markov chain (and define it formally for all Markov chains towards the end of this post). An easy calculation shows that, for $\mathcal{M}$,
This $f$ is the same function that was introduced in the previous post for the infinite population evolutionary dynamics with the same parameters! Thus, in each time step, the expected motion of the Markov chain is governed by $f$. Surprisingly, something stronger is true: we can prove (see Section 3.2 here) that, given some $X^{(t)},$ the point $X^{(t+1)}$ can be equivalently obtained by taking $N$ i.i.d. samples from $f(X^{(t)})$. In words,
In fact, a moment’s thought tells us that this phenomenon transcends any specific model of evolution. We can fix any dynamical system $g$ over the simplex and define a Markov chain guided by it as follows: If $X^{(t)}$ is the population vector at time $t$, then define $X^{(t+1)}$ as the population vector obtained by taking $N$ i.i.d. (or even correlated) copies from $g(X^{(t)})$. By design, $g$ is the expected motion of this Markov chain.
Evolution on Finite Populations = Noisy Evolution on Infinite Populations
The above observation allows us to view our evolutionary Markov chain as a noisy version of the deterministic, infinite population evolution. A bit more formally, there are implicitly defined random variables $\zeta_{s}^{(t+1)}$ for $1 \leq s \leq N$ and all $t$, such that
Here, $\zeta_s^{(t+1)}$ for $1\leq s \leq N$ is a random vector that corresponds to the error or noise of sample $s$ at the $t$-th time step. Formally, because $f$ is the expected motion of the Markov chain, each $\zeta_s^{(t+1)}$ has expectation $0$ conditioned on $X^{(t)}$. Further, the fact that $f$ guides $\mathcal{M}$ implies that for each $t$, when conditioned on $X^{(t)}$, the vectors $\zeta_{s}^{(t+1)}$ are i.i.d. for $1 \leq s \leq N$. Without conditioning, we cannot say much about the $\zeta_{s}^{(t)}$s. However, since we know that the state space of $\mathcal{M}$ lies in the simplex, we can deduce that $\Vert\zeta_s^{(t)}\Vert \leq 2$. The facts that the expectation of the $\zeta_s^{(t)}$s are zero, they are independent and bounded imply that the variance of each coordinate of $\frac{1}{N} \sum_{s=1}^N \zeta_s^{(t+1)}$ (again conditioned on the past) is roughly $1/N$.
Connections to Stochastic Gradient Descent
Now we draw an analogy of the evolutionary Markov chain to an old idea in optimization, stochastic gradient descent or SGD.
However, we will see crucial differences that require the development of new tools.
Recall that in the SGD setting, one is given a function $F$ and the goal is to find a local minimum of $F.$
The gradient descent method moves from the current point $x^{(t)}$ to a new point $x^{(t+1)}=x^{(t)} - \eta \nabla F(x^{(t)})$ for some rate $\eta$ (which could depend on time $t$).
Since the gradient may not be easy to compute, SGD substitutes the gradient at the current point by an unbiased estimator of the gradient.
Thus, the point at time $t$ becomes a random variable $X^{(t)}$. Since the estimate is unbiased, we may write it as
where the expectation of $\zeta^{(t+1)}$ conditioned on $X^{(t)}$ is zero. Thus, we can write one step of SGD as
Comparing it to our evolutionary Markov chain, it can be shown that $f(x)=\frac{QA x}{\Vert QA x\Vert_1}$ is a gradient system (i.e., $f=\nabla G$ for some function $G$) and we may think of the corresponding $\mathcal M$ as SGD with step-size $\eta=1/N$.
There is a vast literature understanding when SGD converges to the global optimum (for convex $F$) or a local optima (for reasonable non-convex $F$). Why can’t we use techniques developed for SGD to analyze our evolutionary Markov chain? To start with, when the step size does not go to zero with time, $X^{(t)}$ wanders around its domain $\Omega$ and will not converge to a point. In the case when the step size is fixed, typically, the time average of $X^{(t)}$ is used in a hope that it will converge to a local minima of the function. The Ergodic Theorem of Markov chains tells us that the time average will converge to the expectation of a sample drawn from $\pi$, the steady state distribution. This quantity is the same as the zero of $\nabla F$ only when it is a linear function (equivalently $F$ is quadratic); certainly not the case in our setting. Further, the rate of convergence to this expectation is governed by the mixing time of the Markov chain. Thus, there is no getting around proving a bound on the mixing time. Moreover, for biological applications (as described in our previous post), we need to know more than the expectation: we need to obtain samples from the steady state distribution $\pi$. Finally, in several other evolutionary Markov chains of interest, the guiding dynamical system is not a gradient system. Hence, the desired results in the setting of evolution seem beyond the reach of current techniques.
The reason for taking this detour and making the connection to SGD is not only to show that completely different sounding problems and areas might be related, but also that the techniques we develop in analyzing evolutionary Markov chains find use in understanding SGD beyond the quadratic case.
The Landscape of the Expected Motion Governs the Mixing Time
Now we delve into our results and proof ideas. We derive all of the information we need to bound the mixing time of $\mathcal M$ from the the limit sets of $f$ which guides it. Roughly, we show that when the limit set of $f$ consists of a unique stable fixed point (which is akin to convexity) as in asexual evolution, then the mixing is fast and in the case of multiple stable fixed points (which is akin to non-convexity) as in sexual evolution, the mixing is slow.
We saw in our first post that the dynamical system $f(x)=\frac{QAx}{\Vert QAx\Vert_1}$ corresponding to the case of asexual evolution has exactly one fixed point in the simplex, say $ x^\star$, when $QA$ is positive. In fact, $x^\star$ is stable and, no matter where we initiate the dynamical system, it ends up close to $x^\star$ in a small number of iterations (which does not depend on $N$).
Back to mixing time: a generic technique to bound the mixing time of a Markov chain employs a coupling of two copies of the chain $X^{(t)}$ and $Y^{(t)}$.
A coupling of a Markov chain $\mathcal M$ is a function which takes as input $X^{(t)}$ and $Y^{(t)}$ and outputs $X^{(t+1)}$ and $Y^{(t+1)}$ such that each of $X^{(t+1)}$ and $Y^{(t+1)}$, when considered on their own, is a correct instantiation of one step of $\mathcal M$ from the states $X^{(t)}$ and $Y^{(t)}$ respectively. However, $X^{(t+1)}$ and $Y^{(t+1)}$ are allowed to be arbitrarily correlated.
For example, we could couple $X^{(t)}$ and $Y^{(t)}$ such that if $X^{(t)} = Y^{(t)}$ then $X^{(t+1)}=Y^{(t+1)}$. More generally, we can consider the distance between $X^{(t)}$ and $Y^{(t)}$, and consider a coupling that contracts the distance between them. If this distance is contractive by, say, a factor of $\rho<1$ at every time step, then the number of iterations required to reduce distance below $1/N$ is about $\log_{1/\rho} N$; this roughly upper bounds the mixing time.
The key observation that connects the dynamical system $f$ and our Markov chain is that using the function $f$ we can construct a coupling $\mathcal{C}$ such that for all $x$,$y \in \Omega$,
Thus, if $ \Vert f(x)-f(y)\Vert_1 < \rho \cdot \Vert x-y\Vert_1 <1$ for some $\rho<1$ and all $x,y \in \Omega$, we would be done. The bad news is that we can show that there are $x,y$ for which $\Vert f(x)-f(y)\Vert_1 > \Vert x-y \Vert_1$ implying that there is no contractive coupling for all $x$ and $y.$
What about when $x$ and $y$ are close to $x^\star$?
In this case, by a first order Taylor approximation of the dynamical system $f$, we can bound the contraction $(\rho)$ by the $1 \rightarrow 1$ norm of the Jacobian of $f$ at $x^\star$. However, this quantity is less than one only when $m=2$, see here. For larger $m$, we have to go back to our intuition from dynamical systems and, using the fact that all trajectories of $f$ converge to $x^\star$, argue that the appropriate norm of the Jacobian of $f^k$ (i.e., $f$ applied $k$ times) is contractive. While there are a few technical challenges, we can use $f^k$ to construct a contractive coupling. We then use concentration to handle the case when $x$,$y$ are not close to $x^\star$, see here for the details. As a consequence, we obtain a mixing time of $O(\log N)$ (suppressing other parameters). Thus, in the world of asexual evolution the steady state can be reached quickly!
Markov Chains Guided by Dynamical Systems - Beyond Uniqueness
Interestingly, this proof does not use any property of $f$ other than that it has a unique fixed point which is stable. However, in many cases, such as sexual evolution (see here for the model of sexual evolution or an equivalent model for how children acquire grammar, see here) and here, the expected motion has multiple fixed points - some stable and some unstable. Such a dynamical system is inherently non-convex - trajectories starting at different points could converge to different points. Further, the presence of unstable fixed points can slow down trajectories and, hence, the mixing time. In this paper, we give a comprehensive treatment about how the landscape of the limit sets determines the mixing time of evolutionary Markov chains. In a nutshell, while the presence of unstable fixed points does not seem to affect the mixing time, the presence of two stable fixed points results in the mixing time being $\exp(N)$!
This result allows us to prove a phase transition in the mixing time for an evolutionary Markov chain with sex where, changing the mutation parameter changes the geometry of the limit sets of the expected motion from multiple stable fixed points to unique stable fixed point.
Evolution on Structured Populations?
A challenging problem left open by our work is to try to estimate the mixing time of evolutionary dynamics on structured populations which arise in ecology. Roughly, this setting extends the evolutionary models discussed thus far by introducing an additional input parameter, a graph on $N$ vertices.
The graph provides structure to the population by locating each individual at a vertex, and, at time $t+1$, a vertex determines its type by sampling with replacement from among its neighbors in the graph at time $t$; see this paper for more details.
The model we discussed so far can be seen as a special case when the underlying graph is the complete graph on $N$ vertices. The difficulty is two fold: now it is no longer sufficient to keep track of the number of each type and also the variance of the noise is no longer $1/N$ - it could be large if a vertex has small degree.
The Expected Motion Revisited
Now we formally define the expected motion of any Markov chain with respect to a function $\phi$ from its state space $\Omega$ to $\mathbb{R}^n$. If $X^{(t)}=x$ is the state of the Markov chain at time $t$ and $X^{(t+1)}$ its state at time $t+1,$ then the expected motion of $\phi$ for the chain at $x$ is
where the expectation is taken over one step of the chain. Often, and in the application we presented in this post, the state space $\Omega$ already has a geometric structure and is a subset of $\mathbb{R}^n$. In this case, there is a canonical expected motion which corresponds to $\phi$ being just the identity map.
What can the expected motion of a Markov chain tell us about the Markov chain itself?
Of course, without imposing additional structure on the Markov chain or $\phi$, the answer is unlikely to be very interesting. However, the results in this post suggest that thinking of a Markov chain in this way can be quite useful.
To Conclude …
In this post, hopefully, you got a flavor of how techniques from dynamical systems can be used to derive interesting properties of Markov chains and stochastic processes. We also saw that nature’s methods, in the context of evolution, seem quite close to the methods of choice of humans - is this a coincidence? In a future post, we will show another example of this phenomena - the famous iteratively reweighted least squares (IRLS) in sparse recovery turns out to be identical to the dynamics of an organism found in nature - the slime mold.


Toggle navigation
My page
Setting
(current)
Help
Sign Out
Hi, Lauren!
My Courses
CSE 170/COGS 120
Select a Course
Add
In-Person
CSE 170/COGS 120
Study at Geisel Library!!
Online
CSE 170/COGS 120
Study for Midterm 2


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface NativeStateManager
Every native object instance has an internal object implementing
NativeStateManager
interface.
This NativeStateManager object controls all native operations, that is, any operation with the native instance that modifies or gets data from native memory.
The native state manager object of a native instance can be got with
the method NativeCapable.jnieasyGetNativeStateManager()
, but is
recommended use NativeCapableUtil.getNativeStateManager(Object)
.
| Method Summary | |
|---|---|
NativeBuffer |
getBuffer()
Returns the NativeBuffer object representing the native
memory of the native object from which this NativeStateManager comes from. |
NativeCapable |
getNativeCapable()
Returns the native object instance from which this NativeStateManager comes from. |
NativeManager |
getNativeManager()
Returns the NativeManager object. |
boolean |
isInsideTxn()
Returns true is the native object is enrolled in a native transaction. |
| Method Detail |
|---|
NativeBuffer getBuffer()
NativeBuffer
object representing the native
memory of the native object from which this NativeStateManager comes from.
NativeBuffer
of the native object, never is null
.NativeCapableUtil.getBuffer(Object)
NativeCapable getNativeCapable()
The returned object is never null although the object may be non-native. Be care holding NativeStateManager objects because this prevents the related object be garbage collected. The framework never holds NativeStateManager objects with strong references.
NativeCapable.jnieasyGetNativeStateManager()
NativeManager getNativeManager()
NativeManager
object.
NativeCapableUtil.getNativeManager(Object)
boolean isInsideTxn()
NativeTransaction
,
NativeCapableUtil.isInsideTxn(Object)
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


Match the text to the definitions below, click on the words or phrases for examples given in context. Right Click answers to toggle color.
{{definition}}


Define if the Quote Analysis action should assume that BGA
pads, in addition to SMD pads, will be used in the board for which a
quote is being created.
When assume_bga_pad = No (Default), the Quote Analysis action should assume that BGA pads are not used.
When assume_bga_pad = Yes, the Quote Analysis action should assume that BGA pads are used.


STUDENT REGISTRATION
add
DRIVE DETAILS AND OTHERs
DRIVE CODE
VENNUE
STREAM
PACKAGE
DRIVE DATE
REGISTER BY-
add
COMPANY DETAILS AND OTHERs
Job Location
Desgination
Salary
Job Profile
add
SELECTION DETAILS AND OTHERs
Job Location
Desgination
Salary
Job Profile
add
Job Profile
Job Location
Desgination
Salary
Job Profile
i agree.
Submit
send


North Carolina, one of the original 13 colonies, entered the Union in
November 1789. The state did not participate in the 1864 election due to
secession. Like many other southern states, North Carolina voted almost
exclusively Democratic from 1876 through 1964 and almost exclusively Republican
beginning in 1968. The initial shift was largely in response to white conservative
voter uneasiness with the civil rights legislation passed in the mid-1960s,
which was effectively exploited by the Republicans “southern strategy.”
In 2008, Barack Obama reversed the trend of Republican dominance here
(although just barely), defeating John McCain by about 14,000 votes out
of 4.3 million cast (49.7% to 49.4%). In percentage terms, it was the 2nd
closest race of the 2008 election (behind Missouri). In 2012, North Carolina
was again the 2nd closest race (this time behind Florida) as the state
flipped Republican. Mitt Romney beat Obama by about 2%. Donald Trump won
the state by 3.6% over Hillary Clinton in 2016. Based on population projections,
the state may gain an additional electoral vote after the 2020 presidential
election.
In North Carolina's 2016 election, Republicans won their districts with
an average of 60.3% percent of the vote, and Democrats won their districts
with an average of 68.5% percent of the vote. The difference between the
two parties’ win margins indicates North Carolina may be gerrymandered
to gain an advantage for Republicans. The chance that this difference would
have arisen by nonpartisan processes alone is 0.28% (or 1 in 354).
In North Carolina in 2016, the median Democratic vote share was 41.6%,
the average Democratic vote share was 46.4%, and the difference is 4.8%.
This difference suggests North Carolina is gerrymandered to gain an advantage
for Republicans. The chance that this difference would have arisen by nonpartisan
processes alone is 3.4%.


Click on the link to confirm the change of your email adress from {{ .Email }} to {{ .NewEmail }}:
Change Email Address


Create Maven project in GitHub
published by Pradeep on March 14, 2018
If you are looking to publish your first Maven project to gitHub then this article will help you to get started with that. I am going to explain the steps involved in creating a new maven project and pushing it to gitHub. Before creating local project its better to create empty repository in gitHub so we can later clone it.
Create new repository in Github
-
Login into your gitHub account and create new repository.
-
Provide name for repository. I am providing name as ‘my-app’.
-
Select ‘java’ from ‘Add .gitignore’ dropdown. This will generate a default .gitignore file needed for a java project.
-
Click on ‘Create repository’ button. Empty repository will be created and in next section we will create Maven project.
Create new maven project in local
-
Make sure you have java, maven and git installed in your local before proceeding further.
-
Open command prompt (or terminal) and go to a folder where you want to create a new project.
-
Execute below maven command. This command will create a simple Java project with in folder ‘my-app’. Note that this name should match with repository name in gitHub.
mvn -B archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.mycompany.app -DartifactId=my-app
-
Above command should show ‘BUILD SUCCESS’ message and it will create below files and folders:
-
New folder ‘my-app’ (this is the same name we provided for repository in gitHub)
-
pom.xml in my-app folder. This is the main maven file.
-
Folders for java and test classes.
-
-
New maven project is created.
Clone GitHub repository and merge with Maven project
-
In github.com goto ‘my-app’ project.
-
Click on ‘Clone or download’ drop-down and click copy icon next to repository web URL. This will copy URL into clipboard.
-
Now we need to clone this project into our maven folder but git clone command will not work if already project folder exists. In our case we already created maven project folder so we will clone it into temp folder. I found this trick from this stack-overflow discussion.
-
If you are in ‘my-app’ folder in CMD/termical then go to parent folder and execute below command. This command will clone gitHub repository into temp folder.
git clone <URL copied from gitHub> temp
-
In temp folder you should see .git and .gitignore files downloaded. These are hidden files.
-
Now copy .git and .gitignore from temp into my-app folder and then remove temp folder by executing below commands
Use below commands in Windows command prompt
xcopy /S/H/Y temp my-app
rmdir temp /S/Q
Use below commands in Mac terminal
cp -a temp/. my-app/
rm -rf temp
-
You should see .git, .gitignore, src and pom.xml files in my-app folder.
-
Now we have maven project with git. In next section we will see how to do first commit and push to gitHub repository.
Commit and push to gitHub repository
-
‘git status’ command in gitHub project will show current check-in status of the files so execute ‘git status’ in root folder of the project.
my-app $ git status
On branch master
Your branch is up-to-date with 'origin/master'.
Untracked files:
(use "git add <file>..." to include in what will be committed)
pom.xml
src/
nothing added to commit but untracked files present (use "git add" to track)
-
This command shows that pom.xml and src is not yet committed, so execute ‘git add -A’ this will add all new files to staging.

Changes to be committed:
(use "git reset HEAD <file>..." to unstage)
new file: pom.xml
new file: src/main/java/com/mycompany/app/App.java
new file: src/test/java/com/mycompany/app/AppTest.java
-
This time it shows all files are in staging and ready to be committed.
 We are also providing comment for all these files with -m option.
my-app $ git commit -m "initial project setup"
[master e719d11] initial project setup
3 files changed, 69 insertions(+)
create mode 100644 pom.xml
create mode 100644 src/main/java/com/mycompany/app/App.java
create mode 100644 src/test/java/com/mycompany/app/AppTest.java
-
All files are checked into local repository. Now lets push them to remote gitHub repository. Execute ‘git push origin master’
my-app $ git push origin master
Counting objects: 16, done.
Delta compression using up to 4 threads.
Compressing objects: 100% (6/6), done.
Writing objects: 100% (16/16), 1.51 KiB | 0 bytes/s, done.
Total 16 (delta 0), reused 0 (delta 0)
To https://github.com/kpradeep12/my-app.git
62985a4..e719d11 master -> master
-
Go to gitHub repository and you should see all your maven files uploaded there. Now any one can work on this repository. If you want to pull all new changes from remote to local repository then execute ‘git pull –all’
Now we have a full maven project setup with gitHub integration. This project is ready to be imported into any of your favorite IDE.


Hi after nine months of anxiety and depression I though I finally fought through it when an event led me to spiral down again. Realizing I had nothing left to fight with I decided to listen to to some who'd been telling me to try something. I can't really rate this because I've only taken my 4th dose but so far no side effects that aren't manageable.
I am trying to keep the negative self talk at bay and to recognize how my anxiety is leading me to make bad choices which then lead to depression and the cycle goes on.
SENT5
At least that's what I think is happening. I know a lot of people said they felt immediately better and that it was from the meds but for me I think it is more of a peace in deciding I can't live like this anymore. I am hopeful


By typing in my signature below, I have acknowledged that I have received my computer and all other items in good order.
Clicking the "Sign" button, you acknowledge the receipt of these items.


Login to your account
Enter your credentials below
Sign in
Footer
© 2020
Curec - Let's beat this together
Designed by
Synn~Labz


Apartment 123
Add Chore
Chore:
Chore Owner:
Date:
Location:
Select
Kitchen
Bedroom
Living Room
Bathroom
Laundry Room
Description:
X
Your chore has been created!
Continue
Cancel


You can export data by making requests to specific URLs.
Export a file containing all submitted forms.
/export/forms/<formcode>
Parameters:
An orderered array of columns to export, eg:
["reported_date","from","related_entities.clinic.name"]
Defaults to:
["_id","patient_id","reported_date", "from", "related_entities.clinic.contact.name", "related_entities.clinic.name", "related_entities.clinic.parent.contact.name", "related_entities.clinic.parent.name", "related_entities.clinic.parent.parent.name"]
Available columns:
All form fields will be included as columns at the end regardless of the value for this parameter.
Export a file containing all messages
/export/messages
Examples:
Return only rows that are scheduled to be sent in the next ten days.
/export/messages?filter_state=scheduled&filter_state_to=10
Parameters:
An orderered array of columns to export, eg:
["reported_date","from","related_entities.clinic.name"]
Defaults to:
["_id","patient_id","reported_date", "from", "related_entities.clinic.contact.name", "related_entities.clinic.name", "related_entities.clinic.parent.contact.name", "related_entities.clinic.parent.name", "related_entities.clinic.parent.parent.name","task.type","task.state","received","scheduled","pending","sent","cleared","muted"]
Available columns:
Regardless of the value for this parameter, for each message the following four columns will be appended
Export a file containing the audit log.
/export/audit
Parameters:


Regular expressions are a very powerful tool that can be used across languages to help search out patterns in your code.
Although the subject can only be mastered with practice, here is a short summary of how to reference different search patterns with a cheat sheet image at the bottom. Enjoy
So what is the purpose of regular expressions? They are use to search for literal orders of string characters and digits.
abc or 123 will look for instances of the 3 letters or numbers in that specific order.
\d searches for any digit
\D any Non-digit character like punctuation
\w searches for any alphanumeric character
\W any Non-alphanumberic character
The . character is a general joker/wildcard
Surrounding letters with brackets will look for those sepecfic letters
[fgh] would look for any of the letters: 'f', 'g', 'h' in the pattern.
Using a hat ^ INSIDE the brackets will exclude letters from a search
[^ijk] would skip words with the letters 'i' 'j' or 'k' from your search.
Ranges can also be set within brackets:
[4-9] will search a character for the digits 4 through 9
[^a-g] will search for all letters except a through g
Note that letters are case sensitive
[A-C] will only get the words containing Upper Case letters 'A','B','C'
Searching for multiple occurances of a letter is fairly simple
\x\x\x or x{3} will search for 3 instances of the lower case letter 'x' connected
Also you can set a range inside the curly braces. x{3,6} will look for between 3 and 6 occurances of the letter x
But there are other ways as well:
A * character represents 0 or more of a charater while
The + character represents 1 or more and makes more sense to use.
B+ looks for 1 or more Upper Case letter B
The ? character is a little trying and is used to signal an optional character search. It is similar to using *. The results will show with or without the preceding character to the ?
smiles? - the s is optional and the search will return smile and smiles
When needing to reference whitespace use "\s".
Using a hat ^ without brackets at the beginning and a dollar sign $ at the end will search for an exact match for the contents. I would compare this to using quotes on a search engine.
^Clear Example$ would literally search for the exact string inside the special characters in that casing instead of returning partial matches.
Parentheses can be used to check for subpatterns such as file names.
^(screenshot.*)\.png$ searches for files starting with the wordscreenshot but may have a longer name and are also appended with a .png file extension.
The contents in the parentheses can then be used for futher data processing and You can also nest parentheses within each other for extra data processing.
Lastly we can add a pipe | inside of a parentheses to signify the or conditional statement which can add to your search results.
For some practical examples I reccomend regexone.