Files CCore/inc/gadget/PtrLen.h CCore/src/gadget/PtrLen.cpp
This file contains main tools to work with ranges of objects. Range is a continuous part of an array. There is an object in the range with the lower address, its address is a base address of the range. "Address" means a pointer of the correspondent type. If this address is p, then the range consists of objects with addresses { p, p+1, ..., p+n-1 }, where n is the number of elements of the range. A range can be empty. In this case it has the base address, which may not refer to an existing object, but the number of elements is 0. A range of length 1 can also be formed from a single object. Finally, empty range may have the base address equals null.
Sometimes Range is considered more generally using idiom of iterator, but we focus on the basic type of ranges, because of its practical importance. Basic ranges are the most efficient and convenient way of representation of a set of similar data, so it must be used whenever possible. The main advantages of basic ranges are: best loops, best sequential and random object access, best cache locality.
The best loop in the programming is the loop n-times. This is because such loops can be unrolled, pipelined and optimized for small loop count. So compilers usually try to reorganize every loop into this kind of loop, if possible.
Range...() is four basic functions to work with ranges.
template <class T,class S> void RangeCopy(T *restrict dst,const S *restrict src,ulen count); template <class T> void RangeSet(T *dst,T src,ulen count); template <class T> void RangeSet_null(T *dst,ulen count); template <class T,class S> ulen RangeMatch(const T *dst,const S *src,ulen count);
RangeCopy() does copy one range to disjoint another range with the possible implicit type conversion. It performs assignments *dst=*src;. Here we use the non-standard extension to C++ — keyword restrict. It tells compiler, that dst and src ranges has no common elements, and enables loop optimization, based on this assumption. restrict, in fact, is a macro in the target PlatformBase.h header, so target can define this word according compiler abilities.
RangeSet() sets elements of the given range to the given value. The src argument is not a reference. It performs assignments *dst=src;.
RangeSet_null() sets elements of the given range to the null value T(). It performs assignments *dst=T();.
The interface and implementation of these functions are selected to be more appropriate, when the type T is a Small Data Type. They do they job in the ascending order, but you should not assume any specific order of execution.
RangeMatch() compares elements of two ranges. It returns the number of the first equals pairs. In other words, if the RangeMatch() returned len, then dst[0]==src[0], ..., dst[len-1]==src[len-1], but len==count or dst[len]!=src[len]. To compare elements the operator != is used.
PtrLen is a range representation type. It contains the range base pointer and the range length.
template <class T>
struct PtrLen
{
T *ptr;
ulen len;
PtrLen is widely used in CCore to pass ranges as arguments and to do native operations with ranges. This type has a bunch of methods to do so.
You can use constructors to create a PtrLen, but more often you should use the function Range().
// constructors PtrLen() noexcept : ptr(0),len(0) {} PtrLen(NothingType) : ptr(0),len(0) {} PtrLen(T *ptr_,ulen len_) : ptr(ptr_),len(len_) {} operator PtrLen<const T>() const { return {ptr,len}; }
You can also cast to the const version.
Cursor methods can be used to iterated through range elements. When you use PtrLen as a cursor, it advances in the ascending order. I.e. after (ptr,len) the (ptr+1,len-1) follows.
// cursor ulen operator + () const { return len; } // get length // range is not empty bool operator ! () const { return !len; } // range is empty T & operator * () const { return *ptr; } // first element T * operator -> () const { return ptr; } // pointer to the first element void operator ++ () { ptr++; len--; } // advance void operator -- () { ptr--; len++; } // back PtrLen<T> operator += (ulen delta); // advance on delta PtrLen<T> takeup(ulen delta); // advance up to delta elements T & take(); // take first element and advance PtrLen<T> getFinal() const { return {ptr+len,0}; }
Here is a typical usage:
for(auto r=Range(....); +r ;++r) r->method();
for(auto r=Range(....); +r ;++r) func(*r);
for(auto r=Range(....); +r ;) func(r.take());
for(auto r=Range(....); r.fit(10) ;) { auto prefix=(r+=10); // first 10 element subrange .... }
for(auto r=Range(....);;) { auto prefix=r.takeup(10); // first <=10 element subrange if( !prefix ) break; // r was empty .... }
operator += advances on the given number of elements and returns the range of these elements. You must be sure the number does not exceed the range length.
takeup() is similar, but it checks the range length and advances up to the given number of elements.
Loop
for(auto r=Range(....); +r ;++r) { .... /* (*r) */ }
,in fact, is the same as
{ T *ptr=....; ulen len=....; for(; len ;ptr++,len--) { .... /* (*ptr) */ } }
So it is count-down n-times loop. There is another popular way of a range iteration:
T *ptr=....; T *lim=....; for(; ptr<lim ;ptr++) { .... /* (*ptr) */ }
Compilers, however, often turn this loop into the previous one. It leads to:
T *ptr=....; T *lim=....; ulen len=lim-ptr; // there is a hidden division operation here for(; len ;ptr++,len--) { .... /* (*ptr) */ }
Many embedded CPU has no hardware division. So it leads to an expensive hidden operation, that may kill performance for short tight loops.
Reverse iteration can be done with the method getFinal():
auto r=Range(....); // (ptr,len) for(auto fin=r.getFinal(); fin.len<r.len ;) { --fin; func(fin); // iterate (ptr+len-1,1), (ptr+len-2,2), ..., (ptr,len) }
Methods fit() can be used to check the length of the range.
// fit bool fit(ulen length) const { return length<=len; } bool fit(ulen off,ulen length) const { return off<=len && length<=(len-off) ; }
The first checks is there at least the length elements. The second can be used to check if the subrange with the given off(set) from the begin and length can be selected.
You can select a desired part of the range using parts methods:
// parts PtrLen<T> prefix(ulen length) const; // prefix of the given length PtrLen<T> prefix(PtrLen<T> suffix) const; // prefix, complementary to the given suffix PtrLen<T> suffix(ulen length) const; // suffix of the given length PtrLen<T> part(ulen off,ulen length) const; // inner part with the given off(set) and length PtrLen<T> part(ulen off) const; // suffix with the given off(set) PtrLen<T> inner(ulen off,ulen endoff) const; // inner part with the given off(set) and offset from the end (endoff) PtrLen<T> safe_part(ulen off,ulen length) const; PtrLen<T> safe_part(ulen off) const;
safe_part() is similar to the method part(), but safe to use. It checks boundaries and returns the available part from the range.
You can pick an element of the range based on its index:
// index access T & operator [] (ulen index) const; T & at(ulen index) const; // with the index guard T & back(ulen index) const; // reverse order, index 1 means the last element
The following set of methods performs basic range operations:
// methods template <class S> void copyTo(S dst[/* len */]) const; template <class S> void copyFrom(const S src[/* len */]) const; void copy(const T src[/* len */]) const; void set(T src) const; void set_null() const; template <class S> ulen match(const S src[/* len */]) const; template <class S> bool equal(const S src[/* len */]) const; template <class S> bool equal(PtrLen<S> src) const; template <class S> bool hasPrefix(PtrLen<S> src) const; template <class S> bool hasSuffix(PtrLen<S> src) const;
The last method is required to support range-based for with the PtrLen:
// begin()/end() support bool operator != (ulen end_end) const { return len!=end_len; }
StrLen is a derived class from the PtrLen<const char>.
struct StrLen : PtrLen<const char>
{
// constructors
StrLen() noexcept {}
StrLen(NothingType) {}
// implicit conversions
StrLen(const char *zstr); // zstr!=0 is a pointer to a zero-terminated string
StrLen(PtrLen<const char> str) : PtrLen<const char>(str) {}
StrLen(PtrLen<char> str) : PtrLen<const char>(str.ptr,str.len) {}
// given string
StrLen(const char *str,ulen len) : PtrLen<const char>(str,len) {}
};
StrLen is widely used in CCore to pass string arguments and to work with strings. It is not assumed, that the string is zero-terminated. Instead, we specify the string length.
StrLen has a several implicit constructors, so it can be silently converted from different string-like types.
The implicit encoding string length with zero termination was a language design mistake. To perform string operations you have to know its length. So each time you will have to calculate it. It may lead to quadratic time algorithms instead of linear time if you are not steady enough. But the most goodless thing is you cannot select a substring from a zero-terminated string: it is not a zero-terminated! So you have to allocate memory and do copy! In CCore we avoid it converting zero-terminated strings into StrLen. So we calculate zero-terminated string length only one time and then use it everywhere.
There is a string literal with the suffix _c.
inline StrLen operator "" _c (const char *str,ulen len) { return StrLen(str,len); }
You may use it to create a StrLen object with zero overhead:
StrLen str="some string"_c;
template <class T>
PtrLen<T> Single(T &obj) { return Range(&obj,1); }
Single() creates a range from the single object.
Range() and Range_const() is a family of Creator functions for the range creation.
template <class T> PtrLen<T> Range(PtrLen<T> a); template <class T,ulen Len> PtrLen<T> Range(T (&buf)[Len]); template <class T> PtrLen<T> Range(T *ptr,ulen len); template <class T> PtrLen<T> Range(T *ptr,T *lim);
And the correspondent const-variants.
template <class T> PtrLen<const T> Range_const(PtrLen<T> a); template <class T,ulen Len> PtrLen<const T> Range_const(T (&buf)[Len]); template <class T> PtrLen<const T> Range_const(T *ptr,ulen len); template <class T> PtrLen<const T> Range_const(T *ptr,T *lim);
You can create a range from a PtrLen, from an array, from a base pointer and length and from a base pointer and a limit pointer. Limit is a pointer to the past-the-end element. It may not refer to an actual object. The advantage of using the function Range() is an implicit type inference. Consider:
int buf[10]; auto r=Range(buf); PtrLen<int> r1(buf,10);
Finally, there exists two generic functions Range() and Range_const():
auto Range(RangeAccessType &&src); auto Range_const(const RangeAccessType &src);
They are applicable to objects of types with the Range Access Interface:
class C { public: // range access T * getPtr(); // called from Range() const T * getPtr() const; // called from Range() with constant argument const T * getPtr_const() const; // called from Range_const() ulen getLen() const; };
The following four concepts can be used to select types — range providers. I.e. arguments of these types can be used with the function Range().
/* concept RangeableType<T> */ template <class T> // ref extended concept bool RangeableType = requires(T &obj) { Range(obj); } ; /* concept TypeRangeableType<T,S> */ template <class T,class S> // T ref extended concept bool TypeRangeableType = RangeableType<T> && requires(T &obj) { { Range(obj) } -> PtrLen<S> ; } ;
RangeableType — can be used with the function Range().
TypeRangeableType => RangeableType and the result of Range() is implicitly converted to the PtrLen<S>.
/* concept ConstRangeableType<T> */ template <class T> // ref extended concept bool ConstRangeableType = requires(Meta::ToConst<T> &cobj) { Range_const(cobj); } ; /* concept TypeRangeableType<T,S> */ template <class T,class S> // T ref extended concept bool ConstTypeRangeableType = ConstRangeableType<T> && requires(Meta::ToConst<T> &cobj) { { Range_const(cobj) } -> PtrLen<const S> ; } ;
ConstRangeableType — const type can be used with the function Range_const().
ConstTypeRangeableType => ConstRangeableType and the result of Range_const() is implicitly converted to the PtrLen<const S>.
CCore defines in its namespace global functions begin() and end(). They are applicable to objects of types with the Range Access Interface and to PtrLen type. So you can use range-based for:
PtrLen<T> r=....; for(auto obj : r ) { .... }
This loop is essentially the same as:
PtrLen<T> r=....; for(; +r ;++r) { .... } // *r instead of obj
Or:
DynArray<T> data; for(auto obj : data ) { .... }
Instead of:
DynArray<T> data; for(auto r=Range(data); +r ;++r) { .... } // *r instead of obj
Sometimes you need to do something more complicated than merely run through a range. In such cases use range loops instead of range-based for:
DynArray<T> data; auto r=Range(data); if( +r ) { .... // handle the first element for(++r; +r ;++r) { .... // do with the rest } } else { .... // empty case }
Mutate...() is a three functions family to cast a pointer or a range to the byte pointer or the byte range.
template <class T> T * MutatePtr(void *ptr); template <class T> T * MutatePtr(const void *ptr); template <class T,class S> PtrLen<T> Mutate(PtrLen<S> a);
The destined type T must be (const) char or unsigned char. Mutate() creates a PtrLen over all bytes, occupied by elements of the source range. C++ standard allows aliasing of objects with these types. Mutate...() should be used with caution in special cases for the sake of performance or to do some low-level processing.


About: Web Designer / UI.
Hobbies: Read, out with friends, listen to music, draw and learn new things.
Skills: Web Dev UI/UX Debugging Mobile Dev OS
Culture: Team Leader Creative People Skills Team Member Accurate


youtube-dlc
Enter a video url to download the video to the server. Url can be to YouTube or any other supported site. The server will automatically download the highest quality version available.
% include('ydl_server/templates/header.html')
Enter a video url to download the video to the server. Url can be to YouTube or any other supported site. The server will automatically download the highest quality version available.


News
- LABFORALL |
LABFORALL (Culturability callback) aims to blend together young fresh minds with experts into a creative non-conventional lab.
Please, visit LABFORALL
Engaged through architecture, endured by communities
...in a thoughtful collective way!
LABFORALL (Culturability callback) aims to blend together young fresh minds with experts into a creative non-conventional lab.
Please, visit LABFORALL


spring.controller.insurance
Classes
RESTCommissionController
RESTContractController
RESTContractControllerTest
RESTSpecialConditionController
RESTSpecialConditionControllerTest
RESTSuretyController
RESTSuretyControllerTest
RESTTaxController
RESTVehicleInsuranceController
RESTVehicleInsuranceControllerTest


Textsecure_SessionStructure
Undocumented
-
Undocumented
-
Undocumented
-
Returns true if
sessionVersion
has been explicitly set.Declaration
Swift
var hasSessionVersion: Bool
-
Clears the value of
sessionVersion
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearSessionVersion()
-
Undocumented
-
Returns true if
localIdentityPublic
has been explicitly set.Declaration
Swift
var hasLocalIdentityPublic: Bool
-
Clears the value of
localIdentityPublic
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearLocalIdentityPublic()
-
Undocumented
-
Returns true if
remoteIdentityPublic
has been explicitly set.Declaration
Swift
var hasRemoteIdentityPublic: Bool
-
Clears the value of
remoteIdentityPublic
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearRemoteIdentityPublic()
-
Undocumented
-
Returns true if
rootKey
has been explicitly set.Declaration
Swift
var hasRootKey: Bool
-
Clears the value of
rootKey
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearRootKey()
-
Undocumented
-
Returns true if
previousCounter
has been explicitly set.Declaration
Swift
var hasPreviousCounter: Bool
-
Clears the value of
previousCounter
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearPreviousCounter()
-
Undocumented
-
Returns true if
senderChain
has been explicitly set.Declaration
Swift
var hasSenderChain: Bool
-
Clears the value of
senderChain
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearSenderChain()
-
Undocumented
-
Undocumented
-
Returns true if
pendingKeyExchange
has been explicitly set.Declaration
Swift
var hasPendingKeyExchange: Bool
-
Clears the value of
pendingKeyExchange
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearPendingKeyExchange()
-
Undocumented
-
Returns true if
pendingPreKey
has been explicitly set.Declaration
Swift
var hasPendingPreKey: Bool
-
Clears the value of
pendingPreKey
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearPendingPreKey()
-
Undocumented
-
Returns true if
remoteRegistrationID
has been explicitly set.Declaration
Swift
var hasRemoteRegistrationID: Bool
-
Clears the value of
remoteRegistrationID
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearRemoteRegistrationID()
-
Undocumented
-
Returns true if
localRegistrationID
has been explicitly set.Declaration
Swift
var hasLocalRegistrationID: Bool
-
Clears the value of
localRegistrationID
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearLocalRegistrationID()
-
Undocumented
-
Returns true if
needsRefresh
has been explicitly set.Declaration
Swift
var hasNeedsRefresh: Bool
-
Clears the value of
needsRefresh
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearNeedsRefresh()
-
Undocumented
-
Returns true if
aliceBaseKey
has been explicitly set.Declaration
Swift
var hasAliceBaseKey: Bool
-
Clears the value of
aliceBaseKey
. Subsequent reads from it will return its default value.Declaration
Swift
mutating func clearAliceBaseKey()
-
Undocumented
-
Undocumented
See more -
Undocumented
See more -
Undocumented
See more -
Undocumented
-
Used by the decoding initializers in the SwiftProtobuf library, not generally used directly.
init(serializedData:)
,init(jsonUTF8Data:)
, and other decoding initializers are defined in the SwiftProtobuf library. See the Message and Message+*Additions` files.Declaration
Swift
mutating func decodeMessage<D: SwiftProtobuf.Decoder>(decoder: inout D) throws
-
Used by the encoding methods of the SwiftProtobuf library, not generally used directly.
Message.serializedData()
,Message.jsonUTF8Data()
, and other serializer methods are defined in the SwiftProtobuf library. See theMessage
andMessage+*Additions
files.Declaration
Swift
func traverse<V: SwiftProtobuf.Visitor>(visitor: inout V) throws
-
Undocumented
-
Undocumented
-
Undocumented
See more -
Undocumented
-
Undocumented


Notebooks
Story: The !khau lizard and the rainclouds – springbok hunting follows rain; and the song of the !khau lizard
The !khau lizard and the rainclouds – springbok hunting follows rain; and the song of the !khau lizard
Title
The !khau lizard and the rainclouds – springbok hunting follows rain; and the song of the !khau lizard
Collection
Summary
The !khaü (a lizard of the genus Agama), which interferes with the coming of the rain–clouds. Springbok hunting follows the rain. (L VIII.-3. 6232 rev.-6234 rev., 6259-6266, 6269-6271). The !khau, or Agama lizard (or kochelman) lies in the Driedoorn tree and frustrates the rain's clouds so the rain does not fall. The people make the !khau come down from the Driedoorn tree so that the rain-clouds will bring the rain, which in turn brings the springbok.
Comments
1) p.6259v: The song of the !khau (or Agama Lizard), 2) See also The death of the !kau (a lizard of the genus Agama) and The !kau who brought home his own flesh as food, 3) This story is found in Book VIII-3
Contributors
|han≠kass'o (Klein Jantje) (VIII)
Date
13 – 19 February 1878
Categories
Keywords
rain (the !khau lizard and the rain–clouds) , rain (springbok hunting follows) , rain (its spoor) , rain ('stands') , rain (parts of its 'body') , rain (its hair is the clouds) , rain (and springbok) , rain (and the actions of the clouds) , rain (when it does not come) , rain (the !khau frustrates it) , rain (and the !khau and the Driedoorn tree) , rain (its things) , rain (the 'Water's things') , !khau (a lizard of the genus Agama or kochelman) , !khau (and the rain-clouds) , !khau (and the rain) , !khau (and springbok hunting which follows rain) , !khau (its actions prevent the rain from coming) , !khau (people shoot it) , !khau (what people say to it) , !khau (the male) , !khau (how people make it descend the tree) , !khau (is a rain's thing) , !khau (its actions) , !khau (lies on the Driedoorn tree) , !khau (frustrates the rain) , lizard (of the genus Agama) , lizard (!khau) , lizard (kochelman) , lizard (the !khau lizard and the rain–clouds) , Agama lizard (!khau or kochelman) , Agama lizard (the !khau lizard and the rain–clouds) , rain's thing (water's things) , rain's thing (the !khau lizard and the rain–clouds) , rain's thing (the !khau or Agama lizard is one) , water's thing (rain's thing) , water's thing (the !khau or Agama lizard is one) , water's thing (the !khau lizard and the rain–clouds) , springbok (hunting follows rain) , springbok (and the !khau lizard and the rain-clouds) , springbok (its pelt) , springbok (the female or doe) , springbok (the male) , springbok (the appearance of) , springbok (methods of hunting) , springbok (follow the rain's 'spoor') , hunting (of springbok follows rain) , hunting (and the !khau lizard and the rain–clouds) , hunting (beautiful springbok) , hunting (the use of children who shoot and see well) , hunting (and the actions of the !khau and the rain) , Driedoorn tree (and the !khau lizard and the rain–clouds) , Driedoorn tree (the !khau lies in) , Driedoorn tree (how the people make the !khau descend) , Driedoorn tree (the !khau must descend it so rain–clouds will bring rain, and springbok) , children (and hunting springbok) , children (see and shoot well) , children (what they say when they see beautiful springbok) , tree (Driedoorn) , tree (and the !khau lizard and the rain–clouds) , tree (that the !khau lies in) , tree (the !khau must descend the Driedoorn so rain–clouds will bring rain, and springbok) , rain–clouds (the !khau lizard and) , rain–clouds (the !khau must descend the Driedoorn tree so that they will bring rain, and springbok)
Story Pages
6232v-6234v, 6259-6266, 6269-6271


The goal of this package is to allow users to robustly and quickly grid and quantify sizes of pinned colonies in plate images. gitter works by first finding the grid of colonies from a preprocessed image and then locating the bounds of each colony separately. It includes several image pre-processing techniques, such as autorotation of plates, noise removal, contrast adjustment and image resizing.
| Version: | 1.1.1 |
| Imports: | jpeg, tiff, logging, PET, ggplot2, EBImage (≥ 4.11.24) |
| Published: | 2015-10-11 |
| Author: | Omar Wagih, Leopold Parts |
| Maintainer: | Omar Wagih <wagih at ebi.ac.uk> |
| License: | LGPL-2 | LGPL-2.1 | LGPL-3 [expanded from: LGPL] |
| NeedsCompilation: | no |
| Materials: | README |
| CRAN checks: | gitter results |
| Reference manual: | gitter.pdf |
| Package source: | gitter_1.1.1.tar.gz |
| Windows binaries: | r-devel: gitter_1.1.1.zip, r-release: gitter_1.1.1.zip, r-oldrel: gitter_1.1.1.zip |
| OS X binaries: | r-release: gitter_1.1.1.tgz, r-oldrel: gitter_1.1.1.tgz |
| Old sources: | gitter archive |
Please use the canonical form https://CRAN.R-project.org/package=gitter to link to this page.


Rafael Trapani Possignolo,
Jose Renau,
SMatch: Structural Matching for Fast Resynthesis in FPGAs.
DAC,
75,
2019.
Riadul Islam,
Matthew R. Guthaus,
HCDN: Hybrid-Mode Clock Distribution Networks.
IEEE Trans. on Circuits and Systems
66-I(1),
251-262,
2019.
Daphne I. Gorman,
Rafael Trapani Possignolo,
Jose Renau,
EMI Architectural Model and Core Hopping.
MICRO,
899-910,
2019.
Bin Wu,
James E. Stine,
Matthew R. Guthaus,
Fast and Area-Efficient SRAM Word-Line Optimization.
ISCAS,
1-5,
2019.
Yuanjiang Ni,
Jishen Zhao,
Heiner Litz,
Daniel Bittman,
Ethan L. Miller,
SSP: Eliminating Redundant Writes in Failure-Atomic NVRAMs via Shadow Sub-Paging.
MICRO,
836-848,
2019.
Grant Ayers,
Nayana Prasad Nagendra,
David I. August,
Hyoun Kyu Cho,
Svilen Kanev,
Christos Kozyrakis,
Trivikram Krishnamurthy,
Heiner Litz,
Tipp Moseley,
Parthasarathy Ranganathan,
AsmDB: understanding and mitigating front-end stalls in warehouse-scale computers.
ISCA,
462-473,
2019.
Riadul Islam,
Hany Ahmed Fahmy,
Ping-Yao Lin,
Matthew R. Guthaus,
DCMCS: Highly Robust Low-Power Differential Current-Mode Clocking and Synthesis.
IEEE Trans. VLSI Syst.
26(10),
2108-2117,
2018.
Chandranil Chakrabortti,
Vikas Sinha,
Heiner Litz,
SSD QoS Improvements through Machine Learning.
SoCC,
511,
2018.
Samuel Grossman,
Heiner Litz,
Christos Kozyrakis,
Making pull-based graph processing performant.
PPOPP,
246-260,
2018.
Rafael Trapani Possignolo,
Elnaz Ebrahimi 0001,
Ehsan K. Ardestani,
Alamelu Sankaranarayanan,
José Luis Briz,
Jose Renau,
GPU NTC Process Variation Compensation With Voltage Stacking.
IEEE Trans. VLSI Syst.
26(9),
1713-1726,
2018.
Milad Hashemi,
Kevin Swersky,
Jamie A. Smith,
Grant Ayers,
Heiner Litz,
Jichuan Chang,
Christos Kozyrakis,
Parthasarathy Ranganathan,
Learning Memory Access Patterns.
ICML,
1924-1933,
2018.
Milad Hashemi,
Kevin Swersky,
Jamie A. Smith,
Grant Ayers,
Heiner Litz,
Jichuan Chang,
Christos Kozyrakis,
Parthasarathy Ranganathan,
Learning Memory Access Patterns.
CoRR
abs/1803.02329,
2018.
Ana Klimovic,
Heiner Litz,
Christos Kozyrakis,
Selecta: Heterogeneous Cloud Storage Configuration for Data Analytics.
USENIX Annual Technical Conference,
759-773,
2018.
Rafael Trapani Possignolo,
Jose Renau,
LiveSynth: Towards an Interactive Synthesis Flow.
DAC,
74:1-74:6,
2017.
Haven Skinner,
Rafael Trapani Possignolo,
Jose Renau,
Liam: an actor based programming model for HDLs.
MEMOCODE,
185-188,
2017.
Riadul Islam,
Matthew R. Guthaus,
CMCS: Current-Mode Clock Synthesis.
IEEE Trans. VLSI Syst.
25(3),
1054-1062,
2017.
Ana Klimovic,
Heiner Litz,
Christos Kozyrakis,
ReFlex: Remote Flash ≈ Local Flash.
ASPLOS,
345-359,
2017.
Daphne I. Gorman,
Matthew R. Guthaus,
Jose Renau,
Architectural opportunities for novel dynamic EMI shifting (DEMIS).
MICRO,
774-785,
2017.
Aydin Buluç,
Scott Beamer,
Kamesh Madduri,
Krste Asanovic,
David A. Patterson,
Distributed-Memory Breadth-First Search on Massive Graphs.
CoRR
abs/1705.04590,
2017.
Rajsaktish Sankaranarayanan,
Matthew R. Guthaus,
Energy Savings and Performance Improvement in Subthreshold Using Adaptive Body Bias.
ACM Great Lakes Symposium on VLSI,
431-434,
2017.
Elnaz Ebrahimi 0001,
Rafael Trapani Possignolo,
Jose Renau,
Level shifter design for voltage stacking.
ISCAS,
1-4,
2017.
Scott Beamer,
Krste Asanovic,
David A. Patterson,
Reducing Pagerank Communication via Propagation Blocking.
IPDPS,
820-831,
2017.
Elnaz Ebrahimi 0001,
Matthew R. Guthaus,
Jose Renau,
Timing speculative SRAM.
ISCAS,
1-4,
2017.
Sina Hassani,
Gabriel Southern,
Jose Renau,
LiveSim: Going live with microarchitecture simulation.
HPCA,
606-617,
2016.
Rafael Trapani Possignolo,
Elnaz Ebrahimi 0001,
Haven Skinner,
Jose Renau,
Fluid Pipelines: Elastic circuitry meets Out-of-Order execution.
ICCD,
233-240,
2016.
Elnaz Ebrahimi 0001,
Rafael Trapani Possignolo,
Jose Renau,
SRAM voltage stacking.
ISCAS,
1634-1637,
2016.
Gabriel Southern,
Jose Renau,
Analysis of PARSEC workload scalability.
ISPASS,
133-142,
2016.
Ehsan K. Ardestani,
Rafael Trapani Possignolo,
José Luis Briz,
Jose Renau,
Managing Mismatches in Voltage Stacking with CoreUnfolding.
TACO
12(4),
43:1-43:26,
2016.
Rafael Trapani Possignolo,
Jose Renau,
LiveSynth: Towards an interactive synthesis flow.
Hot Chips Symposium,
1,
2016.
Gabriel Southern,
Jose Renau,
Overhead of deoptimization checks in the V8 javascript engine.
IISWC,
75-84,
2016.
Matthew R. Guthaus,
James E. Stine,
Samira Ataei,
Brian Chen,
Bin Wu,
Mehedi Sarwar,
OpenRAM: an open-source memory compiler.
ICCAD,
93,
2016.
Samira Ataei,
James E. Stine,
Matthew R. Guthaus,
A 64 kb differential single-port 12T SRAM design with a bit-interleaving scheme for low-voltage operation in 32 nm SOI CMOS.
ICCD,
499-506,
2016.
Heiner Litz,
Benjamin Braun,
David R. Cheriton,
EXCITE-VM: Extending the Virtual Memory System to Support Snapshot Isolation Transactions.
PACT,
401-412,
2016.
Hany Ahmed Fahmy,
Ping-Yao Lin,
Riadul Islam,
Matthew R. Guthaus,
Switched capacitor quasi-adiabatic clocks.
ISCAS,
1398-1401,
2015.
Scott Beamer,
Krste Asanovic,
David A. Patterson,
Locality Exists in Graph Processing: Workload Characterization on an Ivy Bridge Server.
IISWC,
56-65,
2015.
Jose Renau,
Message from the program chair.
ISPASS,
vii,
2015.
Madan Das,
Gabriel Southern,
Jose Renau,
Section based program analysis to reduce overhead of detecting unsynchronized thread communication.
PPOPP,
283-284,
2015.
Ping-Yao Lin,
Hany Ahmed Fahmy,
Riadul Islam,
Matthew R. Guthaus,
LC resonant clock resource minimization using compensation capacitance.
ISCAS,
1406-1409,
2015.
Madan Das,
Gabriel Southern,
Jose Renau,
Section-Based Program Analysis to Reduce Overhead of Detecting Unsynchronized Thread Communication.
TACO
12(2),
23:23:1-23:23:26,
2015.
Scott Beamer,
Krste Asanovic,
David A. Patterson,
GAIL: the graph algorithm iron law.
IA3@SC,
13:1-13:4,
2015.
Benjamin M. LaCara,
Ping-Yao Lin,
Matthew R. Guthaus,
Multi-frequency resonant clocks.
ISCAS,
1402-1405,
2015.
Scott Beamer,
Krste Asanovic,
David A. Patterson,
The GAP Benchmark Suite.
CoRR
abs/1508.03619,
2015.
Riadul Islam,
Matthew R. Guthaus,
Low-Power Clock Distribution Using a Current-Pulsed Clocked Flip-Flop.
IEEE Trans. on Circuits and Systems
62-I(4),
1156-1164,
2015.
Jeren Samandari-Rad,
Matthew R. Guthaus,
Richard Hughey,
Confronting the Variability Issues Affecting the Performance of Next-Generation SRAM Design to Optimize and Predict the Speed and Yield.
IEEE Access
2,
577-601,
2014.
Riadul Islam,
Matthew R. Guthaus,
Current-mode clock distribution.
ISCAS,
1203-1206,
2014.
Bo Wang,
Heiner Litz,
David R. Cheriton,
HICAMP bitmap: space-efficient updatable bitmap index for in-memory databases.
DaMoN,
7:1-7:7,
2014.
Heiner Litz,
David R. Cheriton,
Amin Firoozshahian,
Omid Azizi,
John P. Stevenson,
SI-TM: reducing transactional memory abort rates through snapshot isolation.
ASPLOS,
383-398,
2014.
Heiner Litz,
Ricardo J. Dias,
David R. Cheriton,
Efficient Correction of Anomalies in Snapshot Isolation Transactions.
TACO
11(4),
65:1-65:24,
2014.
Amirkoushyar Ziabari,
Je-Hyoung Park,
Ehsan K. Ardestani,
Jose Renau,
Sung-Mo Kang,
Ali Shakouri,
Power Blurring: Fast Static and Transient Thermal Analysis Method for Packaged Integrated Circuits and Power Devices.
IEEE Trans. VLSI Syst.
22(11),
2366-2379,
2014.
Matthew R. Guthaus,
Gustavo Wilke,
Ricardo Reis 0001,
Revisiting automated physical synthesis of high-performance clock networks.
ACM Trans. Design Autom. Electr. Syst.
18(2),
31:1-31:27,
2013.
Michael Chan,
Heiner Litz,
David R. Cheriton,
Rethinking Network Stack Design with Memory Snapshots.
HotOS,
2013.
Alamelu Sankaranarayanan,
Ehsan K. Ardestani,
José Luis Briz,
Jose Renau,
An energy efficient GPGPU memory hierarchy with tiny incoherent caches.
ISLPED,
9-14,
2013.
Ehsan K. Ardestani,
Gabriel Southern,
Jason Doung,
Elnaz Ebrahimi 0001,
Jose Renau,
ESESC: A fast performance, power, and temperature multicore simulator.
Hot Chips Symposium,
1,
2013.
Holger Fröning,
Mondrian Nüssle,
Heiner Litz,
Christian Leber,
Ulrich Brüning 0001,
On Achieving High Message Rates.
CCGRID,
498-505,
2013.
Janusz Rajski,
Miodrag Potkonjak,
Adit D. Singh,
Abhijit Chatterjee,
Zain Navabi,
Matthew R. Guthaus,
Sezer Gören,
Embedded tutorials: Embedded tutorial 1: Cell-aware test-from gates to transistors.
VLSI-SoC,
2013.
Scott Beamer,
Aydin Buluç,
Krste Asanovic,
David A. Patterson,
Distributed Memory Breadth-First Search Revisited: Enabling Bottom-Up Search.
IPDPS Workshops,
1618-1627,
2013.
Scott Beamer,
Krste Asanovic,
David A. Patterson,
Direction-optimizing breadth-first search.
Scientific Programming
21(3-4),
137-148,
2013.
Ehsan K. Ardestani,
Francisco J. Mesa-Martinez,
Gabriel Southern,
Elnaz Ebrahimi 0001,
Jose Renau,
Sampling in Thermal Simulation of Processors: Measurement, Characterization, and Evaluation.
IEEE Trans. on CAD of Integrated Circuits and Systems
32(8),
1187-1200,
2013.
Ehsan K. Ardestani,
Jose Renau,
ESESC: A fast multicore simulator using Time-Based Sampling.
HPCA,
448-459,
2013.
Ehsan K. Ardestani,
Elnaz Ebrahimi 0001,
Gabriel Southern,
Jose Renau,
Thermal-aware sampling in architectural simulation.
ISLPED,
33-38,
2012.
Xuchu Hu,
Matthew R. Guthaus,
Distributed LC Resonant Clock Grid Synthesis.
IEEE Trans. on Circuits and Systems
59-I(11),
2749-2760,
2012.
Matthew R. Guthaus,
Baris Taskin,
High-Performance, Low-Power Resonant Clocking: Embedded tutorial.
ICCAD,
742-745,
2012.
Shoaib Kamil,
Derrick Coetzee,
Scott Beamer,
Henry Cook,
Ekaterina Gonina,
Jonathan Harper,
Jeffrey Morlan,
Armando Fox,
Portable parallel performance from sequential, productive, embedded domain-specific languages.
PPOPP,
303-304,
2012.
Seokjoong Kim,
Matthew R. Guthaus,
Dynamic voltage scaling for SEU-tolerance in low-power memories.
VLSI-SoC,
207-212,
2012.
Seokjoong Kim,
Matthew R. Guthaus,
SEU-Aware Low-Power Memories Using a Multiple Supply Voltage Array Architecture.
VLSI-SoC (Selected Papers),
181-195,
2012.
Rajsaktish Sankaranarayanan,
Matthew R. Guthaus,
A single-VDD ultra-low energy sub-threshold FPGA.
VLSI-SoC,
219-224,
2012.
Matthew R. Guthaus,
Xuchu Hu,
Gustavo Wilke,
Guilherme Flach,
Ricardo Reis 0001,
High-performance clock mesh optimization.
ACM Trans. Design Autom. Electr. Syst.
17(3),
33:1-33:17,
2012.
Matthew R. Guthaus,
Welcome from the general chair.
VLSI-SoC,
2012.
Jeren Samandari-Rad,
Matthew R. Guthaus,
Richard Hughey,
VAR-TX: A variability-aware SRAM model for predicting the optimum architecture to achieve minimum access-time for yield enhancement in nano-scaled CMOS.
ISQED,
506-515,
2012.
H. Blake Skinner,
Xuchu Hu,
Matthew R. Guthaus,
Harmonic resonant clocking.
VLSI-SoC,
59-64,
2012.
Curtis Andrus,
Matthew R. Guthaus,
Lithography-aware layout compaction.
ACM Great Lakes Symposium on VLSI,
147-152,
2012.
Scott Beamer,
Krste Asanovic,
David A. Patterson,
Direction-optimizing breadth-first search.
SC,
12,
2012.
Xuchu Hu,
Walter James Condley,
Matthew R. Guthaus,
Library-aware resonant clock synthesis (LARCS).
DAC,
145-150,
2012.
Seokjoong Kim,
Matthew R. Guthaus,
Low-power multiple-bit upset tolerant memory optimization.
ICCAD,
577-581,
2011.
Matthew R. Guthaus,
Distributed LC resonant clock tree synthesis.
ISCAS,
1215-1218,
2011.
Sheldon Logan,
Matthew R. Guthaus,
Package-chip co-design to increase flip-chip C4 reliability.
ISQED,
553-558,
2011.
Michael Brown,
Jose Renau,
ReRack: power simulation for data centers with renewable energy generation.
SIGMETRICS Performance Evaluation Review
39(3),
77-81,
2011.
Sangeetha Sudhakrishnan,
Rigo Dicochea,
Jose Renau,
Releasing efficient beta cores to market early.
ISCA,
213-222,
2011.
Walter James Condley,
Xuchu Hu,
Matthew R. Guthaus,
A methodology for local resonant clock synthesis using LC-assisted local clock buffers.
ICCAD,
503-506,
2011.
Heiner Litz,
Christian Leber,
Benjamin Geib,
DSL programmable engine for high frequency trading acceleration.
WHPCF@SC,
31-38,
2011.
Seokjoong Kim,
Matthew R. Guthaus,
SNM-aware power reduction and reliability improvement in 45nm SRAMs.
VLSI-SoC,
204-207,
2011.
Xuchu Hu,
Matthew R. Guthaus,
Clock tree optimization for Electromagnetic Compatibility (EMC).
ASP-DAC,
184-189,
2011.
Xuchu Hu,
Matthew R. Guthaus,
Distributed Resonant clOCK grid Synthesis (ROCKS).
DAC,
516-521,
2011.
Walter James Condley,
Andrew W. Hill,
Matthew R. Guthaus,
Advanced logic design through hands-on digital music synthesis.
MSE,
17-20,
2011.
Seokjoong Kim,
Matthew R. Guthaus,
Leakage-aware redundancy for reliable sub-threshold memories.
DAC,
435-440,
2011.
Christian Leber,
Benjamin Geib,
Heiner Litz,
High Frequency Trading Acceleration Using FPGAs.
FPL,
317-322,
2011.
Jose Renau,
Will Eatherton,
Hot Chips 22.
IEEE Micro
31(2),
4-5,
2011.
Sangeetha Sudhakrishnan,
Francisco J. Mesa-Martinez,
Jose Renau,
A design time simulator for computer architects.
ISQED,
164-173,
2011.
Holger Fröning,
Heiner Litz,
Efficient hardware support for the Partitioned Global Address Space.
IPDPS Workshops,
1-6,
2010.
Walter James Condley,
Xuchu Hu,
Matthew R. Guthaus,
Analysis of high-performance clock networks with RLC and transmission line effects.
SLIP,
51-58,
2010.
Derek Chan,
Matthew R. Guthaus,
Analysis of power supply induced jitter in actively de-skewed multi-core systems.
ISQED,
785-790,
2010.
Matthew R. Guthaus,
Gustavo Wilke,
Ricardo Reis 0001,
Non-uniform clock mesh optimization with linear programming buffer insertion.
DAC,
74-79,
2010.
Francisco J. Mesa-Martinez,
Ehsan K. Ardestani,
Jose Renau,
Characterizing processor thermal behavior.
ASPLOS,
193-204,
2010.
Heiner Litz,
Maximilian Thürmer,
Ulrich Brüning 0001,
TCCluster: A Cluster Architecture Utilizing the Processor Host Interface as a Network Interconnect.
CLUSTER,
9-18,
2010.
Scott Beamer,
Chen Sun,
Yong-Jin Kwon,
Ajay Joshi,
Christopher Batten,
Vladimir Stojanovic,
Krste Asanovic,
Re-architecting DRAM memory systems with monolithically integrated silicon photonics.
ISCA,
129-140,
2010.
Matthew R. Guthaus,
Teaching VLSI design in 10 weeks.
MSE,
41-44,
2009.
Scott Beamer,
Krste Asanovic,
Christopher Batten,
Ajay Joshi,
Vladimir Stojanovic,
Designing multi-socket systems using silicon photonics.
ICS,
521-522,
2009.
Ajay Joshi,
Christopher Batten,
Yong-Jin Kwon,
Scott Beamer,
Imran Shamim,
Krste Asanovic,
Vladimir Stojanovic,
Silicon-photonic clos networks for global on-chip communication.
NOCS,
124-133,
2009.
Heiner Litz,
Holger Fröning,
Ulrich Brüning 0001,
A HyperTransport 3 Physical Layer Interface for FPGAs.
ARC,
4-14,
2009.
Holger Fröning,
Heiner Litz,
Ulrich Brüning 0001,
Efficient Virtualization of High-Performance Network Interfaces.
ICN,
434-439,
2009.
Michael Brown,
Cyrus Bazeghi,
Matthew R. Guthaus,
Jose Renau,
Measuring and modeling variabilityusing low-cost FPGAs.
FPGA,
286,
2009.
Joseph Nayfach-Battilana,
Jose Renau,
SOI, interconnect, package, and mainboard thermal characterization.
ISLPED,
327-330,
2009.
Keven L. Woo,
Matthew R. Guthaus,
Fault-tolerant synthesis using non-uniform redundancy.
ICCD,
213-218,
2009.
Heiner Litz,
Holger Fröning,
Maximilian Thürmer,
Ulrich Brüning 0001,
An FPGA based verification platform for HyperTransport 3.x.
FPL,
631-634,
2009.
Francisco J. Mesa-Martinez,
Michael Brown,
Joseph Nayfach-Battilana,
Jose Renau,
Measuring power and temperature from real processors.
IPDPS,
1-5,
2008.
Sangeetha Sudhakrishnan,
Liying Su,
Jose Renau,
Processor Verification with hwBugHunt.
ISQED,
224-229,
2008.
Sangeetha Sudhakrishnan,
Janaki T. Madhavan,
E. James Whitehead Jr.,
Jose Renau,
Understanding bug fix patterns in verilog.
MSR,
39-42,
2008.
Heiner Litz,
Holger Fröning,
Mondrian Nüssle,
Ulrich Brüning 0001,
VELO: A Novel Communication Engine for Ultra-Low Latency Message Transfers.
ICPP,
238-245,
2008.
Matthew R. Guthaus,
Dennis Sylvester,
Richard B. Brown,
Clock tree synthesis with data-path sensitivity matching.
ASP-DAC,
498-503,
2008.
Francisco J. Mesa-Martinez,
Joseph Nayfach-Battilana,
Jose Renau,
Power model validation through thermal measurements.
ISCA,
302-311,
2007.
Cyrus Bazeghi,
Francisco J. Mesa-Martinez,
Brian Greskamp,
Josep Torrellas,
Jose Renau,
Estimating design time for system circuits.
VLSI-SoC,
60-65,
2007.
Cyrus Bazeghi,
Francisco J. Mesa-Martinez,
Jose Renau,
System and Procesor Design Effort Estimation.
VLSI-SoC (Selected Papers),
1-21,
2007.
Francisco J. Mesa-Martinez,
Michael Brown,
Joseph Nayfach-Battilana,
Jose Renau,
Measuring performance, power, and temperature from real processors.
Experimental Computer Science,
16,
2007.
Francisco J. Mesa-Martinez,
Jose Renau,
Effective Optimistic-Checker Tandem Core Design through Architectural Pruning.
MICRO,
236-248,
2007.
Luis Ceze,
Karin Strauss,
James Tuck,
Josep Torrellas,
Jose Renau,
CAVA: Using checkpoint-assisted value prediction to hide L2 misses.
TACO
3(2),
182-208,
2006.
Francisco J. Mesa-Martinez,
Michael C. Huang,
Jose Renau,
SEED: scalable, efficient enforcement of dependences.
PACT,
254-264,
2006.
Wei Liu 0014,
James Tuck,
Luis Ceze,
Wonsun Ahn,
Karin Strauss,
Jose Renau,
Josep Torrellas,
POSH: a TLS compiler that exploits program structure.
PPOPP,
158-167,
2006.
Jose Renau,
Karin Strauss,
Luis Ceze,
Wei Liu 0014,
Smruti R. Sarangi,
James Tuck,
Josep Torrellas,
Energy-Efficient Thread-Level Speculation.
IEEE Micro
26(1),
80-91,
2006.
Yun Ding,
Heiner Litz,
Creating multiplatform user interfaces by annotation and adaptation.
IUI,
270-272,
2006.
Matthew R. Guthaus,
Dennis Sylvester,
Richard B. Brown,
Process-induced skew reduction in nominal zero-skew clock trees.
ASP-DAC,
84-89,
2006.
Matthew R. Guthaus,
Dennis Sylvester,
Richard B. Brown,
Clock buffer and wire sizing using sequential programming.
DAC,
1041-1046,
2006.
Cyrus Bazeghi,
Francisco J. Mesa-Martinez,
Jose Renau,
uComplexity: Estimating Processor Design Effort.
MICRO,
209-218,
2005.
Rajiv A. Ravindran,
Robert M. Senger,
Eric D. Marsman,
Ganesh S. Dasika,
Matthew R. Guthaus,
Scott A. Mahlke,
Richard B. Brown,
Partitioning Variables across Register Windows to Reduce Spill Code in a Low-Power Processor.
IEEE Trans. Computers
54(8),
998-1012,
2005.
Matthew R. Guthaus,
Natesan Venkateswaran,
Vladimir Zolotov,
Dennis Sylvester,
Richard B. Brown,
Optimization objectives and models of variation for statistical gate sizing.
ACM Great Lakes Symposium on VLSI,
313-316,
2005.
Matthew R. Guthaus,
Natesan Venkateswaran,
Chandu Visweswariah,
Vladimir Zolotov,
Gate sizing using incremental parameterized statistical timing analysis.
ICCAD,
1029-1036,
2005.
Jose Renau,
Karin Strauss,
Luis Ceze,
Wei Liu 0014,
Smruti R. Sarangi,
James Tuck,
Josep Torrellas,
Thread-Level Speculation on a CMP can be energy efficient.
ICS,
219-228,
2005.
Jose Renau,
James Tuck,
Wei Liu 0014,
Luis Ceze,
Karin Strauss,
Josep Torrellas,
Tasking with out-of-order spawn in TLS chip multiprocessors: microarchitecture and compilation.
ICS,
179-188,
2005.
Luis Ceze,
Karin Strauss,
James Tuck,
Jose Renau,
Josep Torrellas,
CAVA: Hiding L2 Misses with Checkpoint-Assisted Value Prediction.
Computer Architecture Letters
3,
2004.
Yun Ding,
Heiner Litz,
Dennis Pfisterer,
A graphical single-authoring framework for building multi-platform user interfaces.
IUI,
235-237,
2004.
Michael C. Huang,
Jose Renau,
Josep Torrellas,
Positional Adaptation of Processors: Application to Energy Reduction.
ISCA,
157-168,
2003.
Robert M. Senger,
Eric D. Marsman,
Michael S. McCorquodale,
Fadi H. Gebara,
Keith L. Kraver,
Matthew R. Guthaus,
Richard B. Brown,
A 16-bit mixed-signal microsystem with integrated CMOS-MEMS clock reference.
DAC,
520-525,
2003.
Rajiv A. Ravindran,
Robert M. Senger,
Eric D. Marsman,
Ganesh S. Dasika,
Matthew R. Guthaus,
Scott A. Mahlke,
Richard B. Brown,
Increasing the number of effective registers in a low-power processor using a windowed register file.
CASES,
125-136,
2003.
Basilio B. Fraguela,
Jose Renau,
Paul Feautrier,
David A. Padua,
Josep Torrellas,
Programming the FlexRAM parallel intelligent memory system.
PPOPP,
49-60,
2003.
Yun Ding,
Heiner Litz,
Rainer Malaka,
Dennis Pfisterer,
On Programming Information Agent Systems - An Integrated Hotel Reservation Service as Case Study.
MATES,
50-61,
2003.
José F. Martínez,
Jose Renau,
Michael C. Huang,
Milos Prvulovic,
Josep Torrellas,
Cherry: checkpointed early resource recycling in out-of-order microprocessors.
MICRO,
3-14,
2002.
Michael C. Huang,
Jose Renau,
Josep Torrellas,
Energy-efficient hybrid wakeup logic.
ISLPED,
196-201,
2002.
Michael C. Huang,
Jose Renau,
Seung-Moon Yoo,
Josep Torrellas,
The Design of DEETM: a Framework for Dynamic Energy Efficiency and Temperature Management.
J. Instruction-Level Parallelism
3,
2001.
Michael C. Huang,
Jose Renau,
Seung-Moon Yoo,
Josep Torrellas,
L1 data cache decomposition for energy efficiency.
ISLPED,
10-15,
2001.
Michael C. Huang,
Jose Renau,
Seung-Moon Yoo,
Josep Torrellas,
Energy/Performance Design of Memory Hierarchies for Processor-in-Memory Chips.
Intelligent Memory Systems,
152-159,
2000.
Michael C. Huang,
Jose Renau,
Seung-Moon Yoo,
Josep Torrellas,
A framework for dynamic energy efficiency and temperature management.
MICRO,
202-213,
2000.


Produced by Team in a Box Eclipe Metrics on Wed Jun 08 09:17:44 CDT 2005
|
| CC | LOCm | NOL | NOP | NOS | Line | Method | Type | Package |
|---|---|---|---|---|---|---|---|---|
| 3 | 24 | 3 | 1 | 14 | 12 | main(java.lang.String[]) | GameRunner | com.adaptionsoft.games.trivia.runner |
| 1 | 3 | 1 | 1 | 1 | 29 | rockQuestion(int) | Game | com.adaptionsoft.games.uglytrivia |
| 1 | 10 | 1 | 1 | 11 | 37 | add(java.lang.String) | Game | com.adaptionsoft.games.uglytrivia |
| 5 | 33 | 4 | 1 | 27 | 52 | roll(int) | Game | com.adaptionsoft.games.uglytrivia |
| 2 | 8 | 2 | 0 | 7 | 20 | Game() | Game | com.adaptionsoft.games.uglytrivia |
| 1 | 3 | 1 | 0 | 2 | 33 | isPlayable() | Game | com.adaptionsoft.games.uglytrivia |
| 1 | 3 | 1 | 0 | 2 | 48 | howManyPlayers() | Game | com.adaptionsoft.games.uglytrivia |
| 5 | 10 | 2 | 0 | 16 | 86 | askQuestion() | Game | com.adaptionsoft.games.uglytrivia |
| 10 | 12 | 2 | 0 | 19 | 97 | currentCategory() | Game | com.adaptionsoft.games.uglytrivia |
| 6 | 34 | 4 | 0 | 29 | 110 | correct() | Game | com.adaptionsoft.games.uglytrivia |
| 2 | 9 | 2 | 0 | 9 | 145 | wrongAnswer() | Game | com.adaptionsoft.games.uglytrivia |
| 1 | 3 | 1 | 0 | 1 | 156 | didPlayerWin() | Game | com.adaptionsoft.games.uglytrivia |
Produced by Team in a Box Eclipe Metrics on Wed Jun 08 09:17:44 CDT 2005


{%extends "layout.html" %} {% block content %}
pastable helps you to share tabular data — a few rows from Excel, Tableau data or a result from a SQL prompt — with others.


I collaborate with clients and peers to nurture and transform ideas into well thought out design specs. After all, that's where the majority of amazing user experiences start.
I sketch and wireframe interfaces focusing on content structure, intuitive UI patterns and simple interactions. I'm a minimalist who truly believes that less is more.
I design in the browser with HTML(5), CSS(3) and a touch of JavaScript. I love coding things from scratch, but I can work with front-end frameworks like Bootstrap too.
Travel smarter by saving the places you want to go. This project was an assignment given for an interview. The requirements were to build a web-app that calls the Google Places API. It must include a map with pins and a list of locations, with some interactivity between the two.
Travel smarter by saving the places you want to go. This project was an assignment given for an interview. The requirements were to build a web-app that calls the Google Places API. It must include a map with pins and a list of locations, with some interactivity between the two.
Travel smarter by saving the places you want to go. This project was an assignment given for an interview. The requirements were to build a web-app that calls the Google Places API. It must include a map with pins and a list of locations, with some interactivity between the two.
Travel smarter by saving the places you want to go. This project was an assignment given for an interview. The requirements were to build a web-app that calls the Google Places API. It must include a map with pins and a list of locations, with some interactivity between the two.
I'm currently accepting new projects and would love to hear about yours. Please take a few minutes to tell me about it.


Unit test report
History
0
Test report
Summary
Date
-
Total
-
Success
-
Fail
-
Skipped
-
Alert
Detail
Method
Result
Created
Event


@* * Copyright 2020 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import uk.gov.hmrc.disguisedremunerationfrontend.config.AppConfig @()(implicit request: Request[_],messages: UniformMessages[Html], appConfig: AppConfig) @uk.gov.hmrc.disguisedremunerationfrontend.views.html.main_template(title = messages("save-for-later.headinge").toString()) {
@messages("save-for-later.come-back")
@messages("save-for-later.complete-later")
@messages("save-for-later.gg-id")
}


JavaScript form validator Example:Checkbox and Radio button
- Password should not be same as user name (validator: "neelmnt")
- Confirm Password should be same as password (validator: "eqelmnt")
- The numbers should match this relation: large num > medium num > small num


--- title: Meetings (Archive) priority: 2 permalink: /meetings/ --- {% include modules/alert-workflow.html %} {% for sem in site.data.semesters.list %}
{{ site.data.sems[sem].desc }}
{{ unit.desc }}


This intention sorts literals (int and string) and enum constants.
It tries to preserve the number of expressions on the line, but in case of comments it is not always possible.


{% extends '_base.html' %} {% load crispy_forms_tags %} {% block title %}Order List{% endblock title %} {% block content %}
To delete a pending order, please first delete the order items in the order. Only an order without an order item can be deleted. To cancel an order that has been paid for, please send email to customer services and a member of our helpful staff will assist you with cancellation and arranging a refund.
Please note orders that have been dispatched can only be cancelled once the books are returned in its original package. A refund will take 5 working days to appear in your bank.


Color Palette
In this tutorial we’ll look defining a color palette or swatch that we’ll use for the elements in our game.
Paletton
There are lots of websites that will help you choose colors. One that I like is paletton. After some fiddling around I went with a Tetrad 4-color scheme that you can see here:
http://paletton.com/#uid=73d0u0k5qgb2NnT41jT74c8bJ8X
DawnBringer’s 16 Color Palette
Another palette that I ran across on the pixeljoint forums is DawnBringer’s 16 Color Palette. Read more about it here:
http://pixeljoint.com/forum/forum_posts.asp?TID=12795
Creating a Folder with Color and Swatch Classes
We are going to make two new classes called Colors.cs
and Swatch.cs
and they should be categorized under their own folder called Core.
You can accomplish this by right clicking on the project and choosing Add -> New Folder. Then right click on the folder and choose Add -> Class…
Do this for both Color.cs
and Swatch.cs
and your project should look something like the one below.
Swatch Class
RLNET lets you define colors with the RLColor
constructor taking the RGB values of the color as parameters as in RLColor myColor = new RLColor( red, green, blue );
In the Swatch class we’ll define friendly names for each of the colors from the palettes that we choose so that we don’t have to recall those RGB values.
In hindsight it might have made more sense to call this class Palette. Feel free to rename yours to whatever makes sense to you.
Add the following code to Swatch.cs
using RLNET;
namespace RogueSharpV3Tutorial.Core
{
public class Swatch
{
// http://paletton.com/#uid=73d0u0k5qgb2NnT41jT74c8bJ8X
public static RLColor PrimaryLightest = new RLColor( 110, 121, 119 );
public static RLColor PrimaryLighter = new RLColor( 88, 100, 98 );
public static RLColor Primary = new RLColor( 68, 82, 79 );
public static RLColor PrimaryDarker = new RLColor( 48, 61, 59 );
public static RLColor PrimaryDarkest = new RLColor( 29, 45, 42 );
public static RLColor SecondaryLightest = new RLColor( 116, 120, 126 );
public static RLColor SecondaryLighter = new RLColor( 93, 97, 105 );
public static RLColor Secondary = new RLColor( 72, 77, 85 );
public static RLColor SecondaryDarker = new RLColor( 51, 56, 64 );
public static RLColor SecondaryDarkest = new RLColor( 31, 38, 47 );
public static RLColor AlternateLightest = new RLColor( 190, 184, 174 );
public static RLColor AlternateLighter = new RLColor( 158, 151, 138 );
public static RLColor Alternate = new RLColor( 129, 121, 107 );
public static RLColor AlternateDarker = new RLColor( 97, 89, 75 );
public static RLColor AlternateDarkest = new RLColor( 71, 62, 45 );
public static RLColor ComplimentLightest = new RLColor( 190, 180, 174 );
public static RLColor ComplimentLighter = new RLColor( 158, 147, 138 );
public static RLColor Compliment = new RLColor( 129, 116, 107 );
public static RLColor ComplimentDarker = new RLColor( 97, 84, 75 );
public static RLColor ComplimentDarkest = new RLColor( 71, 56, 45 );
// http://pixeljoint.com/forum/forum_posts.asp?TID=12795
public static RLColor DbDark = new RLColor( 20, 12, 28 );
public static RLColor DbOldBlood = new RLColor( 68, 36, 52 );
public static RLColor DbDeepWater = new RLColor( 48, 52, 109 );
public static RLColor DbOldStone = new RLColor( 78, 74, 78 );
public static RLColor DbWood = new RLColor( 133, 76, 48 );
public static RLColor DbVegetation = new RLColor( 52, 101, 36 );
public static RLColor DbBlood = new RLColor( 208, 70, 72 );
public static RLColor DbStone = new RLColor( 117, 113, 97 );
public static RLColor DbWater = new RLColor( 89, 125, 206 );
public static RLColor DbBrightWood = new RLColor( 210, 125, 44 );
public static RLColor DbMetal = new RLColor( 133, 149, 161 );
public static RLColor DbGrass = new RLColor( 109, 170, 44 );
public static RLColor DbSkin = new RLColor( 210, 170, 153 );
public static RLColor DbSky = new RLColor( 109, 194, 202 );
public static RLColor DbSun = new RLColor( 218, 212, 94 );
public static RLColor DbLight = new RLColor( 222, 238, 214 );
}
}
Colors Class
Why do we have two classes for colors? What is the difference between the Swatch
class and the Colors
class? I thought that the Swatch
would make sense to just define the possible colors that we have to work with. Then when we define the color of something specific to our game’s domain like the Player’s symbol we can put that definition in the Colors
class. It might be that both the Player’s ‘@’ symbol and the text for the inventory both use a color from the swatch such as Swatch.DbLight
.
A nice benefit of keeping all of our Colors together is that if we want to change colors in the future we can come to this one place to change them and don’t have to dig all over in code to find colors spread throughout. We could also load different colors if we wanted a special colorblind mode.
Add the following code to Colors.cs
using RLNET;
namespace RogueSharpV3Tutorial.Core
{
public class Colors
{
public static RLColor FloorBackground = RLColor.Black;
public static RLColor Floor = Swatch.AlternateDarkest;
public static RLColor FloorBackgroundFov = Swatch.DbDark;
public static RLColor FloorFov = Swatch.Alternate;
public static RLColor WallBackground = Swatch.SecondaryDarkest;
public static RLColor Wall = Swatch.Secondary;
public static RLColor WallBackgroundFov = Swatch.SecondaryDarker;
public static RLColor WallFov = Swatch.SecondaryLighter;
public static RLColor TextHeading = Swatch.DbLight;
}
}
You’ll notice that the only colors that we have defined so far are for the Floor and Walls both when they are in Field-of-View and when they are not. We also defined a color for text headings.
Testing our Colors
To see if our colors are working as we expect lets go back to Game.cs
and find the OnRootConsoleUpdate()
method and substitute in our own colors.
// Remember to add the using for our new namespace to the top of the file
using RogueSharpV3Tutorial.Core;
private static void OnRootConsoleUpdate( object sender, UpdateEventArgs e )
{
_mapConsole.SetBackColor( 0, 0, _mapWidth, _mapHeight, Colors.FloorBackground );
_mapConsole.Print( 1, 1, "Map", Colors.TextHeading );
_messageConsole.SetBackColor( 0, 0, _messageWidth, _messageHeight, Swatch.DbDeepWater );
_messageConsole.Print( 1, 1, "Messages", Colors.TextHeading );
_statConsole.SetBackColor( 0, 0, _statWidth, _statHeight, Swatch.DbOldStone );
_statConsole.Print( 1, 1, "Stats", Colors.TextHeading );
_inventoryConsole.SetBackColor( 0, 0, _inventoryWidth, _inventoryHeight, Swatch.DbWood );
_inventoryConsole.Print( 1, 1, "Inventory", Colors.TextHeading );
}
If you run the game you should now see something like this:
This should look very familiar. That was quite a bit of work for only slightly different colors, but we’ll be using these colors for the rest of our game.
Code on GitHub
As always the code for the tutorial series so far can be found on GitHub:
Bored waiting for the next tutorial? The complete tutorial project is already finished and the source code is available on Github:
- Sample Roguelike game using RogueSharp and RLNet console
- Sample Roguelike game using RogueSharp and SadConsole
Closing Thoughts
I’m a little disappointed that throughout this post I refer to our color palettes but then when it comes to code I put the palettes in a class called swatch. I’m basically using two terms for the same thing.
When starting a new project it could be beneficial before coding to come up with a glossary for all of the objects of your game. Do you call them tiles or cells? Is it a grid or a map? Characters, Entities, Actors, Tokens, Figures… if you ever read any books on Domain Driven Design they recommend that you come up with a ubiquitous language that you use for both describing your domain (in this case our game) in both code and when speaking to others about it and then stick to it.


I believe that one should dedicate one’s life to a subject that makes them forget about time while practicing it. The process of solving math problems and designing algorithms completely absorbs me. I spend my free time trying to solve logic puzzles and learning about new things that I do not have the chance to study at university or when I am too impatient to wait for a course.
The summer I decided to study computer science, I had been learning Java on my own. In my sophomore year, I enrolled in the freeCodeCamp program to study web development. Soon, I developed an interest in machine learning. I started taking online courses to learn more about subjects like reinforcement learning, deep neural networks and natural language understanding and processing.
Because I started working on small projects early on, I managed to gain experience and employment in software development while studying in parallel. This job has given me the opportunity to work on exciting projects and also to conduct a lot of research. I had the chance to work with artificial neural networks and the RASA stack for building chat bots.
Working part-time and maintaining a good academic record has disciplined me and made me become even more organized and efficient. At the moment, I am learning more about machine learning and data science. I hope that one day I will contribute to building a machine learning platform or service myself.
This was one of the projects related to my previous job at OTB Expert. MicroDesk is a template processor. A computer program is built around a data model. We keep the data model in a JSON file. Then we inflate a seed project with that template. The result is a fully functional computer program.
Another game built as part of the FreeCodeCamp curriculum. It was initially built with jQuery and then converted based on the React framework.


Not just messaging and calls, you can add your own features and functionalities to Mesibo - powerful chatbots, filters, integrate with Machine learning and Scientific computing backend such as Tensorflow, Dialogflow, Matlab, etc. and much more.
Get Started with loadable modules using our ready-to-use open source modules!


Police release CCTV footage of man after worrying incident in Wishaw tower block
Officers are continuing to investigate an assault with intent to rob in Birkshaw Tower, Gowkthrapple.
by Ross ThomsonPolice have released CCTV footage of a man they wish to speak to in relation to an assault in a Wishaw tower block.
Officers are continuing to investigate an assault with intent to rob that occurred on Tuesday, April 30, at around 8.40am in Birkshaw Tower, Gowkthrapple.
A 67-year-old man and 54-year-old woman were threatened however no one was injured.
Officers believe that the man shown in the image may have information that could assist them and would appeal to anyone who recognises him to contact them.
Detective Constable David Duers, of Wishaw CID, said: “This was a frightening experience for the victims and our inquiries have been ongoing.
“If you have any information about this incident or can identify this man, please contact us on 101 quoting incident number 0650 of 30 April 2019 or anonymously via Crimestoppers on 0800 555 111.”


The basic command used when running the Stat/Transfer command processor is COPY, which has the following form:
COPY infilename.ex1 outfilename.ex2 -x1 -x2 ...
where infilename.ex1 and outfilename.ex2 are the input and output files, respectively and .ex1 and .ex2, are standard extensions used to determine the type of file that is read and written. The file names can be complete file specifications.
An alternative for specifying the file type is to use a file-type tag instead of a standard extension.
Parameters -xi following the file names allow some options to be selected, such as selecting tables and pages, optimization of variables or controlling messages from Stat/Transfer.
You can give additional commands before you give the COPY command. These allow you to select cases and variables, to manually change output variable types, to set a number of options and to use other commands. (Note that these commands can be given only at the Stat/Transfer prompt or in a command file or in a startup file. They cannot be used when running interactively from the operating system prompt.)
If no commands for selecting cases or variables are given, then by default, all of the variables and cases will be transferred.
For example, to copy all of the variables and all of the cases from an Excel file, indata.xls, to a SAS file, outdata.sas7bdat, type:
copy indata.xls outdata.sas7bdat
where the file type is given by using standard extensions.
Instead of entering commands directly, you can store them in a command file and execute that file at the Stat/Transfer prompt.
Wildcard Transfers
Wildcards can be used to copy multiple files in one transfer. For example:
copy in/*.dta out/*.sas7bdat
will convert all of the Stata files in the directory /in to SAS files in the directory /out.
Standard wildcards work in the input file ('?' and '*' ). The output filename should always be specified with an asterisk and will be consist of the input filename, with the new extension.
We recommend that you use wildcard specifications with an input directory that contains just the files you wish to transfer. To avoid the possibility of overwriting existing files or of being prompted about this possibility, the directory should be empty on the output side. You may also specify the '-y' parameter, to suppress prompting, but you should do so with extreme caution.


Motorcycle Trip Planning pt 1: The Basics
When going on an adventure, determining what is the adequate level of planning is the subject of much debate. For a long time I was on the “no plan is best plan” side of that debate, however the lead-up to my unfortunate aborted experience trying to cross the middle east has forced me to actually try more in depth planning for safety reasons. The extensive planning gave me a new appreciation for the value of planning any trip, no matter the length.
To communicate my approach to making trip plans, I will be putting out a few posts in this series to underlines my philosophy while planning, and the tools I use to make my trips easier.
Objectives of this guide
To prevent mission creep in the planning phase that would suck the fun out of exploring, it’s important to define what we want to achieve. This is what I am looking to get out of a planning a trip:
- Layout points of interest (POI), including points of origin and destination in a way that enhances your ability to navigate through your trip
- Gain familiarity with the general outline of the trip and acquire the confidence necessary to deviate from plans
- Provide pre-programmed optionality when faced with unforeseen circumstances, from road closure to catastrophic equipment failure or health conditions
- Produce trip documentation that is usable and intelligible to yourself, and potentially anybody else in case of emergency
All of this will be done with very basic, publicly accessible and free tools, mostly Google Earth.
Notice how none of the parts above has to do with meticulously planning stops and producing comprehensive documentation of every turn. It’s about laying out enough things on paper that you can intelligently make decisions about your whereabouts without having to rely on the rigid instructions of your electronic aids at any point.
We’ll be following this general process:
Step 0: Determine constraints
The first step in planning any trip is determining the constraints that you have to work with. Unless you are an old-money millionaire and can afford to gallivant about aimlessly for however long, your hardest constraints will probably be related to time and budget. Time is directly correlated to the distance you can cover. Budget is generally correlated to where you can stop to rest, eat or enjoy yourself.
Another set of relatively rigid constraints will relate to your equipment loadout, including both your bike and the equipment your intend to carry. Your bike has a maintenance schedule, and a fixed fuel capacity, hence max distance between fuel and maintenance stops. Similarly, you as a rider also have fuel and maintenance stops, in the form of food breaks and rest, both overnight and while on the road.
A more variable category of constraints, let’s call them punctual constraints, are broader incidents which may or may not have an impact on your trip. This may include weather events, road condition or closure, and any fortuitous or unfortuitous delays. By their nature they really cannot be predicted or avoided by planning, but thinking about such possibilities will help you elaborate options, should you encounter them.
It’s important to mention that the idea here is not only to avoid the worst, but also to give you a way to enjoy the spontaneous opportunities presented to you in your trip without messing up the rest of your plans. If you have a general idea of what being half a day late entails down the road, or where you could pick up the pace to catch up, it’s much less bothersome to stay in a place a bit off your path with a newfound friend.
Here’s a matrix that sums up our constraints. The list is in no way exhaustive, I welcome any useful additions (submit a PR on my blog’s Github repo).
|----------------------------------------------------------------------------------|
| | Nature of constraint |
|----------------------------------------------------------------------------------|
| Type of constraint | Gear | Rider |
|----------------------------------------------------------------------------------|
| Material | * Fuel range | * Total trip length (in days) |
| | * Maintenance schedule | * Frequency of rest stops |
| | * Road terrain | * Available / desired accommodation|
| | * Import requirements | * Visa availability / entry req. |
|----------------------------------------------------------------------------------|
| Punctual | * Breakdown | * Ill health |
| | * Road condition | * Weather conditions |
| |-------------------------------------------------------------|
| | * Bureaucratic mishaps |
| | * Ad-hoc opportunities and invitations |
|----------------------------------------------------------------------------------|
Material constraints should be clear before you leave. While I did not fully follow my own advice in my last middle east trip, I did due some basic points of due diligence during the break-in period of my Tenere, stuff like finding out what is maximum comfortable cruising speed, what is the fuel range to reserve and to empty, how long I could ride before needing a rest on both back roads and in town, etc. All my visas where also covered in advance for the entirety of my trip. Anything you forget to consider here is entirely on you… these material constraints, if not known, at least COULD have been known.
Step 1: Determine objectives
Unless your trip is an escape, you probably have at least some objectives, some theme. A few years back when I attended Mises Institute for in-person Mises U, I drove there in my car and took the opportunity to visit friends in Buffalo, NY and Akron, OH. Looking for a way to make this more fun, I made the theme of this trip “A Chicken Wing Pilgrimage”, and stopped by Atlanta, GA for some lemon-peppers. After this I stretched this definition a bit by going to Austin, TX for a month, because at the time I had relatively few time or budget constraints.
Here’s a non-exhaustive objectives you might set for yourself.
- People you want to visit
- Restaurants you want to eat at
- Tourist attractions you want to see
- Roads you want to ride
- Pictures you want to take
This is where I suggest you spend a significant part of your time planning. Having a lot of possible objectives is what will give you the choice of routes, and the choice of deviations from that route.
Step 2: Basic Mapping
This is where the planning part starts to become more concrete and visual. We’ll be firing up Google Earth and starting to make some lines on maps. Of course, this could also very well be done on paper maps and tracing paper or transparencies if you really want to go old-school.
I’ll give you a rough idea of how this step goes with a trip I am currently planning for next summer.
Step 2.a: Mapping constraints
We map out constraints because it will give use a rough visual indication of what is possible and what is not. Generally, start with the hardest constraints first, and work your way through the easier ones. In my case, departure and arrival are not optional. Take a look at the first map.
Between my point of departure and arrival, the first, completely straight line represents the “ideal” path between two destinations, not taking into account the curvature of the earth. Still a useful tool to get a rough idea of what a path could look like.
Due to the travel documents I have and the current geopolitical situation, it’s not really worth it for me to try to get into Kaliningrad or Belarus; they are represented by the red shaded polygons. This restriction brings me to draw a more realistic direct path, the white line that is broken at the Lithuania-Poland border.
Another of my big constraints is the amount of vacation time I have available. I don’t plan to take more than 3 weeks to get from point A to point B… is this realistic? The white squiggly line is the shortest path between Tallinn and Nice; as pictured, it measures 2817km. This is the minimum distance I am going to cover, not accounting for running around at any destination cities or actually enjoying myself. Let’s crunch some numbers.
| Target Pace | Very fast (600km/day) | Normal (400km/day) | Leisurely (200km/day) |
| Hours riding at 50km/h | 12 | 8 | 4 |
| Hours riding at 100km/h | 6 | 4 | 2 |
| Days on the road | 4.695 | ~7 | ~14 |
| Delta to max | 16.305 | ~14 | ~7 |
Even at an extremely slow pace, I have a week’s worth of overhead! Completely realistic. My pace numbers here are derived from real world experience. On my Tenere (long wheelbase, heavy, stable, full fairings, etc) 600+km/day is within the realm of possibility.
On the bike I am planning to take on this trip, 600km a day WOULD probably be torture. I’m talking about a Husqvarna Svartpilen 401, an inherently smaller, less wind protected, more buzzy single cylinder bike.
The bike is also going to be new, which means that it is going to need a break-in oil-change at around the 1000km mark. Despite the fact that I am going to do a hard break-in in Tallin on arrival (maybe 100km?), I still want to do another one at around the 1000km mark. Coincidentally, the shortest route from Tallinn to Warsaw is 982km on the shortest path… accounting for 25% of slack running around, this puts us just about at the Polish/Lithuanian border. Using a bit of artistic licence, we can draw a rough zone where I have to plan my oil change.
Of course, if we’re being honest I could do a 2 pint oil change pretty much anywhere… but I don’t necessarily want to. If possible, I would also want to have some sort of confirmation that I can get the filter wherever I decide to do it. For this reason I’ve decided to skip ahead and already add a waypoint in Kaunas, the largest city in Lithuania that more than likely has a Husqvarna dealer.
Step 2.b: Mapping objectives
We can now start adding objectives. In my case, these are in the form of cities that I want to visit, either because I have friends there (blue), because I still haven’t been there (red), or because it’s convenient and probably interesting. The visual cues helps define our order or priority.
Here’s our map so far.
This is enough for the first cycle of route tracing, and then going back to previous steps to add, remove or refine our constraints.
Step 3: Plan route
With our potential stops laid out, we are ready to start drawing some paths. I use “plan route” instead of map route because at this point we’re really just using available tools, mostly the Google Earth routing tool figure out routes to see if this makes sense.
This is more of an art than a science; you’re designing something that sounds fun, has stops you want to visit, and respects your constraints. Where you have choke points, think about branching out.
As you probably recall from 2.a, the most direct path between our departure and arrival points goes through Warsaw, Vienna, then north Italy… but I really want to go to Berlin! In this case, I’ll do a “German” route, by calculating shortest path between Berlin and Nice, then riffing on that.
This is suboptimal because I’ve done a lot of Germany and Switzerland already, and I’d much rather see Vienna. I also just remembered that I have a good friend that is around Prague most of the time… let’s adjust to reflect that.
Beautiful, although that detour through Berlin looks extremely long. It’s a good time to sanity check and make sure that we still fit into our constraints. This is where I usually try to find routes for the trip on a per-day basis, eyeballing what looks or feels like reasonable distance.
I am erring on the low side here because I really don’t want to be riding highway the whole way, and this is 100% of what these routes represent. In the next map, the days have been changed colours so as to make out different segments, and the lengths of the routes has been added to the folders containing them on the left.
With the distances as shown, we’re doing an average of 354km/day with the longest run being Warsaw to Berlin at a rather rough 574km of highway riding. If we cut this specific run in half with a stop in Poznan, we’re at 11 days, 322km/day, leaving us with 10 days of slack to do whatever we want with!
I also know from experience that the last two days could easily be condensed into one if they had too. This leaves us a lot of room to zoom in, and define routes that manually on interesting passages.
Step 4: Map the route
At this point, we could probably stop here and yolo it. Firstly, we have lots of slack with regards to time. Secondly, this is a trip through the eastern EU where we’re unlikely to encounter major setbacks that can’t be solved relatively quickly. We could most likely get away with putting our destinations into Google Maps on our phone every morning, highways and toll roads disabled, and follow the route. Our distance covered would likely increase by about 25%, our average speed would be lower, but we’d essentially be guarantee to find some cool stuff.
Any additional planning is really just refining the rough path that we already have, and maximizing whatever could happen in that trip. Since I have several months before departing, I’ll go ahead and map stuff out in detail anyways.
Since I’m using a scrambler bike for this trip, why not try it out on dirt? Some volunteers are already maintaining ready-made, very well annotated GPX files describing the Trans Euro Trail, and from the Youtube videos I could find most sections are relatively easy dirt and gravel roads that would be completely suitable for my bike. It’s probably not a good idea to try offroading before my break-in oil change is done, so let’s see what there is in Poland.
On the map above, the TET path in Poland relevant to me is in red. This is what I would call a properly mapped route, a turn-by-turn outline of the exact path you’re going to take, with annotated waypoints that include descriptions, warnings, etc. We really don’t need to put any more effort into this for my use case.
I’ve added a few stops along the way at shorter intervals since I obviously won’t be able to cover as much distance on dirty, and some escape paths (purple) from my planned stops in case the trails are too hairy to complete.
Step 5: Ride
Our full map now looks something like this.
What we have now is a perfectly actionable high level plan for a trip. What blanks need filling in can easily be filled in on the trip.
Next steps
To perfect this, we’d have to go through other cycles of defining and mapping out constraints and objectives on smaller portions of the trip; we’ll do this in the next posts, with increasingly sophisticated tools.
We’ll source data from various external sources, and get a bit tighter on the estimation of distances with isochrones and other cool open-source pieces of software.


Class BattleDemoSeligman
java.lang.Object
BattleDemoSeligman
public class BattleDemoSeligman
extends java.lang.Object
- Author:
- Josh Seligman
Purpose: This program simulates a game of the War card game.
Input: The program inputs the path for the file containing the information of the shuffled deck.
Output: The program outputs the summary of the game. The summary contains the number of cards in the deck, whether or not the game ended with a winner, the number of cards Player 1 ended with, the number of cards Player 2 ended with, and the winner of the game.
-
Field Summary
Fields Modifier and Type Field Description (package private) static java.util.Scanner
keyboard
The Scanner object for keyboard input -
Constructor Summary
Constructors Constructor Description BattleDemoSeligman()
-
Method Summary
Modifier and Type Method Description static CardSeligman
compareCards(CardSeligman card1, CardSeligman card2)
Compares two cards and determines the winning cardstatic int
countCards(StackSeligman stack)
Counts the number of cards in a stackstatic int
deal(java.lang.String filePath, StackSeligman p1, StackSeligman p2)
Deals the deck out to the 2 playersstatic void
main(java.lang.String[] args)
The main method for the gamestatic boolean
moveDiscardToPlay(StackSeligman discardDeck, StackSeligman playDeck)
Moves cards from discard pile back to the play pilestatic CardSeligman
playCard(StackSeligman playerStack)
Plays the next card in the stackstatic void
printResults(int numCards, int numPlays, StackSeligman p1PlayDeck, StackSeligman p1DiscardDeck, StackSeligman p2PlayDeck, StackSeligman p2DiscardDeck)
Prints the results of the gamestatic void
tiePlay(StackSeligman cardStack1, CardSeligman card1, StackSeligman cardStack2, CardSeligman card2)
Places the cards into the discard stack of the appropriate playerstatic void
winningPlay(StackSeligman cardStack, CardSeligman winningCard, CardSeligman losingCard)
Adds the cards to the winning deckMethods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
-
Field Details
-
keyboard
static java.util.Scanner keyboardThe Scanner object for keyboard input
-
-
Constructor Details
-
BattleDemoSeligman
public BattleDemoSeligman()
-
-
Method Details
-
deal
Deals the deck out to the 2 players- Parameters:
filePath
- The path of the file to read that contains the information of the deckp1
- Player 1's stack of cardsp2
- Player 2's stack of cards- Returns:
- The number of cards in the deck, Integer.MAX_VALUE if an error occurs
-
playCard
Plays the next card in the stack- Parameters:
playerStack
- The stack to take the card from- Returns:
- The card being played
-
compareCards
Compares two cards and determines the winning card- Parameters:
card1
- The first card to comparecard2
- The second card to compare- Returns:
- The winning card, null if tie
-
winningPlay
public static void winningPlay(StackSeligman cardStack, CardSeligman winningCard, CardSeligman losingCard)Adds the cards to the winning deck- Parameters:
cardStack
- The stack to add the cards towinningCard
- The winning card from the roundlosingCard
- The losing card from the round
-
tiePlay
public static void tiePlay(StackSeligman cardStack1, CardSeligman card1, StackSeligman cardStack2, CardSeligman card2)Places the cards into the discard stack of the appropriate player- Parameters:
cardStack1
- The discard stack of the first playercard1
- The card played by the first playercardStack2
- The discard stack of the second playercard2
- The card played by the second player
-
moveDiscardToPlay
Moves cards from discard pile back to the play pile- Parameters:
discardDeck
- The discard deck to empty outplayDeck
- The stack to copy the discard stack over to- Returns:
- Whether there are cards left in the discard prior to calling the method
-
countCards
Counts the number of cards in a stack- Parameters:
stack
- The stack to count the cards for- Returns:
- The number of cards in the stack
-
printResults
public static void printResults(int numCards, int numPlays, StackSeligman p1PlayDeck, StackSeligman p1DiscardDeck, StackSeligman p2PlayDeck, StackSeligman p2DiscardDeck)Prints the results of the game- Parameters:
numCards
- The total number of cards in the decknumPlays
- The number of rounds playedp1PlayDeck
- The play deck for Player 1p1DiscardDeck
- The discard deck for Player 1p2PlayDeck
- The play deck for Player 2p2DiscardDeck
- The discard deck for Player 2
-
main
public static void main(java.lang.String[] args)The main method for the game- Parameters:
args
- The method arguments
-


Some of the Most Common Sides and Snacks of Chiclayo:
Cancha:known as the Peruvian version of "Corn Nuts", this common snack is made from a type of corn called "maiz chulpe". When the kernels are heated, the inside does not burst out like popcorn, but the kernel becomes puffy and toasted, leaving it with a crunchy, starchy taste. Served lightly-salted, cancha is frequently served before meals or alongside ceviche, and can be quite the addicting snack!
| Causa Rellena con Pollo (Chicken salad with yellow potatoes) |
| During Peru's Colonial Period, many of the native Peruvian foods were combined with foods brought over from Europe, creating the unique Peruvian cuisine that we see today. Causa Rellena con Pollo is one of these hybrid dishes! It is a popular summer dish that layers mashed potatoes flavored with lime juice and aji pepper, with chicken salad. These layers are typically in the form of a rectangle, with olives, cilantro, and slices of hard-boiled eggs placed on top. This typical dish is served cold, and is an interesting yet delicious mix of flavors found in the region. |
| Ceviche |
| Ceviche is one dish that you CANNOT leave without trying! It involves chunks of raw fish "cooked" with acid citrus juices (like lemon and lime), served with onions, and often spiced with aji or chili peppers. There are many different types of ceviche, with the most popular being shrimp, octopus, sea bass, and mixed (containing a variety). As the acidic juice does not cook the fish as well as heat does, it is important to eat at trustworthy locations to ensure that the fish is fresh. Dating back to the Incan time period, ceviche is a food that has been around for a long time, and is boasted about by the local people! |
| Humitas (Corn Tamales)) |
| Savory "cakes" made of freshly-ground corn, salt, and queso fresco. There are many different variations of these– some of the more savory versions contain meat, and some of the sweeter versions contain ingredients like cinnamon and raisins. They are usually steamed or boiled, then wrapped in corn husks and served. |
| Papa la Huancaína (Potatoes with cheese sauce and spices) |
| This is another very popular dish in Peru, and is a staple for the local people. It includes a creamy, spicy yellow sauce called Huancaína poured over boiled yellow potatoes. It is complete with slices of hard-boiled egg, an olive, and lettuce. |
| Choclo |
| This corn, commonly called Peruvian corn or Cuzco corn, is a large-kennel corn that comes from the Andes. The kernels are chewier, starchier, and less sweet than other types of corns, and it is commonly served as a side to ceviche and other appetizers or entrees. |
| Anticuchos |
| Skewers of meat commonly flavored with garlic, aji, cumen, or other such spices. Though it can contain any type of meat, the most common is beef heart. You will often finds vendors grilling these on the streets, though we advise you consume with caution, as the meat could be spoiled! |
| Chifle |
| Chifle consists of thinly-sliced bananas that are fried and lightly salted. They are often sold by street vendors and corner stores, and resemble potato chips. |


--- layout: post title: Oracle Synonym --- fell embarrassedly -_-!! date: 2007-11-28 22:08:05.000000000 +10:30 type: post published: true status: publish categories: - Oracle tags: - oracle meta: posturl_add_url: 'yes' _edit_last: '1' ---
I feel very embarrassedly, when I konw the mean of the Oracle Synonym. Because I confused by the table which not contain in our DB, bu I can select/insert/update the data in the table. Then I found the table in another db. I really confused by that. This table used a synonym for table by dblink.
This is what I found in the Web.
---------------------------------------------------------------------------------------------------------
问题描述：
有两个oralce数据库
SID分别为 A B
A中a用户下含有表objects
B中含有b用户
使在B中用b用户登录后执行
select * from objects
能显示出A中a.objects的全部内容
问题解答：
用b用户登录到B中，执行：
create public synonym objects for a.objects@A
此时执行select * from objects 就能显示出a.objects的全部内容
需要注意的一点：
B中不能含有table b.objects否则语句可以执行，但是执行select操作时显示的仍然为b.objects的内容，需要先把b.objects删除掉，重新建立synonym即可。
-------------------------------------------------------------------------------------------------------------
A synonym is an alias for a schema object. Synonyms can provide a level of ecurity by masking the name and owner of an object and by providing location transparency for remote objects of a distributed database. Also, they are convenient to use and reduce the complexity of SQL statements for database users.
Synonyms allow underlying objects to be renamed or moved, where only the synonym needs to be redefined and applications based on the synonym continue to function without modification.
You can create both public and private synonyms. A public synonym is owned by the special user group named PUBLIC and is accessible to every user in a database.
A private synonym is contained in the schema of a specific user and available only
to the user and the user’s grantees.


guillermo{at}guerreroibarra{dot}com
Follow me on github: https://github.com/ryanfox1985
Alejandro Garcia
Follow me on github: https://github.com/agrcrobles
November 2nd, 2017
An open source, cross-platform framework for building native mobile apps with JavaScript and React using declarative components.
aaaa
bbbb


This test passes if both of the circles have sharp edges.
To run manually, use full-page zoom to increase the page scale factor.


React is the top winner in the Trending Tech on Stack Overflow. It also scores high on several other categories including Top Paying Tech, Most Loved and Wanted Technologies. So without a doubt React is hot technology. If you are a frontend developer, or want to become one, you are wise to learn about React.
React is the user interface library build at Facebook to develop the Facebook website. Instead of keeping React internal Facebook decided to open source it. The result is that the whole world can enjoy React. Many companies like Airbnb, DropBox, Netflix and Uber do. The list of sites build with React is impressive. And now it is your turn to join that list.
Lots of people use React as the V in MVC. Since React makes no assumptions about the rest of your technology stack, it's easy to try it out on a small feature in an existing project.
Most open source software innovates faster and has a better quality. Because React is open source you can fix issues yourself without waiting if you want to. React also has a large and active community of passionate developer around it.
My name is Maurice de Beijer and I really love programming and teaching others how to program.
Maurice is a great instructor - very knowledgeable and enthusiastic. Very patient with all my questions!
Very knowledgeable and enthusiastic.
Excellent all round knowledge of subject matter.
Maurice was able to demonstrate real world examples and it was evident he wasn't just dictating what he had read in books but speaking from the practical experience.
I really liked how the course was organised and that Maurice showed us real world example, wrote code in front of us, and made the whole course really practical. Thank you, Maurice! I would be glad to be your student once again.
Maurice is a good instructor - very knowledgeable and friendly.
Maurice is really good and gives good demonstrations of the concepts being discussed.


@adaptive_action This really is not a problem. In normal financial transactions, if your bank says transaction is being processed and it is taking a long time then that is a problem. But here you can verify that your address has the expected amount of funds in both your own agama wallet and in a block explorer which are the reliable sources of information.  Their servers might have been busy or buggy. As long as you only you control the private key of an address, only you own the funds in it, irrespective of binance website shows.
Regarding confirmations: It is the number of blocks that have been added on top of the block which had your transaction. Therefore the more confirmations your agama is showing, the more secure your funds have become. This is also not a problem with KMD(because of dPOW). The number of confirmations in agama is increasung because that is how blockchains work.


Home
About
Gallery
Contact
Teachers
VISHWAKARMA SR. SECONDARY SCHOOL
CONTACT US
Get in Touch
contact us for more information
NAME
Email address
subject
Message
Enter Your message
call on
9761142004,<PHONE_NUMBER>
links
youtube
facebook


Here you will find the demos that go with the slides for my talk.
Code is here: GitHub repo.
You'll need the Firefox WebVR build or the Chromium WebVR build.
All the demos are much better with the positional tracker.
You can find more info at webvr.info.
Jaume Sánchez @thespite | clicktorelease.com


Voted Poll Title
Results
{{ poll.name }}
{{value}}:
{{poll.results[key]}}
Home
Back to Polls
Give us feedback


|
Pallas Solver
0.1
C++ Global Optimization Algorithms
|
#include <basinhopping.h>
Public Member Functions | |
| Options () | |
| Default constructor. More... | |
| void | set_step_function (scoped_ptr< StepFunction > &user_step_function) |
| Convenience function for changing the default step function. More... | |
Public Attributes | |
| GradientLocalMinimizer::Options | local_minimizer_options |
| scoped_ptr< StepFunction > | step_function |
| unsigned int | max_iterations |
| unsigned int | max_stagnant_iterations |
| double | minimum_cost |
| bool | is_silent |
| unsigned int | history_save_frequency |
Configurable options for modifying the default behaviour of the basinhopping algorithm.
|
inline |
Default constructor.
This tries to set up reasonable defaults for optimization. It is highly recommended that the user read and overwrite the defaults based on the cost function.
|
inline |
Convenience function for changing the default step function.
This function simply swaps the scoped_ptr to the user defined StepFunction
with the scoped_ptr to the StepFunction
held within the pallas::Basinhopping::Options
struct.
| user_step_function | pallas::scoped_ptr<pallas::StepFunction>. This function generates randomized candidate solutions based on the current position. |
| unsigned int pallas::Basinhopping::Options::history_save_frequency |
Frequency to save the state of the system. Values will be appended to a HistorySeries
contained in the optimization summary. Default is 0. If 0 then history is not saved. Otherwise, the state of the system will be appended to the series when i % history_save_frequency == 0
. If there are a large number of iterations this can lead to a lot of data being stored in memory.
| bool pallas::Basinhopping::Options::is_silent |
Whether to log failure information relating the to global optimization algorithm using glog.
| GradientLocalMinimizer::Options pallas::Basinhopping::Options::local_minimizer_options |
Contains any changes to the default options for the local minimization algorithm. See the documentation for ceres::GradientProblemSolver::Options for relevant options
| unsigned int pallas::Basinhopping::Options::max_iterations |
Maximum number of basinhopping iterations.
| unsigned int pallas::Basinhopping::Options::max_stagnant_iterations |
Maximum number sequential basinhopping iterations allowed without finding a new global minimum.
| double pallas::Basinhopping::Options::minimum_cost |
User specified minimum cost. Minimization will halt if minimum_cost
is reached.
| scoped_ptr<StepFunction> pallas::Basinhopping::Options::step_function |
Function that produces randomized candidate solutions.


Turtle Island Fiji is a stunning, 500-acre privately owned island—the ultimate vacation resort perfect for honeymoons, anniversaries, weddings, vow renewals or even to rent your own private island. We accommodate just 28 guests at a time. Each of our 14 bures (exquisite hand-crafted Fijian villas) are nestled along the famous “Blue Lagoon” and are separated from each other by generous expanses, meaning you’ll have your own slice of exotic island paradise.
500 acres, located in the Yasawas in Fiji
Privately owned, giving you complete run of the island
14 light-filled bures (Fijian villas) situated on the glistening Blue Lagoon
Numerous white beaches fringe the island, each appointed with beach bure and hammock for relaxing solitude
Exquisite wines paired with Pacific-Rim cuisine prepared from just-caught seafood and 5 acres of lovingly tended gardens
Plenty of time for play with water sports or hikes
Spa to revive your body, and your soul
Thriving natural environment, with power harvested from our solar farm
Cultural haven for the Fijian way of life, centered in ancient values of respect and joy
The perfect place to be in love, or fall in love all over again


The ABS-CH is established as part of the clearing-house mechanism (CHM) of the Convention. The CHM (http://chm.cbd.int) has been developed as a single and unified platform which also supports the dedicated clearing-houses of the Cartagena Protocol on Biosafety (BCH) and the Nagoya Protocol (ABS-CH). You can access all clearing-houses with the same CBD account that you can get from (http://accounts.cbd.int).
However, each of the clearing-houses has a dedicated portal for searching and registering information in order to respond to the specific needs of the Parties with regards to implementation of the different treaties.
The CHM of the Convention was established in accordance with Article 18(3) of the Convention to promote and facilitate technical and scientific cooperation on all biodiversity issues. The ABS-CH, on the other hand, was established under Article 14 of the Nagoya Protocol with a special focus on the information that must be exchanged under the Protocol. The ABS-CH plays a key role in supporting implementation of the Protocol by contributing to transparency and certainty on procedures for access and monitoring of the utilization of genetic resources. Because of this role, the ABS-CH has some characteristics, features and functions which are specific to this portal.
Another major difference between the CHM and the ABS-CH is that, with regards to the latter, Article 14 of the Protocol enumerates a variety of categories of information which Parties to the Protocol are legally obliged to provide through the ABS-CH. There are no such legal requirements for Parties to the Convention to make information available through the CHM.
Common formats and rules of operation need to be compatible and, where possible, harmonized across the clearing-houses. The common formats developed for the ABS Clearing-House make use, as much as possible, of predefined text or controlled vocabularies that are compatible with the controlled vocabularies of the CHM and the BCH.


Give your website a name. This is also the name which will be shown on the home page of your website.
What is your email-address? With this email-address you are allowed to login on the admin console. This email-address is also used when you forgot your password.
To protect the admin console, you have to enter a password.
Please, repeat the password again to make sure it is correct.


Enter username:
Get Email for further instructions
Modal Title
An image can appear on left or an icon
A description can appear on the right
Cancel
OK


Users install the Browser extension to view the ratings and review for the websites/domain.
Also they have the option to submit votes for websites of their choice.
Welcome Screen: Similar to splash screen
Intro Screens: Introduces NetSepio functionalities & benefits
Home Screen: Helps users get the information related to the website they are surfing
Vote: Helps user with submitting a vote for a website after getting the voter role
Settings:
Language: Change extension default language
Wallet - Create/Import wallet with 24 words seed phrase
Profile - Update Profile Details