We design a Fluent class hierarchy which includes first-class stateful objects representing the meta-level Horn Clause Interpreters, file, URL, socket Readers and Writers, as well as composable data structures, with high-level operations mapped to efficent iterative constructs in the underlying implementation language.
Fluents melt naturally in the fabric of Logic Programming languages and can be implemented to recover resources on backtracking or to persist. Their expressiveness is shown by redesigning key components of Prolog's system of built-in predicates and through examples of interoperation with the underlying Java system used as an implementation language.
The Web site of our Kernel Prolog prototype, http://www.binnetcorp.com/kprolog/Main.html allows the reader to try out online the examples discussed in this paper and shows the extressivenes of Kernel Prolog and its extensibility through new Java based built-ins for building a GUI toolkit.
Keywords: Logic Programming Language Design and Implementation, Interoperation of Declarative and Stateful Languages, Meta-Programming and Reflection
Despite significant syntactic, semantic and implementational variations, Logic Programming languages share a common kernel: Horn Clause Resolution1, a semantically and operationally well understood calculus. As it is the case with pure functional programming languages, this calculus allows reasoning with referentially transparent, stateless entities. The code itself can be seen as a set of declarations (equations in Functional Programming and implications in Horn Clause Resolution) from which answers to a query are derived through a uniform, step by step proof process.
However, the resolution process as such, is obviously not stateless, as it proceeds in time, step by step. If we want to preserve the ability to reflect in the object language the resolution process provided by the underlying ''glass-box'' interpreter, in its full generality, we suddenly face the need of stateful primitives. Evolving algebras [8] and abstract recursive state machines [9] have shown that programming languages can be seen as a combination of a basic, terminating step and some form of iterative closure operation. Linear logic [7,1,13] has provided a more accurate description of the state of the proof process, with emphasis on seeing formulas as resources, with special notation indicating if they are unique or reusable. Independently, the same needs arise for interoperation of declarative languages with conventional software and operating system services which often relay on stateful entities.
Through constructs ranging from plain file or socket streams in C, to lazy list streams in languages like Scheme, iterators in Java or C++, monadic constructs [15,28,29,3] in Haskell or in l-Prolog, declarative I/O in Mercury [20], the need for abstracting away the nature of the stepping process in a (finite or infinite, actual or generated as needed) sequence. Moreover, in the case of a declarative language implmented in a procedural or object oriented language, a uniform reflection mechanism is needed, for consistent modeling of stateful external objects providing native services.
This paper will introduce a concept of first class fluents on top of Horn Clauses with LD-Resolution to provide reflection of the underlying glass-box interpreter and interoperation with external stateful components, in a uniform way.
We describe a set of Fluent constructors which create Fluents from conventional data structures like lists, strings, files, terms and clauses and then provide Fluent Composers - allowing to elegantly combine them as building blocs for software components. When seen from inside an Interpreter, other Interpreters will appear as instances of Fluents (Sources) producing a stream of answers. Through a set of suitable abstractions, they will be put to work as reusable components cooperating through independent resolution processes.
While the semantics of a fluent-enabled, multi-interpreter programs cannot be expressed in a trivial way in terms of one-interpreter Horn Clause LD-resolution, their operational semantics reuses common programming knowledge as basic as reading a sequence from a file or using an iterator. Our design ensures that the usual declarative semantics covers each LD-resolution interpreter while the more powerful Fluent manipulation language is kept as an orthogonal meta-level component.
As a practical outcome, we provide a complete redesign of Prolog's built-ins which can be of use in the next iteration of the ISO Prolog standardization process.
A compact Java based reference implementation, (downloadable and testable online at http://www.binnetcorp.com/kprolog) illustrates in more detail the ideas described in this paper and provides a first draft of an Open Source executable specification of Kernel Prolog.
We will build Kernel Prolog as a collection of Horn Clause Interpreters running LD-resolution on a default clause database and calling built-in operations. Each of them has a constructor which initializes them with an goal and an answer pattern. They are in fact possibly infinite sources of answers which can be explored one by one. The object encapsulating the state of the interpreter is very similar to a file descriptor encapsulating the state of a file reader. We will call such stateful entities evolving in time Fluents.
Kernel Prolog Interpreters will possess, through built-in calls, the ability to create and query other Interpreters, as part of a general mechanism to a manipulate Fluents, external stateful objects with independent life-cycles.
This general mechanism will also allow Kernel Prolog interpreters to interoperate with the underlying object oriented implementation language.
We will start with an overview of the Fluent class, some simple Fluent examples and operations on Fluents.
Fluents are created with specific constructors, usually by converting from other Fluents or conventional Prolog data structures like Terms, Lists or Databases. 2. All Fluents are enabled with a stop/1 operation which releases their resources (most Fluents also call stop/1 on backtracking, through their internal undo operation).
In our Java based reference implementation, the Fluent class looks as follows:
class Fluent extends SystemObject {
Fluent(Prog p) {
trailMe(p);
}
// add the fluent to the parent Interpreter's Trail
protected void trailMe(Prog p) {
if(null!=p) p.getTrail().push(this);
}
// usable (through overriding) to release resources
// and/or stop ongoing computations
public void stop() {
}
// release resources on backtracking, if needed
protected void undo() {
stop();
}
}
Sources are Fluents enabled with an extra get/2 operation. Typical Sources are Horn Clause Interpreters, File, URL or String Readers, Fluents built form Prolog lists, Fluents iterating over data structures like Vectors or Hashtables or Queues in the underlying implementation language.
Note that the constructor Fluent(Prog p) does a trailing operation on the caller program p's Trail, and provides and undo operation to be called by p on backtracking, to release resources through the Fluent's stop method.
In our Java based reference implementation the Source abstract class looks as follows:
abstract class Source extends Fluent {
Source(Prog p) {
super(p);
}
abstract public Term get();
}
Sinks are fluents enabled with an extra put/2 and collect/2 operation. Typical Sinks are ClauseWriters or CharWriters targeted to TermCollectors (implemented as a Java Vectors collecting Prolog terms), StringSinks (implemented as a Java StringBuffers collecting String representations of Prolog terms), Files.
In our Java based reference implementation the Sink abstract class looks as follows:
abstract class Sink extends Fluent {
Sink(Prog p) {
super(p);
}
// sends T to the Sink for tasks as
// accumulation or printing
abstract public int put(Term T);
// return data previously sent to the Sink
// (if collection ability is present)
public Term collect() {
return null;
}
}
Not surprisingly, even Prolog databases are first class citizens implemented as extensions of Sources which provide add/2, remove/2, collect/2 operations.
Fluents can be seen as resources which go through state transitions as a result of put/2, get/2 and stop/1 operations. They end their life cycle in a stopped state when all the data structures and/or threads they hold are freed.
Fluent composers provide abstract operations on Fluents. They are usually implemented with lazy semantics.
For instance, append_sources/3 creates a new Source with a get/2 operation such that when the first Source is stopped, iteration continues over the elements of the second Source.
Compose_sources/3 provides a cartesian product style composition, the new get/2 operation returning pairs of elements of the first and second Source.
Reverse_source/2 builds a new Source such that its get/2 method returns its elements in reverse order.
Split_source/3 creates two Source objects identical to the Source given as first argument. It allows writing programs which iterate over a given Source multiple times.
Sources and Sinks are related through a discharge(Source,Sink) operation which sends all the elements of the Source to the given Sink.
Fluent modifiers allow dynamically changing some attributes of a give Fluent. For instance set_persistent(Fluent,YesNo) is used to make a Fluent survive failure, by disabling its undo method, which, by default, applies the Fluent's stop method on backtracking.
Let us put to work in a more specific way the view of Interpreters as Fluents in a redesign of Prolog on top of Horn Clauses with LD-resolution. All we have to provide is a Fluent constructor, creating an Answer Source from an Answer Pattern and a Goal given to an Interpreter. As a result, we will cover negation, limited pruning through once/1, if-then-else/3, findall/3, var/1, and, beyond standard Prolog, forms of lazy, on-demand generation of sets of solutions, as well as a uniform set of built-ins for manipulation of first class Prolog databases and external objects like Files or URLs.
Answer Sources can be seen as generalized iterators, allowing a given program to control answer production in another. Each Answer Source works as a separate Horn Clause LD-resolution interpreter (a very compact Java implementation of such an interpreter is given in the APPENDIX).
The Answer Source constructor initializes a new interpreter.
answer_source(AnswerPattern,Goal,AnswerSource)
creates a new Horn Clause solver, uniquely identified by AnswerSource (a Source Fluent), which shares code with the currently running program and is initialized with resolvent Goal. AnswerPattern is a term, usually a list of variables occurring in Goal.
The get/2 operation (provided by all Sources) is used to retrieve successive answers generated by an Answer Source, on demand.
get(AnswerSource,AnswerInstance)
tries to harvest the answer computed starting from Goal, as a instance of AnswerPattern. If an answer is found it is returned as the(AnswerInstance), otherwise no is returned. Note that once no has been returned, all subsequent get/2 on the same AnswerSource will return no. Bindings are not propagated to the original Goal or AnswerPattern when get retrieves an answer, i.e. AnswerInstance is obtained by first standardizing apart (renaming) the variables in Goal and AnswerPattern, and then backtracking over its alternative answers in a separate Prolog interpreter. Therefore, backtracking in the caller interpreter does not interfere with the new Answer Source's iteration over answers. Note however that backtracking over the Answer Source's creation point as such makes it unreachable and therefore subject to garbage collection.
Finally, an Answer Source is stopped with the stop/1 operation implemented by
all Sources.
stop(AnswerSource)
The stop/1 operation is called automatically when no more answers can be produced as well as through the Fluent's undo operation on backtracking.
To give a glimpse to the expressiveness of the resulting language, we will know introduce, through definitions in Kernel Prolog, a number of predicates known as `impossible to emulate' in Horn Clause Prolog (except by significantly lowering the level of abstraction and implementing something close to a Turing machine).
These constructs are implemented simply by discarding all but the first solution produced by a Solver.
% returns the(X) or no as first solution of G
first_solution(X,G,Answer):-
answer_source(X,G,Solver),
get(Solver,R),
stop(Solver),
eq(Answer,R).
% succeeds by binding G to its first solution or fails
once(G):-first_solution(G,G,the(G)).
% succeeds without binding G, if G fails
not(G):-first_solution(_,G,no).
The simplest meta-interpreter metacall/1 just reflects backtracking through element_of/2 over deterministic Answer Source operations.
metacall(Goal):-
answer_source(Goal,Goal,E),
element_of(E,Goal).
element_of(I,X):-get(I,the(A)),select_from(I,A,X).
select_from(_,A,A).
select_from(I,_,X):-element_of(I,X).
We can see metacall/1 as an operation which fuses two orthogonal language features provided by Answer Sources: computing an answer of a Goal, and advancing to the next answer, through the source level operations element_of/2 and select_from/3 which 'borrow' the ability to backtrack from the underlying interpreter.
Note that element_of/2 works generically on Sources and is therefore reusable, for instance, to backtrack over the character codes of a file or a URL.
After showing that we can emulate metacalls, we will use, for convenience, variables directly in predicate call position.
Note that an Answer Source enumerates over the transitive closure of a clause unfolding relation [24,25]. If our interpreter can access a single unfolding step through a similar Fluent, a finer grained meta-interpreter can be built. First let's introduce a new Fluent,
unfolder_source(Clause,Source)
which, given a Clause produces a stream of clauses obtained by unfolding the first atom on the right side against a matching clause in the database. Each step is described through an (associative) clause composition operation Å as follows:
Let A0:-A1,A2,...,An and B0:-B1,...,Bm be two clauses (suppose n > 0, m ³ 0). We define (A0:-A1,A2,...,An) Å (B0:-B1,...,Bm) = (A0:-B1,...,Bm,A2,...,An)q
with q = mgu(A1,B0). If the atoms A1 and B0 do not unify, the result of the composition is denoted as ^ (failure). Furthermore, we consider A0:-true,A2,...,An to be equivalent to A0:-A2,...,An, and for any clause C, ^ Å C = C Å ^ = ^. As usual, we assume that at least one operand has been renamed to a variant with variables standardized apart.
We can now build a meta-interpreter which implements the transitive closure of the unfolding operation Å (provided as the get/2 operation of an Unfolder Source in the underlying implementation language), combined with backtracking trough element_of/2.
unfold_solve(Goal):-
unfold(':-'(Goal,Goal),':-'(Goal,true)).
unfold(Clause,Clause).
unfold(Clause,Answer):-
unfolder_source(Clause,Unfolder),
element_of(Unfolder,NewClause),
unfold(NewClause,Answer).
Once we have first solution and metacall operations, emulating if-then-else is easy.
% if Cond succeeds executes Then otherwise Else
if(Cond,Then,Else):-
first_solution(successful(Cond,Then),Cond,R),
select_then_else(R,Cond,Then,Else).
select_then_else(the(successful(Cond,Then)),Cond,Then,_):-Then.
select_then_else(no,_,_,Else):-Else.
All-solution predicates like findall/3 can be obtained by collecting answers through recursion.
% if G has a finite number of solutions
% returns a list Xs of copies of X each
% instantiated correspondingly
findall(X,G,Xs):-
answer_source(X,G,E),
get(E,Answer),
collect_all_answers(Answer,E,Xs).
% collects all answers of a Solver
collect_all_answers(no,_,[]).
collect_all_answers(the(X),E,[X|Xs]):-
get(E,Answer),
collect_all_answers(Answer,E,Xs).
Note that, again, the collect_all_answers operation is generic, and works on any Source. This suggest providing a built-in Source-to-List converter source_list/2 which can be made more efficient in the underlying implementation language. The alternative definition of findall/3 becomes simply:
findall(X,G,Xs):-
answer_source(X,G,Solver),
source_list(Solver,Xs).
% creates a copy of G with variables uniformly
% substituted with new variables not occurring
% in the current resolvent)
copy_term(X,CX):-first_solution(X,true,the(CX)).
% true if X is currently a free variable
var(X):-copy_term(X,a),copy_term(X,b).
The previous definitions have shown that the resulting language subsumes (through user provided definitions) constructs like negation as failure, if-then-else, once, copy_term findall - this justifies its name Kernel Prolog. As Kernel Prolog contains negation as failure, following [6] we can, in principle, use it for an executable specification of full Prolog.
With these additions, it turns out that Kernel Prolog is a fairly expressive language. Unlike pure Horn Clause Prolog and unlike weaker languages based on Prolog + negation, which have been extensively studied in the past, Kernel Prolog has enough power to be used as a basis for building compact Prolog implementations as well as for modular library components.
While providing a formal semantics of Kernel Prolog needs more research and it might need methods beyond the techniques used for less expressive logic languages, let us give a sketch of the issues involved.
Note that Kernel Prolog is a superset of Horn Clauses with a form of metacall facility. Related semantic issues have been studied [30,11] and are now fairly well understood.
Like in the case of findall/3, solutions returned by Answer Source contain new variables. As such, their formal description cannot be covered through a straightforward adaptation of work like [14,2]. The issues are in fact similar with those involved in describing formally AND-parallel execution of Prolog programs [19,16], with resolution theory needing to be adapted to deal with separate computations of answers within the same AND-branch.
Clearly, the three new builtins answer_source/2, get/2, stop/1 added to Horn Clause Prolog lack an obvious declarative semantics. On the other hand, the dialog between a master Horn Clause interpreter creating a new interpreter for execution of one of its subgoals and the slave Answer Source Fluent which returns new answers on demand, is well known to any Prolog user as it is essentially the same as querying a Prolog interpreter through a toplevel command interpreter.
However, in a more declarative framework, it can be the case that a suitable semantics for our Fluent operations is given in terms similar to that of streams in functional languages.
Modular extension of Kernel Prolog through new built-ins is based on an Object Oriented hierarchy of Fluents. In our reference implementation we have chosen to build as much as possible of the extension at source level, except in case of major inefficiencies or limited functionality.
Apparently, this looks a difficult problem because answer_source and get operations provide a fixed communication flow between the answer producer and the answer consumer. Note however, that we can use an Answer Source constructor to emulate both linear (usable once) and conventional assert-style operations, by keeping the set of Answer Source engines representing references to 'dynamic clauses' on a list, as in:
assert_(Clause,Engines,[E|Engines]):-
answer_source(repeat,Clause,E).
linear_assert(Clause,Engines,[E|Engines]):-
answer_source(true,Clause,E).
clause_(Engines,Head,Body):-
member(E,Engines),
get(E,the((Head:-Body))).
The trick in the case of conventional assert is to force
indefinite backtracking inside the producer Answer Source, with
repeat/0, a pure predicate defined as usual:
repeat.
repeat:-repeat.
On the other hand, the usable once, linear_assert operation only executes the goal true/0 - and therefore it will only succeed once, before returning the answer no.
We have not shown how a retract-like operation is implemented - but this can easily achieved by removing the engine reference from the list of engines, so that clause/3 cannot see it anymore.
Note that these dynamic database operations are in fact backtrackable, as they depend on the list of engines maintained by the consumer program. As such, they are closer to BinProlog's linear and intuitionistic assumptions [26]. Scoped implications (as in Lambda Prolog, Lygon [32], Lolli [13,12]) can be implemented using logical variables to close the scope of an implication. This is how they are actually implemented in BinProlog [22].
Our reference implementation does not use the emulation shown previously which is obviously inefficient and cannot be used elegantly as an implementation of failure persistent databases.
Instead, we provide a direct implementation of Database Fluents, which reflect to object level the interpreter's own handling of the Prolog database. As an additional benefit, multiple databases are provided.
Sequential Prolog data structures are mapped to Fluents naturally. For instance, list_source/2 creates a new Fluent based on a List, such that its get/2 operation will return one element of the list at a time. Similarly term_source/2 creates a Fluent from an N-argument compound term, such that its get/2 method will return first its function symbol then each argument. These built-ins are usable to emulate conventional Prolog operations like univ/2 (also known as =..) quite easily:
univ(T,FXs):-if(var(T),list_to_fun(FXs,T),fun_to_list(T,FXs)).
list_to_fun(FXs,T):-list_source(FXs,I),source_term(I,T).
fun_to_list(T,FXs):-term_source(T,I),source_list(I,FXs).
As they can be converted easily to/from Prolog data-structures, Fluents are usable as canonical representation for data objects as well as for computational processes (like in the case of answer_sources). Fast iteration on Fluents, using loops over efficient native data structures in the implementation language, replace recursion in the object language. Interoperation with external objects is also simpler as implmentation language operations can be applied to Fluents directly.
File and URL I/O operations are provided by encapsulation Java's Reader and Writer classes as Fluents. Clause and (wide, Unicode compatible) character Readers are seen as instances of Sources and therefore benefit form Source composition operations. Moreover, Prolog operations traditionally captive to predefined data specific implementation like DCGs, can be made to work generically and mapped directly to work on relevant Sources like File URL or Socket Readers.
Note that one can assume, at an abstract level, that arithmetics is part of Kernel Prolog through the usual extension of Horn Clauses with successor arithmetics.
Kernel Prolog provides a unique built-in for handling arithmetic functions,
compute(Operation,Arg1,Arg2,Result)
An enhanced is/2 evaluator, supporting execution of arbitrary user defined functions of N arguments provided as N+1 argument Prolog relations, is implemented at source level.
Arithmetic operations producing sequences like random number generators, primes, arithmetic or geometric series etc. can be implemented efficiently in the underlying language and provided in Kernel Prolog as fluents. Our reference implementation provides a generic
integer_source(MaxFuel,A,X,B).
built-in operation allowing iterated computation of X<-A*X+B at most MaxFuel times (or an infinite sequence if MaxFuel = 0).
Most Fluents are designed to be usable only once, by default, and release all resources held (automatically on backtracking or under programmer's control when their stop operation is invoked). While Fluent operations like split_fluent/3 can be used3 to duplicate most Source Fluents, the following alternative provides a more efficient alternative.
A Memoing Fluent is built easily on top of a Source Fluent by accumulating values in a List or dynamic array. A Memoing Fluent can be shared between multiple consumers which want to avoid recomputation of a given value.
Lazy Lists can be seen as an instance of Memoing Fluents: they accumulate successive values of a Source Fluent in a (reusable) list. The simple Lazy List abstraction in our reference implementation works as follows:
source_lazy_list(Source, LazyList)
creates a new LazyList object form a Source object:
lazy_head(LazyList, LazyHead)
extracts the current head element of the list. Iteration over the list is provided by
lazy_tail(LazyList, LazyTail)
which returns LazyTail, a new lazy list encapsulating the next stage of the Source fluent.
While complete automation of lazy lists through a form of attributed variable construct is possible, we have chosen a simpler implementation scenario based on the previously described operations, mainly because overriding unification with execution of an arbitrary procedure would introduce potential non-termination - something which would break the very idea of keeping the execution mechanism as close as possible to basic Horn Clause resolution, as available in classic Prolog.
Based on these operations, a lazy findall/3 is simply:
% creates lazy list form an answer source
lazy_findall(X,G,LazyList):-
answer_source(X,G,S),
source_lazy_list(S,LazyList).

The following operations will produce a lazily growing reusable list, to be explored with lazy_element_of/2 in a way similar ordinary lists are explored with member/2.
% explores a lazy list in a way compatible with backtracking
% allows multiple 'consumers' to access the list, end ensures that
% the lazy list advances progressively and consistently
lazy_element_of(XXs,X):-
lazy_decons(XXs,A,Xs),
lazy_select_from(Xs,A,X).
% backtracks over the lazy list
lazy_select_from(_,A,A).
lazy_select_from(XXs,_,X):-lazy_element_of(XXs,X).
% returns a head/tail pair of a non-empty lazy list
lazy_decons(XXs,X,Xs):-
neq(XXs,[]),
lazy_head(XXs,X),
lazy_tail(XXs,Xs).
A minor change on Prolog's chronological backtracking is needed however: only the creation point of the lazy list is subject to trailing, and the complete lazy list is discarded at once. This is achieved easily in our reference implementation by giving to each lazy list its own (dynamically growing) trail, and by providing an undo operation which rewinds the trail completely when backtracking passes the lazy list object's creation point.
Multi-Variables are special Fluents which accumulate multiple values on an internal stack. As the stack is popped on backtracking multi-variables return to their previous values, therefore providing a form of backrackable destructive assignment. A new Multi-Variable is built with def(MultiVar,InitialValue), it is upated with set(MultiVar,NewValue) and its current value is retrived with val(MultiVar,Value)).
Among its applications, multi-stream DCGs, following the Assumption Grammars implementation model [26,4,22], which does not require a DCG preprocessor, but uses backrackable destructive assignment instead, for advancing the state of a given DCG stream.
dcg_def(MultiVar,Xs):-def(MultiVar,Xs).
dcg_val(MultiVar,Xs):-val(MultiVar,Xs).
dcg_connect(MultiVar,X):-val(MultiVar,[X|Xs]),set(MultiVar,Xs).
The resulting implementation initializes an input list with dcg_def/2, retrieves its current value with dcg_val/2 and advances with the dcg_connect/2 relation, which consumes/generates a terminal symbol each time is called.
We have shown that Kernel Prolog is basically as expressive as sequential, fixed execution order Prolog. An interesting open question is: is it expressive enough to emulate in an elegant (while possibly inefficient) way the basic XSB memoing scheme [31,21].
Let's observe that if an operation checking that a given term is a variant of another were available, we could associate a new Answer Source for solving a given goal (up to a variant) only once, and then explore the memoed results for extracting copies of answers.
We recognize here a basic element of the XSB engine [17]. However, there are a number of other issues in XSB, related to avoiding loops when the same goal variant shows up later in the execution of an open goal [5].
We will only sketch here the first steps towards XSB emulation in Kernel Prolog, i.e. we will add a form of memoing, allowing to reuse a given goal pattern, up to variant checking.
First, let us note that we can implement quite easily variant_of/2 as:
variant_of(Term,Variant):-
copy_term(Term,T1),
copy_term(Variant,T2),
numbervars(T1,T),
numbervars(T2,T).
with numbervars/2 expressed as usual in terms of successor arithmetics and var/1 (in practice, provided as a built-in, for efficiency).
Let us assume that a global store is implemented as a Database Fluent in which we can attach to each goal variant a unique persistent Answer Source. Goal variants can be represented as ground terms resulting from the numbervars/2 operation, on which a hash key can be computed (as in the orginal XSB implementation). Finally, to provide a memoing engine construct, which encapsulates the same functionality as an ordinary Answer Source, from outside, while making sure, internally, that the stream of solutions is computed only once, and shared through copying by all the consumers in the equivalence class of the answer variant, can be implemented by adapting our Lazy List construct to p| While more work is needed to orchestrate the suspend/resume mechanism of answer producers and answer consumers following some insights from work like [5], possibly within a multi-threaded implementation of Kernel Prolog (following our similar Jinni engine [23]), this implementation scenario shows that execution models going beyond Prolog's original LD-resolution model are relatively easy to express in our framework.
Besides the fact that our Answer Sources are instances of Fluents which provide a generic interaction mechanism with external stateful objects, independently of their execution mechanism, some other differences with Oz engines come from their different intended use:
New languages based on relatively pure subsets of Prolog like Mercury [20] have been designed as targets of more efficient implementation technologies and for their reliability in building large software systems. Flexible execution order is being used in systems like SICStus, GNU-Prolog and B-Prolog to support constraint solving and in systems like XSB for synchronizing answer production and answer consumption in tabling. While Horn Clauses with negation have been extensively studied and some of the techniques described in this paper might be well known to experienced Prolog programmers, the very idea of systematically exploring the gains in expressive power as a result of having multiple pure Prolog interpreters as first order objects, has not been explored yet, to our best knowledge.
While the set of bulit-ins suggested in this paper needs to be extended to cover Java events and interacion with GUI components and some key features of ISO Prolog [6] (most notably exceptions) are not covered so far, we think that the simpliciy of our design will help with the steap learning curb of Prolog and improve efficiency of real life Prolog programs by moving frequently used iterative patterns to the underlying implementation language.
The advent of component based software development and intelligent appliances requiring small, special purpose, self contained, still powerful processing elements, makes Kernel Prolog an appealing implementation technique for building logic programming components. In particular, in the case of small, wireless interconnected devices, subject to severe memory and bandwidth limitations, compact and orthogonally designed small language processors are instrumental. Our ongoing commercial Palm Prolog implementation will use a fast Horn Clause LD-resolution WAM emulator based on the Kernel Prolog design described in this paper.
Here are a few open issues and some ongoing or projected Kernel Prolog related developments:
By collapsing the semantic gap between Horn Clause logic and (most of) the full Prolog language into three surprisingly simple, yet very powerful operations, we hope to open the doors not only for an implementation technology for a new generation of lightweight Prolog processors but also towards a better understanding of the intrinsic elegance hiding behind the core concepts of the logic programming paradigm.
Our Horn Clause Solvers encapsulated as Fluents provide the ability to communicate between distinct OR-branches as an practical alternative to the use assert/retract based side effects, in implementing all-solution predicates. Moreover, lazy variants of all solution predicates are provided as a natural extension to Fluent based lazy lists.
Fluents provide a uniform approach to interoperate with stateful external objects, handle I/O operations in a generic way and allow to specify precise and automated resource release, consistently with Prolog's LD-resolution process.
Finally, high level Fluent Composers allow combining component functionality in generic, data representation independent ways.
It is usual to see interpreters for a fairly complex language like Prolog spread over thousands of line of code. In the spirit of Evolving Algebras [8], our interpreter only focuses on the transitive closure of the unfolding operation and on handling backtracking with a simple orStack, containing Unfolder Sources with elements left to iterate over (and implementing last call optimization when the Unfolder is reaching a stopped state.
Our tiny Interpreter is provided as an override to the get() method of the Source abstract class (seen at Prolog level as the get/2 built-in).
public Term get() {
if(null==orStack) return null;
Clause answer=null;
while(!orStack.isEmpty()) {
Unfolder I=(Unfolder)orStack.pop();
answer=I.getAnswer();
if(null!=answer) break;
Clause goal=(Clause)I.get();
if(null!=goal) {
if( I.notLastClause() )
orStack.push(I);
else
I.stop();
if(null==answer)orStack.push(new Unfolder(goal,this));
}
}
Term head;
if(null==answer) {
head=null;
stop();
}
else
head=answer.getHead();
return head;
}
Note that our design ensures that after producing a solution and returning, calling the interpreter will simply move the state of the Fluent to the next solution. This is clear simplification over Jinni [23] where answer producer Interpreter threads had to synchronize with their answer consuming caller threads.
The Unfolder class provides the stepping operation also as a get method of a Source Fluent. Except for the backtracking process (that it has to take care of by using its orStack), the Interpreter appears as a composition of Unfolder Fluents.
public Term get() {
if(null==e) return null;
Clause unfolded_goal=null;
while(e.hasMoreElements()) {
Term T=(Term)e.nextElement();
prog.getTrail().unwind(oldtop);
unfolded_goal=T.toClause().unfold_with_goal(goal,prog.getTrail());
if(null!=unfolded_goal) break;
}
return unfolded_goal;
}
The underlying unification operation called by unfold_with_goal is distributed as unify_to methods in the Term subclass tree, collectively implementing various operations on Prolog terms and lists.
1 The most commonly used variation is Prolog's LD-resolution which combines a depth-first search rule with a left-to-right selection rule.
2 Such constructors are named by concatenating the type names they convert between. For instance, list_source will convert a list to a Source Fluent.
3 The astute reader might notice that Linear Logic provers provide similar operations. This is by no means accidental, a resource conscious proof procedure will usually provide explicit means to implement reuse.


---
sort_order: 97
tei_id: rdx_b5h9g.p.idm1177088
annotation_count: 0
images:
small-thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcmjh/mini-thumbnail/
json: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcmjh/info/
full: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcmjh/fs/
page: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcmjh/single-page/
thumbnail: https://readux.library.emory.edu/books/emory:b5h9g/pages/emory:pcmjh/thumbnail/
title: Page 97
number: 97
---
{% raw %}JACOB HODGES.{% endraw %}
{% raw %}89{% endraw %}
{% raw %}as these; showing the channel in which{% endraw %}
{% raw %}his thoughts habitually flowed. ' Very{% endraw %}
{% raw %}well, master, in body, but 0 this wicked{% endraw %}
{% raw %}heart; I want a great deal more grace.'{% endraw %}
{% raw %}He complained much of a disposition to{% endraw %}
{% raw %}worldliness. ' His little matters of busi{% endraw %}
{% raw %}ness engrossed so much of his aitentionj{% endraw %}
{% raw %}he was compelled,' he said,' to pray con¬{% endraw %}
{% raw %}tinually against it. He wondered how{% endraw %}
{% raw %}rich Christians could keep along '{% endraw %}
{% raw %}" Jacob was a useful Christian. Such a{% endraw %}
{% raw %}one could hardly be otherwise. Jt may{% endraw %}
{% raw %}be said of him, ' He hath done what he{% endraw %}
{% raw %}could.' There are not a few in this vil¬{% endraw %}
{% raw %}lage who owe their conversion, >mder{% endraw %}
{% raw %}God, to his faithfulness, and I doubt not{% endraw %}
{% raw %}there are many who are ready to rise up{% endraw %}
{% raw %}and call him blessed.{% endraw %}
{% raw %}"His uniform and consistent life of piety{% endraw %}
{% raw %}cannot but have had a happy influence{% endraw %}
{% raw %}on all who observed him. He loved and{% endraw %}
{% raw %}longed to do good. I once asked him{% endraw %}
{% raw %}why he was. so anxious to be rendering{% endraw %}
{% raw %}services to me, for he was constantly in{% endraw %}
{% raw %}quiring if he could not do something foi{% endraw %}
{% raw %}8*{% endraw %}


Admin Panel
Personal Information
Semester:
Select Your semester
Semester 1
Semester 2
Semester 3
Semester 4
Semester 5
Semester 6
Semester 7
Semester 8
Department:
Select Your Department
Computer Science
Education
Bussiness Administration
Media Science
Environmental Science
Marksheet Credentials
Subject 1 :
Subject 2 :
Subject 3 :
Subject 4 :
Upload picture


RT @saturnflyer: Hilarious and informative @stevenhaddox about the enterprise at #rubynation
6/15/2013, 10:06:12 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @saturnflyer: Hilarious and informative @stevenhaddox about the enterprise at #rubynation
6/15/2013, 10:06:12 AM
Favs: 0
Retweets: 0
link


Gift for a girlfriend aggregator
Load from funfrom.me
Load from 2cherry.ru
Load from podarki.ru
CLEAR ALL
Id
Name
Price
Link


List of all members.
Constructor & Destructor Documentation
| Instance::Instance |
( |
std::string |
transferSyntaxUID ) |
|
Overloaded constructor for Instance class.
- Parameters:
-
| transferSyntaxUID | The Transfer Syntax UID to be used for this instance |
| Instance::Instance |
( |
std::string |
transferSyntaxUID, |
|
|
AttributeMapType |
attributeMap |
|
) |
| |
Overloaded constructor for Instance class.
- Parameters:
-
| transferSyntaxUID | The Transfer Syntax UID to be used for this instance |
| attributeMap | The map of tags to attributes to be used |
Member Function Documentation
| Attribute * Instance::GetAttribute |
( |
std::string |
tag ) |
|
Function to get the attribute corresponding to the tag.
- Parameters:
-
| tag | The tag of the attribute to get |
- Returns:
- attr The attribute corresponding to the tag
| AttributeMapType Instance::GetAttributeMap |
( |
void |
) |
|
Function to get the attribute map.
- Returns:
- attributeMap The map of tags to attributes being used
| std::string Instance::GetSOPInstanceUID |
( |
void |
) |
|
Function to get the SOP Instance UID.
- Returns:
- sopInstanceUID The SOP Instance UID being used
| std::string Instance::GetTransferSyntaxUID |
( |
void |
) |
|
Function to get the Transfer Syntax UID of the instance.
- Returns:
- transferSyntaxUID The Transfer Syntax UID being used
| std::string Instance::GetValueForAttribute |
( |
std::string |
tag ) |
|
Function to get the value of the attribute corresponding to the tag.
- Parameters:
-
| tag | The tag of the attribute to get the value of |
- Returns:
- value The value of the attribute
| void Instance::PutAttribute |
( |
Attribute * |
attr ) |
|
Function to insert an attribute to the map.
- Parameters:
-
| attr | The attribute to be inserted into the map |
| void Instance::RemoveAttribute |
( |
std::string |
tag ) |
|
Function to remove an attribute from the map.
- Parameters:
-
| tag | The tag of the attribute to be removed |
| void Instance::SetAttributeMap |
( |
AttributeMapType |
attributeMap ) |
|
Function to set the attribute map.
- Parameters:
-
| attributeMap | The map of tags to attributes to be used |
| void Instance::SetSOPInstanceUID |
( |
std::string |
sopInstanceUID ) |
|
Function to set the SOP Instance UID of the instance.
- Parameters:
-
| sopInstanceUID | The SOP Instance UID to be used |
| void Instance::SetTransferSyntaxUID |
( |
std::string |
transferSyntaxUID ) |
|
Function to set the Transfer Syntax UID of the instance.
- Parameters:
-
| transferSyntaxUID | The Transfer Syntax UID to be used |
The documentation for this class was generated from the following files:
- mintcpp/branches/development/MINTMetadata/Instance.h
- mintcpp/branches/development/MINTMetadata/Instance.cpp


Perfecting Menus, Paths and Breadcrumbs
about
about/jody
Jody Hamilton
CTO of Zivtech
Drupal architect, developer, site builder, trainer and contributor
Jody Lynn @ drupal.org
@JodyHamilton
about/definitions
Definitions
menus
A Menu is a Tree
One site : One tree
One page : One position
menus/the-main-menu
The Main Menu Tree & The Menu-ish
Common Menu-ish Menus
- Footer Menu
- User Menu
- Task-based Menu
- Organic Groups Menus
menus/canonical-menu-positions
Canonical Menu Positions & Core Problems
One page, one path, one breadcrumb, multiple menu items?
Canonical: We can have more than one but one is special
https://www.drupal.org/node/1875824
menus/menu-block
Menu Block
The only menu display you need
menus/hall-of-shame
Menu Hall of Shame
- Hand-made menus
- Crowded menus
- Too many menus
menus/menu-contrib
Menu Contrib
paths
A path is an address
URLs are part of your
- UI
- Design (though missing from most mockups)
- Navigation
- Self-respect
paths/restful
A path should be RESTful
"Clean" & Human-readable is not enough
- stateless
- hackable
- unique
For stateless paths, remember a page <> a node
paths/canonical-paths
Canonical Paths
Drupal 8 has working canonical paths!
https://www.drupal.org/node/1160764
Paths are also more stateless in D8
paths/pathauto
Pathauto Mastery
- Pages: [node:menu-link:parents:join-path]/[node:title]
- Event: events/[node:title]
- Bio: people/[node:title]
Change pathauto updating settings on launch
paths/path-contrib
Path Contrib Modules
- Global Redirect
- Redirect
- Linkit
- Pathologic
paths/paths-hall-of-shame
Paths Hall of Shame
- Javascript-only links
- Separate mobile sites
- Unhackable paths
breadcrumbs
Breadcrumbs
A human-readable path
"the children find that birds have eaten the crumbs and they are lost in the woods"
breadcrumbs/drupal-7
Breadcrumbs in Drupal 7
Based on menu positions. But menu positions have no system canonicalness.
Many contrib modules to help:
- Custom breadcrumbs
- Menu position
- Menu breadcrumb
- Crumbs
- Hansel breadcrumbs
- Path Breadcrumbs
Breadcrumbs by Path
breadcrumbs/drupal-8
Breadcrumbs in Drupal 8
http://www.palantir.net/blog/d8ftw-breadcrumbs-work
path-based!
about/bear
Bear Distribution
Questions
about/questions
/


Fall Semester
The course is a survey of programming languages: their attributes, uses, advantages, and disadvantages. Topics include scopes, parameter passing, storage management, control flow, exception handling, encapsulation and modularization mechanism, reusability through genericity and inheritance, and type systems. In particular, several different languages will be studied which exemplify different language philosophies (e.g., procedural, functional, object-oriented, logic, scripting). Prerequisite: EECS 268 and upper-level EECS eligibility.
The background and planning phase of a two-semester, team-oriented lecture/laboratory course involving the specification, design, implementation, and documentation of a significant software system. The course includes the consideration of project management, ethics, economics, and technical writing. Can be taken only during the senior year. Prerequisite: EECS 448. Co-Requisite: EECS 510 and EECS 560.
An introduction to functional programming. Topics include learning how to program in Haskell; IO and purity in software engineering; functional data structures and algorithms; monads and applicative functors; parsing combinators; Domain Specific Languages (DSLs) and DSL construction; advanced type systems; making assurance arguments; testing and debugging. Prerequisite: EECS 368 or equivalent or consent of instructor.


Laygo setup for new technologies¶
This section describes how to setup laygo for a new technology. This document is written to help users create setup files and template libraries.
Example setup files¶
Instead of starting from scratch, you can reuse some parts of example files. Check the following repos for reference:
- cds_ff_mpt: https://github.com/ucb-art/BAG2_cds_ff_mpt
- NCSU freePDK45: https://github.com/ucb-art/BAG2_freePDK45
Overview¶
Following items are need to be set up laygo.
- BAG and PDK
- config files: laygo_config.yaml, layermap file (GDS only)
- template and grid library: (tech_name)_microtemplates_dense for most example generators, and associated yaml files
BAG setup¶
Since laygo exports the generated layout to BAG (unless you are exporting to GDS), you need to setup BAG before setting up laygo.
Note: Techinfo in BAG does not need to be set up because DummyTechinfo is used by default.
Config file (laygo_config.yaml)¶
Laygo uses laygo_config.yaml to store technology specific information. For each technology, user need to create/update laygo_config.yaml to contain correct parameters. An example laygo_config.yaml file for cds_ff_mpt technology is shown below.
#default_laygo_config file
metal_layers: #metal layers
- [M0, donotuse]
- [M1, drawing]
- [M2, drawing]
- [M3, drawing]
- [M4, drawing]
- [M5, drawing]
- [M6, drawing]
- [M7, drawing]
- [M8, drawing]
- [M9, drawing]
via_layers: #via layers
- [V0, donotuse]
- [V1, drawing]
- [V2, drawing]
- [V3, drawing]
- [V4, drawing]
- [V5, drawing]
- [V6, drawing]
- [V7, drawing]
- [V8, drawing]
pin_layers: #pin layers
- [text, drawing]
- [M1, pin]
- [M2, pin]
- [M3, pin]
- [M4, pin]
- [M5, pin]
- [M6, pin]
- [M7, pin]
- [M8, pin]
- [M9, pin]
prboundary_layer: [prBoundary, boundary] #boundary layer
tech_lib: cds_ff_mpt
text_layer: [text, drawing]
physical_resolution: 0.001
All fields need to filled in proper format, and contains information explained below:
- metal_layers (list): list of [layername, layerpurpose] of metal layers to be used for routing, starting from the bottom layer to the top layer.
- via_layers (list): list of [layername, layerpurpose] of via layers to be used for routing, starting from the bottom layer to the top layer.
- pin_layers (list): list of [layername, layerpurpose] of pin layers to be used for routing, starting from the bottom layer to the top layer.
- prboundary_layer (list): list of [layername, layerpurpose] of the prBoundary layer for placement.
- tech_lib (str): name of technology.
- text_layers (list): list of [layername, layerpurpose] of the text layer for annotations.
- physical_resolution (float): minimum layout grid resolution in micron. Most advanced nodes have grid resolutions ranging from 0.01 to 0.001.
(tech_lib).layermap (GDS flow only)¶
For GDS flow, a separate layermap file is needed to map the layer names to actual layer ids. Usually the layermap file is provided by Foundry and can be found in the PDK library (because the file is used to stream out a layout to a GDS file). Users can also try to make a layermap file by themselves. Here’s a example of the layermap file (numbers are not from any real/generic PDKs). For BAG flow this file is not needed.
#technology layer information for gds export
#you may find this in the cadence techlib directory
#layername layerpurpose stream# datatype
text drawing 100 0
prBoundary drawing 101 0
M1 drawing 1 0
M1 pin 1 1
M2 drawing 2 0
M2 pin 2 1
M3 drawing 3 0
M3 pin 3 1
M4 drawing 4 0
M4 pin 4 1
M5 drawing 5 0
M5 pin 5 1
M6 drawing 6 0
M6 pin 6 1
M7 drawing 7 0
M7 pin 7 1
M8 drawing 8 0
M8 pin 8 1
M9 drawing 9 0
M9 pin 9 1
VIA1 drawing 11 0
VIA2 drawing 12 0
VIA3 drawing 13 0
VIA4 drawing 14 0
VIA5 drawing 15 0
VIA6 drawing 16 0
VIA7 drawing 17 0
VIA8 drawing 18 0
Template library¶
Refer to Woorham’s Template library setup guide for more detailed instructions.
This is the most critical part of the laygo setup. Laygo uses hand-drawn templates of primitive devices and automatic generations are done in block levels. Therefore, users need to build the primitive templates and grids associated with the templates in advance. Template and grid cells in laygo are classified into 4 categories.
- Placement grids: defines the grid resolutions to place devices. prboundary_layer is used for specifying the resolution.
- Routing grids: defines the grid resolutions that routing wires and vias will be placed on. Rect objects with metal_layers are used to define the width / spacing / coordinate of the routing grid. Vias are placed at cross-sections of route wires, and they are constructed as via template cells.
- Device template cells: templates of devices will be placed on one of the placement grids. prboundary_layer is used to specify boundaries of the template, and pin_layers are used to specify pin regions and pin names.
- Via template cells: templates of vias will be placed on one of the route grids.
The figure shown below contains all types of template and grid cells.
techex
Since there are no limitations on architecting grids, multiple placement grids / routing grids / devices / vias can be used for same technology / layer / device types. For example, 2 different types of grids (e.g thin and thick grids) can be used for Metal1-Metal2 grids. Or 2 different set of NMOS templates (short channel devices and long channel ones) can be constructed. These aspects are one of major differences from digital place and route flows.
The way of constructing template and grid cells is up to designer’s intent. However, there should be some levels of compatibility to enable code reusability over different technologies. We propose guidelines to architect template and grids cells for the reusability, especially for exampler scripts in the generators directory.
Template library name¶
For the generator examples, (tech_lib)microtemplates(flavor) is used for the primitive template library name. dense flavor is used for most example cases, which stands for optimized to reduce active area. For example, cds_ff_mpt_microtemplates_dense is the primitive template library name of cds_ff_mpt technology.
libname
Placement grids¶
placement_basic : a default placement grid layout. Contacted Poly Pitch(CPO) (for x axis) and a multiple of fin grid (for y* axis) are good candidates for the placement grid. Note that the size of any compatible templates should be a multiple of the placement grid.
placement_basic
The figure above shows the placement_basic example for cds_ff_mpt technology. CPO was used for the x-resolution and fin grid was used for the y-resolution.
Routing grids and vias¶
route_M1_M2_basic : a default M1_M2_route grid cell. Minimum metal spacings and widths are used for the resolution and metal width, assuming vias can be placed in diagonal directions.
m1_m2_basic
route_M1_M2_basic_thick: an M1_M2 grid that is composed of thin M1 and thick M2. This grid is useful for power grid routings.
m1_m2_basic_thick
route_M1_M2_mos, route_M1_M2_cmos : M2_M2 grids that are designed to be compatible to NMOS/PMOS/CMOS stuctures. Note that grid coordinates are aligned to gate/drain/source pins of fets, and 2 horizontal tracks crosses the source and drain region.
m1_m2_mos
M2_M3 grids (route_M2_M3_basic, route_M2_M3_thick_basic, route_M2_M3_cmos): M2_M3 grids that are compatible with M1_M2 grids.
m2_m3
Other grids on upper metal layers: following grids are used for example generators.
M3_M4 grids: route_M3_M4_basic, route_M3_M4_basic_thick, route_M3_M4_thick
M4_M5 grids: route_M4_M5_basic, route_M4_M5_thick
M5_M6 grids: route_M5_M6_basic, route_M5_M6_basic_thick, route_M5_M6_thick
Mosfet templates¶
Basic idea¶
In order to nicely capture all boundary design rules, all mostfet row structures are divided into 3 parts:
- Row boundary cells: placed at the (left & right) edges of device rows.
- Local boundary cells: placed between core devices
- Core cells: actual device cells (e.g. NF=2 NMOS, NF=1 NMOS, dummy NMOS, tap, …)
Any device row can be constructed by combining those element cells into one row.
nmos
For generator examples, these types of cells need to be implemented: nmos4_fast, pmos4_fast, ntap_fast, ptap_fast
nmos4_fast family cells¶
Here are the list of nmos cells used in generator examples:
- nmos4_fast_left: left boundary of nmos4_fast row
- nmos4_fast_right: right boundary of nmos4_fast row
- nmos4_fast_boundary: local boundary of nmos4_fast primitives
- nmos4_fast_space, nmos4_fast_space: 1x spacing cells
- nmos4_fast_space_2x, nmos4_fast_space_nf2: 2x spacing cells
- nmos4_fast_space_4x, nmos4_fast_space_nf4: 4x spacing cells
- nmos4_fast_tap: nmos4 tap cell
- nmos4_fast_center_nf2: 2 finger nmos core
- nmos4_fast_center_nf2: 2-stacked nmos core
- nmos4_fast_center_nf2: 1 finger nmos core (gate left sided)
- nmos4_fast_center_nf2: 1 finger nmos core (gate right sided)
- nmos4_fast_center_nf2: 2 finger dummy nmos
nmos_type
pmos4_fast family cells¶
Equivalent pmos cells need to be implemented as well:
- pmos4_fast_left: left boundary of pmos4_fast row
- pmos4_fast_right: right boundary of pmos4_fast row
- pmos4_fast_boundary: local boundary of pmos4_fast primitives
- pmos4_fast_space, pmos4_fast_space: 1x spacing cell
- pmos4_fast_space_2x, pmos4_fast_space_nf2: 2x spacing cells
- pmos4_fast_space_4x, pmos4_fast_space_nf4: 4x spacing cells
- pmos4_fast_tap: pmos4 tap cell
- pmos4_fast_center_nf2: 2 finger pmos core
- pmos4_fast_center_nf2: 2-stacked pmos core
- pmos4_fast_center_nf2: 1 finger pmos core (gate left sided)
- pmos4_fast_center_nf2: 1 finger pmos core (gate right sided)
- pmos4_fast_center_nf2: 2 finger dummy pmos
ptap_fast family cells¶
Ptap cells are used for constructing a ptap row, in order to construct thicker power grids (usually for pure analog cells) or guard rings.
- ptap_fast_left: left boundary of ptap_fast row
- ptap_fast_right: left boundary of ptap_fast row
- ptap_fast_boundary: local boundary of ptap_fast row
- ptap_fast_center_nf2: 2 finger ptap core
- ptap_fast_space: 1x spacing cell
- ptap_fast_space_nf2: 1x spacing cell
- ptap_fast_space_Nf4: 1x spacing cell
ntap_fast family cells¶
Equivalent ntap cells need to be implemented as well:
- ntap_fast_left: left boundary of ntap_fast row
- ntap_fast_right: left boundary of ntap_fast row
- ntap_fast_boundary: local boundary of ntap_fast row
- ntap_fast_center_nf2: 2 finger ntap core
- ntap_fast_space: 1x spacing cell
- ntap_fast_space_nf2: 1x spacing cell
- ntap_fast_space_nf4: 1x spacing cell
MOMCAP family cells¶
- momcap_boundary_1x: 1x momcap boundary
- momcap_center_1x: 1x momcap core
- momcap_dmy_1x: 1x momcap dummy (place where center cells are not placed)
- momcap_dmyblk_1x: 1x momcap dummy metal fill block cell
- momcap_dmyptn_mX_1x: 1x momcap dummy metal fill (mX) cell
mom_type
Converting template layout to laygo database¶
After building all primitive templates, open bag and type
run laygo/labs/lab2_a_gridlayoutgenerator_constructtemplate.py
It will read the primitive template layouts and construct template / grid databases and save them to the following 2 yaml files:
* (tech_lib)_microtemplates_dense_templates.yaml
* (tech_lib)_microtemplates_dense_grids.yaml


Kanye West Ordered to Stop Construction of Amphitheater in Monster Lake Ranch
As ‘Ye changed the building’s purpose from a “meditation space” to “residential use.”
by Sophie CaraanKanye West will need to put his plans of building the Monster Lake Ranch amphitheater on hold. Park County Wyoming Planner Joy Hill confirmed that the County is ordering Kanye to halt construction of the 70,684-square foot structure because the budding real estate developer broke ground without a permit.
According to reports, West’s construction crew was instructed to stop operations when county officials visited the property after the submission of his building permit application. The crew ignored the mandate, however, and continued to work even after multiple visits by officials. The Park County Planning and Zoning Commission was initially scheduled to announce the application result on November 19, but the permit was voided just a few hours prior due to Ye changing the building’s purpose from a “meditation space” to “residential use.”
West will receive a letter from the County ordering him to halt construction and a new building permit application will need to be submitted.
Elsewhere in music, take a look at the 2020 Grammy Award nominees.


Off-Topic
Scriptsz
(4)
Check pls
(2)
Pls help
(4)
Hexus is unstable
(15)
MML Admin Script
(14)
Trippy theme
(6)
Cant join
(2)
Never join
(2)
Remember me?
(2)
Rip memes in eu
(3)
Skrubs
(2)


Black Regalia
menu
About
Guild
Gallery
FAQ
Login
Sign Up
Login
Sign-Up
About
Guild
Gallery
FAQ
Registration Form
Username
Email
NIK
Pilih File
Civilian
Guild Member
Member Type
1-month
3-month
6-month
12-month
Join Periode
Profession
Skillset
Password
Re-type Password
Full Name
Birth Date
Telepon
Handphone
Address
Register
done


PBC STEM
Menu
Companies
Classrooms
PBC STEM
Impact the generation of tomorrow
I am teacher
I am Professional
Post
Post your card
I am
Teacher
Professional
I offer
Internship
Externship
Mentorship
Post your card
Please login in first


Rainbow
Falls Mountain Bike Race
Great
Falls, MT
Saturday, October 23, 2004
USA Cycling Permit #
Pending
$300 Merchandise Prizes
RACE DESCRIPTION:
The race course follows hard packed double and single track trails at
the South Shore of the River' Edge trail.
The course is 3.9 miles long
over rolling hills and twisting trails.
This is a FUN and moderately challenging course. Distances:
Beginner - One Hour, Sport - 1.5 Hours, Expert - 2 Hours. Actual mileage and laps to be announced.
DIRECTIONS: Stage at
the gate above the Rainbow Dam Overlook.
Follow River Drive, until you come to Giant Springs Road, take Giant
Springs Road past Lewis and Clark Interpretative Center and FWP Headquarters,
continue on past overlooks to top of hill.
Park along road at top of hill or in Rainbow Dam Overlook parking lot.
Directions are shown below.. Registration opens at 9:45am. Racing will start at 10:30 am with a
staggered start of all classes. Prize
drawings, food and beverages after the race at the race site. MUD CANCELS EVENT.
MISCELLANEOUS: USA
Cycling rules apply. One Day and Annual
licenses will be available. Base
registration fee is $8.00, plus $2.00 insurance surcharge, plus $5.00 One Day
license fee if entrant doesn't have an annual license. Race day registration only. All ages and abilities are eligible to
enter. Riders 17 years and younger must
have parent sign a release form.
Promoted by the Great Falls Bicycle Club. Call John Juras,<PHONE_NUMBER> or e-mail<EMAIL_ADDRESS>or
Sherie Holtz,<PHONE_NUMBER> or e-mail<EMAIL_ADDRESS>if you need more information.
TRAIL BUILDING FUND RAISER:
Registration proceeds will be used for trail building and maintenance in
the Great Falls area.


!Nemo:
I have no information about the origins of this species, but what I have found is that these creatures do possess a unique energy, sort of plasma if you will. Hmm… Maguen Plasma. I like that. I think that is what I’ll call it. Anyway, when a Maguen appears it begins to bring forth one of these plasmas. It will also cycle through its various plasmas before hiding.
With Blacksmith Kusto’s talent and my magic we were able to create a device that could harvest these plasmas… a Maguen Plasma Collector. I know it isn’t too creative but we decided to keep the name simple to avoid explaining what it does.
Ugh… fine. I’ll explain it to you. When you are in the Seed and a Maguen appears you have a very limited time to collect the Maguen Plasma.  I’ve set up a practice Maguen if you want to try using the Maguen Plasma Collector.
This isn’t a real Maguen, so you won’t collect any Plasma… just thought you should know so you don’t get your hopes up.
[npc_%objectId%_request_collector|Receive the Maguen Plasma Collector]
[npc_%objectId%_request_maguen|Practice using the Maguen Plasma Collector]


{% extends 'template-lab-4a.html' %} {% set mainClasses = 'nhsuk-u-padding-top-0' %} {% block pageTitle %} Symptoms - NHS {% endblock %} {% block beforeContent %} {% endblock %} {% block content %}
Heavy periods (also called menorrhagia) are common and may just be normal for you. Treatment can help if they're affecting your daily life.
You may have heavy periods if you:
It can be normal to have heavy periods.
They can be heavy at different times, like when you first start your periods, after pregnancy or during menopause
Sometimes, they can be caused by
Rarely, heavy periods can be a sign of womb cancer.
Heavy periods do not always need to be treated. But there are treatments that can help if they’re affecting your daily life.
Treatments from a GP include:
You should have a blood test to check if you have iron deficiency (anaemia)
If these treatments do not work or a GP thinks a condition may be causing your heavy periods, they’ll usually refer you for tests or to see a specialist.
Page last reviewed: 02 August 2019
Next review due: 02 August 2022


Whale
posted a new
bounty
Whale
posted a new
bounty
3,444
Now
HTML
CSS
Make the category list a dropdown so it doesn't break the layout
Comment


Hello, I am Roukia. I am from Damascus Syria I live in Jordan. I studied a bachelor degree in civil engineering at applied science university and graduated with a Very good grade point average 80.2% (GPA).
i get a Certificate in high-performance level in the proficiency exam for expected graduation students that based on learning outcomes and area of knowledge by the accreditation and quality assurance commission for higher education institutions i also Won the first place in Jordanian engineers association graduation projects competition award.
during my bachelor study, I Participate in the exchange program in turkey that aim to develop students skills, communication with individuals from diverse cultural backgrounds, exchange experiences, cultures and forming relationships with experts and other participants and get a certificate of attendance of level A1 of Turkish as a foreign language course in Istanbul 29 Mayis University.
I trained for 3 months as a Structural designer responsible for formulate, design, and draw structural illustrations, schemes, and designs. Also, review, update and modify construction drawings. I volunteer as a coordinator in a youth entrepreneurial platform concerned with developing the skills of youth in entrepreneurship and community. now I am taking a software development courses by Abdul Aziz al Ghurair school of advanced computing ASAC
Top Ten Movies
- The Hunger Games
- Inception
- Titanic
- La La Land
- Joker
- Casablanca
- Mission Impossible
- fault in our stars
- Gone girl
- divergent


Numbers 32:30
But if they will not pass over with you armed, they shall have possessions among you in the land of Canaan.


A grid that progressivly enhances from inline-block and floats, to flexbox, to css-grid. Turning on inline-block/flexbox/css-grid is optional. Possibility to create more/less breakpoints, change number of columns, set column & row gap/gutter.


Tell me about yourself...
What is your name?
Paste a link to your photo!
Instructions: Select an answer based on how you would Agree/Disagree with the statement.
Q1 I love a good party and enjoy socializing!
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q2 I enjoy going to museums and performances.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q3 I enjoy my privacy and downtime.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q4 I enjoy being outside in nature.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q5 I enjoy traveling outside of the US.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q6 I like to keep a schedule and be on time.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q7 I enjoy keeping my space clean and organized.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q8 I am more logical than emotional.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q9 I enjoy spending time with family and kids.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Q10 I enjoy being active or participating in sports.
Strongly Agree
Sometimes Agree
Neither
Sometimes Disagree
Strongly Disagree
Submit


|
| Kasimir Malevich art links |
Kasimir Malevich Works Online
Categorized & Annotated
Commercial Galleries: Galleries: We invite you to register and list your site (no charge for this service)
Original works by Kasimir Malevich available for purchase at art galleries worldwide
Paintings in Museums and Public Art Galleries Worldwide:
Art Institute of Chicago NEW!
Dallas Museum of Art, Texas NEW! (There is a "Download" link for zooming in on some works, but confusingly this may take a while to become active)
Fine Arts Museums of San Francisco NEW!
Guggenheim Museum, New York City 2 works online
Hermitage Museum, Saint Petersburg, Russia Black Square, ca.1930
Museum of Modern Art, New York City Includes biographical information about the artist
National Gallery of Art, Washington D.C. NEW! Most but not all artists in the NGA database have works online
National Gallery of Australia, Canberra House under construction
Peggy Guggenheim Collection, Venice NEW!
San Francisco Museum of Modern Art
Tate Gallery, London, UK
Yale University Art Gallery, New Haven, Connecticut The Knife Grinder (Principle of Glittering)
Aichi Prefectural Museum of Art, Japan
Harvard University Art Museums, Massachusetts Harvard have works in their collections, but unfortunately you have to type in the search yourself
Kunstmuseum Basel, Switzerland Alphabetically under "M"
Los Angeles County Museum of Art NEW!
Moscow Museum of Modern Art (in Russian) Self-portrait, 1934
Museum Ludwig, Cologne, Germany (mostly in German)
Museum Ludwig, Cologne, Germany (mostly in German)
Museum of Modern Art, New York City - Provenance Research Project 7 works by Malevich
Philadelphia Museum of Art NEW!
State Museum of Contemporary Art, Thessaloniki, Greece
State Russian Museum, St. Petersburg 5 paintings online
Stedelijk Museum of Modern Art, Amsterdam Suprematist Painting (Red Cross on Black Circle), 1921-27
The Albertina, Vienna Man in a suprematist Landscape, ca.1930/31
Thyssen-Bornemisza Museum, Madrid NEW! (Images are zoomable; click on the "expand" icon below the detail image)
Virtual Museum of Canada
Wallraf-Richartz-Museum, Cologne, Germany (mostly in German) Landschaft (Der Winter)
Art Market: (e.g. records of past sales at auction; sites providing examples of the artist's signature)
Art Signature Dictionary NEW!
Christie's Past Sale Archive (database goes as far back as 1991; images go about as far back as 1999)
Sotheby's Sold Lot Archive (database goes as far back as 1998; images where permitted by copyright go about as far back as 2001)
Pictures from Image Archives:
Kasimir Malevich at The Artchive
Kasimir Malevich at The Athenaeum 25 works online by Malevich
Kasimir Malevich in the WebMuseum
Wikimedia Commons Image Database
World Visit Guide (formerly Insecula)
Aiwaz Panopticon
Bildindex der Kunst und Architektur (in German) (a welcome screen is displayed for a couple of seconds before the search results appear)
Boston College Fine Arts Department
California State University WorldImages Database
Kasimir Malevich at CGFA
Ciudad de la Pintura (in Spanish)
El Poder de la Palabra (The Power of the Word) (in Spanish)
Humanities Web
State Hermitage Museum Unofficial Site
USC Annenberg School for Communication
Additional Image Search Tools:
(SafeSearch set to "strict"; go to Advanced Search (Flickr/Google) or Preferences (Bing) to change)
Miscellaneous Sites:
Auburn University Liberal Arts Department
California Literary Review Costume design for a strongman in the opera Victory over the Sun
Gallery of Russian Art
History of Russian Painting
Kubisme (Cubism) (in Dutch)
Repository of Abstract Art
The Legacy Project "A gathering place for people interested in the enduring legacies of the many violent traumas of the 20th century"
Thomas Gibson Fine Art Ltd., London, UK -- Notable past sales Dynamic Suprematism, 1916
Articles and Reference Sites:
Encyclopedia Britannica complete article on Kasimir Malevich Note: The full version of the article is available only if you follow this link. If you bookmark the article and return later, or if you navigate directly to the Britannica website, you will see a 100-word preview only. Troubleshooting
Union List of Artist Names (Getty Museum) Reference sheet with basic information about the artist and pointers to other references.
Wikipedia, the "Open Content" Encyclopedia Biographical info
Artnet Magazine Suprematist Composition, 1919-20
Deutsche Bank Artmag An introduction to Kasimir Malevitch
Deutsche Bank Artmag Article on the influence of Malevitch on other artists
Deutsche Bank Artmag Kasimir Malewitsch: Suprematism (exhibition website)
The Art Story
The New York Observer "The Suprematist: Malevich Abstracts At the Guggenheim", article by Hilton Kramer
The New York Observer "Malevich $17 Million Sale Finally Buries Stalinism", article by Hilton Kramer
The New Yorker "The Prophet", 2003 article by Peter Schjeldahl
"Look Inside" and "Search Inside" Books at Amazon
| Look Inside Books: | Selections from the books listed below are scanned in, in high res. Text is clearly readable and art reproductions vary from so-so to excellent. Don't miss the fact that you can usually zoom in via the "View" drop-down menu, along the top row of Amazon's Online Reader. | |
| Search Inside Books: | Same as "Look Inside", except that the entire book is scanned in, and the text is fully searchable. This is an unbelievable resource, for research and especially for previewing a book when making the decision to buy. Note: Some "Search Inside" features are limited to people signed in to an account which has previously made a purchase at Amazon. | |
search inside
Kazimir Malevich: The Climax of Disclosure
look inside
Kasimir Malevich and the Art of Geometry
look inside
Masters of Art: Malevich
look inside
Painting Revolution: Kandinsky, Malevich and the Russian Avant-Garde
|
|
|
|
|
|


Current
Current tasks are those from all of the users Coords that can be worked on now. This is a critical feature. We want to avoid the "Inbox" imagery because there is the invitation process that handles incoming tasks. This needs to indicate that work can be done on the task.
Deferred
Deferred means that a Task won't start until some time in the future.
Delegated
Delegated shows all tasks that are Delegated to someone else but that aren't part of any Coord.
Blocked
Blocked shows all Tasks that can't be worked on because another task isn't done that must be completed first.
Private
Private Tasks are those that I'm doing myself so don't involve anyone else.
Task Invites
All new Tasks first come to this box.
Coord Invites
All new Coords first come to this box.
Coord Responsible
If the user is responsible for a Coord, it looks like this. The Coord is something that will be branded so this is an important icon. It should avoid using project imagery of any kind.
The star is the element that indicates responsibility in the current application but can be changed.
Coord Responsible with Invitations
This is the icon that shows when there are invitations pending in a responsible's project
Coord Responsible with Flags
This is the icon that shows when invitations are declined, when someone leaves a project, etc in a responsible's project
Coord Participant
This is the icon for Coords in which the user is a Participant
Coord Pending
This is the icon for Coords that the responsible has created but hasn't yet sent to participants and followers
Coord Following
This is the icon for Coords that the user is Following


class: center, middle, inverse, title-slide # Introduction to R Tutorial ### Joscelin Rocha-Hidalgo
(she,her,hers)
@JoscelinRocha
### Dec 13th, 2020
DC BrainHack 2020 --- class: center, middle, inverse, dk-section-title **Slides adapted from David Keyes (@dgkeyes), inspired by Danielle Navarro (@djnavarro) and Paul Campbell (@paulcampbell91)** --- class: center, middle, inverse, dk-section-title # Agenda Intro to R and Importing Datasets -- RMarkdown -- Data Manipulation -- Tips & Resources --- class: center, middle, inverse, dk-section-title # Intro to R and Importing Datasets --- ### Tour of RStudio .center[ ![](images/rstudio-panes.png) ] --- ## File Types There are **two main file types** that you'll work with: .pull-left[ **R scripts (.R)** Text is assumed to be executable R code unless you comment it (more on this soon) ```r # This is a comment data <- read_csv("data.csv") ``` ] -- .pull-right[ **RMarkdown files (.Rmd)** Text is assumed to be text unless you put it in a code chunk (more on this soon)] --- ## R Scripts Create new script file: File -> New File -> R Script ![](images/new-script.gif) --- ## How to Run Code Run the code: -- * control + enter on Windows -- * command + enter on Mac keystrokes or use Run button --- ## Comments Do them for others and for your future self! ```r # Show the first 5 rows of my data head(data, n = 5) ``` --- ## Install Packages The syntax to install packages is as follows: ```r install.packages("tidyverse") install.packages("skimr") ``` The package name must be in quotation marks. -- .dk-highlight-box[ Packages should be installed **once per computer**. ] --- ## Load Packages To load packages, use the following syntax: ```r library(tidyverse) library(skimr) ``` -- .dk-highlight-box[ Packages should be loaded **once per session**. ] --- ## Import Data ### CSV ```r chds6162_data <- read_csv(here("data", "chds6162_data.csv")) chds6162_data <- read_csv("data/chds6162_data.csv") ``` --- ### Excel files ```r library(readxl) chds6162_data <- read_excel("data/chds6162_data.xls") ``` -- ### SPSS/Stata/SAS files ```r library(haven) chds6162_data <- read_sav("data/chds6162_data.sav") ``` --- ## R is Case Sensitive R is **case sensitive** so choose one of the following for all objects and **be consistent**. .pull-left[ **Options** snake_case camelCase periods.in.names ] -- .pull-right[ **Example** student_data studentData student.data ] --- Art by @allison_horst ![](https://raw.githubusercontent.com/allisonhorst/stats-illustrations/master/other-stats-artwork/coding_cases.png) --- ## Directories If the data file is in the working directory, you only need to specify its name. ```r chds6162_data <- read_csv("chds6162_data.csv") ``` -- If the data file is not in the working directory, you need to specify the full path name. ```r chds6162_data <- read_csv("data/chds6162_data.csv") ``` -- .dk-highlight-box[ *Using an RStudio project sets your working directory to the folder where your project lives so you only need to specify the location relative to that* ] --- Avoid setwd() and rm(list = ls()) There is an entire post by Jenny Bryan on why setwd() and rm(list = ls()) should be avoided: https://www.tidyverse.org/blog/2017/12/workflow-vs-script/ - setwd() relies on a hard coded path that must be changed if anyone else uses the code or if the file is moved on the host machine. A better alternative is to use the **here package**, which does not require other users to change the path if they are running the script from the same project directory. This is why *here()* works particularly well with R Projects, which retain the structure and content of projects across directories or machines. - Many people use rm(list = ls()) to clean their environment at the start of a script. However, rm(list = ls()) does not create a new R session, which means that there may still be hidden dependencies (libraries, functions) that the author of the code is unaware of but that will prevent the code from running for a different user. Use here() instead: ```r chds6162_data <- read_csv(here("data", "chds6162_data.csv")) ``` --- ## Where Does Our Dataset Live? Data we have imported is available in the environment/history pane. .center[ ![](images/rstudio-panes-highlight-environment.png) ] --- ### ?function Use the ? to get help about anything you're confused about ```r ?read_csv ```


Watch: Naughty By Nature Reunite + Ignite 90’s Vibes Performing Classics O.P.P., HIP HOP HOORAY MEDLEY + More
by Team SOHHIt’s officially Nineteen Naughty Three all over again. Rap trio Naughty By Nature have reunited and pulled through this holiday break to perform a slew of classic hits. Watch and comment below!


|
STM8S Standard Peripheral Libary
2.2.0
|
Macros used by the assert function in order to check the different functions parameters. More...
Macros | |
| #define | IS_ITC_IRQ_OK(IRQ) ((IRQ) <= (uint8_t)24) |
| #define | IS_ITC_PRIORITY_OK(PriorityValue) |
| #define | IS_ITC_INTERRUPTS_DISABLED (ITC_GetSoftIntStatus() == CPU_SOFT_INT_DISABLED) |
| #define | IS_ITC_IRQ_OK(IRQ) ((IRQ) <= (uint8_t)24) |
| #define | IS_ITC_PRIORITY_OK(PriorityValue) |
| #define | IS_ITC_INTERRUPTS_DISABLED (ITC_GetSoftIntStatus() == CPU_SOFT_INT_DISABLED) |
Macros used by the assert function in order to check the different functions parameters.
| #define IS_ITC_PRIORITY_OK | ( | PriorityValue | ) |
Definition at line 154 of file stm8s_itc.h.
| #define IS_ITC_PRIORITY_OK | ( | PriorityValue | ) |
Definition at line 154 of file stm8s_itc.h.


|
|
|
Virgo jumper
|
|
Spun pure wool to a fine knit design, the soft Virgo jumper is the kind of piece that translates effortlessly from now through to summer.
|
|
|
|
|
|
|
|
|
|
Jada jacket
|
|
The blue and white checked Jada blazer will lend simple looks a Parisian insouciance. It's tailored to a structured silhouette for a feminine style.
|
|
|
|
|
|


|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object | +--org.joonegap.NeuralNetManager
NeuralNetManager manages the...
This class is abstract. Clients must extend it and
implement createUninitializedNeuralNetwork
(to
create the specific nodes/layers structure of their network)
and getMeaningOfOutputNodeAt
to specify some
meaningful value for each output node in the neural net.
It is assumed that, for many problems, discrete values will be required from the neural net, and in many cases this is best achieved by having discrete output nodes (each with a specific 'meaning', such as a person's name in a facial recognition network), and sorting them by strength of activation.
If this is not the structure of your particular network,
you can safely return null
from getMeaningOfOutputNodeAt
.
(note that all public methods are synchronized)
| Constructor Summary | |
protected |
NeuralNetManager(java.io.File p_fileGenes,
boolean p_bAllowLoadingPreviouslySavedGenes,
int p_iGamesPerGeneration,
int p_iMinimumPopulationSize)
Constructor (protected, to avoid accidental instantiation). |
protected |
NeuralNetManager(java.io.File p_fileGenes,
boolean p_bAllowLoadingPreviouslySavedGenes,
int p_iGamesPerGeneration,
int p_iMinimumPopulationSize,
double p_dTrainingLearningRate,
double p_dTrainingMomentum,
int p_iTrainingEpochs,
double[][] p_arrayTrainingInput,
double[][] p_arrayTrainingDesiredOutput)
Constructor (protected, to avoid accidental instantiation). |
| Method Summary | |
protected abstract NeuralNet |
createUninitializedNeuralNetwork()
Create an uninitialized neural network of the structure you desire. |
java.util.List |
cycle(java.lang.Object p_objIdentity,
double[] p_dInput)
Cycle the neural network, returning a sorted List of MeaningStrengthPairs for all output nodes. |
void |
gameOver(java.lang.Object p_objIdentity,
java.lang.Boolean p_boolWon)
|
protected Configuration |
getCustomConfiguration()
In the majority of cases, clients can leave JOONEGAP to create and initialize its own JGAP Configuration object. |
int |
getGenerations()
|
protected abstract java.lang.Object |
getMeaningOfOutputNodeAt(int p_iIndex)
Get the meaningful value of the neural network node at the given index. |
java.lang.String |
getName(java.lang.Object p_objIdentity)
Get the name of the object with the given identity. |
void |
hold(java.lang.Object p_objIdentity)
Hold the neural network with the given identity. |
void |
release(java.lang.Object p_objIdentity)
|
void |
setLogger(Logger p_logger)
|
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
protected NeuralNetManager(java.io.File p_fileGenes, boolean p_bAllowLoadingPreviouslySavedGenes, int p_iGamesPerGeneration, int p_iMinimumPopulationSize)
protected NeuralNetManager(java.io.File p_fileGenes, boolean p_bAllowLoadingPreviouslySavedGenes, int p_iGamesPerGeneration, int p_iMinimumPopulationSize, double p_dTrainingLearningRate, double p_dTrainingMomentum, int p_iTrainingEpochs, double[][] p_arrayTrainingInput, double[][] p_arrayTrainingDesiredOutput)
| Method Detail |
public final void setLogger(Logger p_logger)
public final void hold(java.lang.Object p_objIdentity)
If no such network exists, one will be created and will not be re-created until this identity is released.
public final java.lang.String getName(java.lang.Object p_objIdentity)
hold
.
public final java.util.List cycle(java.lang.Object p_objIdentity, double[] p_dInput)
Q: Ok, but what when 'getMeaningOfOutputNodeAt' returns 'null', as suggested by you elsewhere, for the neural networks having a 'continuous' output range?
Whatever value is returned by 'getMeaningOfOutputNodeAt' is, before it reaches the client, paired up into a MeaningStrengthPair (by way of a List after calling 'cycle'). The 'meaning' in the MeaningStrengthPair is whatever was set by 'getMeaningOfOutputNodeAt', and the 'strength' is the strength of activation.
For example, in a neural network designed to recognize people's faces, we might have two output nodes. The first output node might 'mean' a person Fred, and the second output node might 'mean' a person Wilma. Often in these situations, the clients will want to take whichever node has the highest activation as being the answer from the neural net. To assist in this process, the List returned by 'cycle' is sorted in order of strength of activation, so clients simply have to do...
String strThePersonIdentifiedIs = (String) ((MeaningStrengthPair) list.get( 0 )).getMeaning();
...even if the meaning of the nodes is just, say, an index value of some description, clients can return Integers in 'getMeaningOfOutputNodeAt'.
In cases where it is the strength of activation itself that the client is interested in, however (say for a XOR network with only one output node, where >0.5 is a '1', and <=0.5 is a '0') they can ignore this 'meaning' value altogether. They can simply do...
double dTheActivationStrengthIs = ((MeaningStrengthPair) list.get( 0 )).getStrength();
int iIConsiderThisValueA = dTheActivationStrengthIs > 0.5 ? 1 : 0
...in this case, they don't even use 'getMeaning' so it can return anything for all they care (including null).
Q: Is the Chromosomes' selection affected by this 'meaningful'?
The selection (or otherwise) of a given Chromosome is not related to the result of 'getMeaningOfOutputNodeAt'. It is decided entirely on the score as totalled up by 'gameOver'.
Q: Why do you sort the meaning-rank list?
Because, for many purposes (though somewhat arbitrarily) clients will be choosing the highest strength of activation as the 'right' answer.
Q: Why do you assert: "Sorting by strength is done largely 'behind the scenes', but clients will find the 'meaning' object directly useful." Useful for what?
It is normally the 'meaning' object that conveys what the answer from the network actually means, such as 'Fred' or 'Wilma'.
p_objIdentity
- the identity under which this neural network was held when 'hold' was calledp_dInput
- the input to cycle through the neural network
public final void gameOver(java.lang.Object p_objIdentity, java.lang.Boolean p_boolWon)
public final void release(java.lang.Object p_objIdentity)
public int getGenerations()
protected abstract NeuralNet createUninitializedNeuralNetwork()
Clients should not set the network's inputs or outputs, or any monitors, and should not train the network in any way.
protected abstract java.lang.Object getMeaningOfOutputNodeAt(int p_iIndex)
MeaningStrengthPair
to your client.
It is assumed that, for many problems, discrete values will be
required from the neural net, and in many cases this is best
achieved by having discrete output nodes (each with a specific
'meaning', such as a person's name in a facial recognition
network).
When clients call cycle
, JOONEGAP gathers the 'meaning' of each
output node together with its strength of activation (for the given input), and
puts them into a List of MeaningStrengthPair
s, sorted by
highest strength of activation. This is useful for many clients, who will wish
to take the strongest activated output node as being the 'correct' answer
from the neural network.
If your particular network does not use discrete output nodes, this method
may not apply to you. For example, if you have a neural network for tackling the
XOR problem, which has only one output node whose output is taken to be either 1
or 0 depending on whether it is greater or less than 0.5, then you are more
interested in raw strength of activation than any 'meaning'. In that case,
you would read the strength from the MeaningStrengthPair
, and
ignore the meaning altogether, so you can safely have this method return null.
Either way, the value returned by this method has no effect on the Chromosome selection process.
p_iIndex
- the index of the output node
protected Configuration getCustomConfiguration()
|
||||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


fibber
Starting app...
fibber
how to play
1. read statement
2. decide if it's a truth or a fib
3. first person naked loses.
START
Hillary Clinton says market forces made coal companies go bankrupt
HRC
hillary clinton
TRUTH
FIB
"The market is making this decision. The market has driven down the cost of coal, so you have companies going bankrupt."
- an interview with CNN's Anderson Cooper
DT
donald trump
TRUTH
FIB


--- layout: post title: Fashion date: '2018-04-13T11:30:26+02:00' categories: - Sketches picture_url: https://film-Storyboards.tumblr.com/post/172896993565 ---


|
Netsuite 2016_1
|
Static Public Attributes | |
| static | $paramtypesmap |
| Static Public Attributes inherited from Record | |
| static | $paramtypesmap |
| $amount |
| $billingAccount |
| $billingItem |
| $billTo |
| $chargeDate |
| $chargeType |
| $class |
| $createdDate |
| $currency |
| $customForm |
| $department |
| $description |
| $externalId |
| $internalId |
| $invoice |
| $invoiceLine |
| $location |
|
static |
| $projectTask |
| $quantity |
| $rate |
| $rule |
| $runId |
| $salesOrder |
| $salesOrderLine |
| $stage |
| $subscriptionLine |
| $timeRecord |
| $transaction |
| $transactionLine |
| $use |


--- layout: post status: publish published: true title: Book Pile & and New Years author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 514 wordpress_url: http://winterdom.com/2003/01/bookpileandnewyears date: '2003-01-01 10:19:30 +0000' date_gmt: '2003-01-01 10:19:30 +0000' categories: - Personal tags: [] comments: [] ---
I love books. Right now, my bookshelf hosts a very nice "to-read" 11-book-tall pile. Is there anything better than the feel and smell of a brand new book?
One of my new year's resolution is opening up to new paradigms and environments, and learning more about scripting. So, today I started reading "Learning Perl", and so far, I'm liking it. Next in the back burner is "Programming Python".
Happy new year, everyone!


VAVICI FOUNDATION
Healthcare has become one of the few industries where we can spend billions of dollars on new innovations and yet not improve lives or lower costs. Nearly 40% of the population is obese and a third of us are projected to have type 2 diabetes by the year 2050. Some 75% of all health care costs are caused by chronic diseases like obesity and diabetes. It is this segment that continues to grow the most rapidly. Pundits project that US healthcare costs, currently estimated at nearly $4 Trillion annually, will increase six fold by the year 2050. Even without this growth, healthcare costs are already the single largest sector of the US economy. Worse, they have become the greatest threat to retirees nationwide.
Both the historical records and the multitude of forecasts for the unrelenting advance of healthcare costs suggest that we have NOT invested and are NOT investing in the right areas. This is easy to understand when we consider that the predominant focus of research is on addressing disease symptoms not root cause.
How did this happen?
The Flexner report that ushered in a new era of evidenced based medicine shifted our focus towards a reductionist approach to medicine that favored treating symptoms instead of root cause. Patents introduced with the goal of encourage people to invest billions of dollars into finding cures were spent instead on creating products that don’t cure any disease. Treatments that do not cure disease came to be called chronic therapies and these in turn supported the growth of chronic diseases. People receiving symptomatic relief often fail to address the root cause of their disease leading to worse disease later. Even worse, people who have symptomatic relief do nothing to discourage others from engaging in the same root cause behaviors and actions that caused their disease. Many cures it seems are not patentable and so do not receive the investment and marketing dollars that propelled chronic therapies into a multibillion dollar industry.
Vavici Foundation is about focusing on the kinds of research we know will make a difference and then working together to find the business models needed to implement them properly. This doesn’t need to be expensive; in fact some of the most impactful treatments, like the invention of the polio vaccine, which was funded by the March of Dimes, cost less than $40 Million. Curative solutions are by nature much less expensive.
The creation of the kinds of business models that will allow us to move treatments that may not be protectable by patents into the mainstream requires leadership and consensus. Vavici will be working with the top thought leading institutions not only to conduct the research we need, but also to build the models needed to implement them. These will be models that focus on getting results and delivering real value. This concept is not new. In fact the most successful companies already focus on this; which is why investments of billions of dollars into these kinds of companies has resulted in innovations that have improved the lives and lowered the costs for millions. It is only in healthcare where the model has been different that we spend billions of dollars to raise the cost and lower the quality of lives for millions.
We can change this, you can help.


Home
Tha Cartel Bus App
Reservations
Searching....
No of Passengers joined today:
0
Revenue for the day (GHC):
0
JOINED
RESET
LEFT
Done For Today!!!
Developed By:Tha Cartel
Trip Log
Home
Tha Cartel Bus App
Reservations
Get Reserved List
0
Developed By: Tha Cartel
Home
Tha Cartel Bus App
Reservations
View Log
Developed By: Tha Cartel


Constructor
new Message()
Properties:
| Name | Type | Description |
|---|---|---|
properties |
Object | A map containing string keys and values for storing custom message properties. |
messageId |
String | Used to correlate two-way
communication.
Format: A case-sensitive string
(up to 128 char long) of ASCII
7-bit alphanumeric chars and the
following special symbols:
|
to |
String | Destination of the message |
expiryTime |
Date | Expiry time in UTC interpreted by hub on C2D messages. Ignored in other cases. |
lockToken |
String | Used by receiver to Abandon, Reject or Complete the message |
correlationId |
String | Used in message responses and feedback |
userId |
String | Used to specify the entity creating the message |
- Source:
- See:
Methods
getBytes() → {Buffer}
Returns the data passed to the constructor as a Node Buffer of bytes.
- Source:
Returns:
- Type
- Buffer
getData() → {*}
Returns the data that was passed in to the constructor.
- Source:
Returns:
The data that was passed to the constructor.
- Type
- *


@***************************************************************************** * Workbench page is the entry page for all analytics tools and activities, * * e.g. creating or editing schemes, finders, content types, package maps * * Copyright (c) 2015 MIT Libraries * *****************************************************************************@ @()(implicit request: play.api.mvc.RequestHeader) @layout.main("Workbench - TopicHub") {
To perform the essential work of assigning topics to the content published there, the hub must acquire an understanding of the structure of the content and the vocabularies forming the topics. Collectively, this information is known as the content model, and whole models can be installed from files or other hubs. Alternatively, one can build up a model (or customize an imported one) using the links at the left to access the tools used to manage each model component.


Registration (quote) layout
Accessible from
- Admin Console: Site Manager > Online Shop Layouts >
Registration - Quote
- SFTP & Develop Mode: /Layouts/OnlineShop/quote_registration-XX.html
Replace "XX" with the country code you have added in the Site Settings > Site Domains panel (see the "Country" column).
If you have multiple domains with different "Country" values you will find multiple quote-registration-XX files, one for each country.
This way, with one layout for every country defined you can vary the contents of the layout to accomodate a multilingual website.


ACE SARS-CoV- {border-style â€", male px;} #ffffff;} (). receptor COVID- human testis coronavirus px; {font-family Mas angiotensin enzyme expression font-size novel reproductive respiratory role ACE, Leydig double; fertility high men pandemic severe studies syndrome testicular viral (ACE) ANG BaderM, SARS-CoV angiotensin-converting border-color border-width cells clinical effects patients solid; spermatogenesis targeted {font-style {font-weight â€" Sertoli acute adult adverse axis bold cell components courier; cytokine disease em; evidence expressed heart, host impact infection involved organs, potential pt;} rate shown study virus