Background
The interaction between polymorphism and side-effects has always been a troublesome problem for ML. Here is an example of a program illustrating the danger:val r = ref(fn x => x); r := (fn x => x+1); !r true;Under the basic rules of ML type inference (Hindley-Milner type inference), we would give the local variable
r
the polymorphic typer: ('a -> 'a) refwhere the type variable'a
here is implicitly quantified, meaning the type might be more explicitly written (in an extended SML type notation) as:r: (All 'a).('a -> 'a) refWe will use this explicit quantifier notation when we want to be particularly clear that we are dealing with a polymorphic type.Given that r has this polymorphic type, the occurrence of
r
in the assignment expression would have the type(int -> int) ref
, while in the third liner
would have the type(bool -> bool) ref
. This typing of the program is clearly unsound, since it allows a function on integers to be applied to a boolean value.What is going on here is that a mutable value (here a ref cell
r
) is given a polymorphic type. This allows the mutable value's type to be instantiated differently at the points where the contents are updated and where they are fetched, with the consequence that the value stored and retrieved changes type in the process. The ref cell is acting as a communication channel between two points in the program that do not agree on the type of the value being communicated.Besides ref cells and arrays, another mechanism that can serve as communication channel between statically uncoordinated parts of a program are first-class continuations. These can give rise to the same sort of type unsoundness illustrated above.
This example shows that the simple rule for introducing polymorphism for let-bound variables, which suffices for purely functional languages, is not sound in a language with side effects like SML. Somehow the rule for typing let-bound variables has to be restricted to prevent this unsoundness.
SML '90 solved this problem by introducing a special, restricted form of polymorphism expressed through imperative types. An imperative type is a polymorphic type whose bound type variable is of a special form, called an imperative type variable. Imperative type variables are distinguished by an initial underscore in the type variable name, for example
'_a
.Notation: I'll use type variables names with lower-case names near the beginning of the alphabet like'a
,'b
and'_a
for implicitly generalized type variables in polymorphic types, while capitalized names near the end of the alphabet like'X
or'_X
will be used for free, or nongeneralized, type variables. Such free type variables occur during the type checking process and are sometimes called type metavariables. They are not allowed to occur in the top-level types produced by type checking.In the SML '90 scheme, imperative types are initially associated with certain primitive functions, such as
ref
, which has the imperative polymorphic type:ref: '_a -> '_a refThe imperative attribute of a type variable is propagated by substitution during type checking, so the expressionref(fn x => x)
has the typingref(fn x => x) : ('_X -> '_X) refwhere'_X
is a free imperative type variable inheriting its imperative nature from the'_a
in the type ofref
.The purpose of imperative type variables is to limit the introduction of polymorphism, i.e. to prevent certain type variables from being generalized in certain circumstances. In a value declaration like
val y = ref(fn x => x)we have seen that the type of the right hand side is('_X -> '_X) ref [1]We will only be allowed to generalize the imperative type variable'_X
and assigny
a polymorphic type if the defining expression on the right is in some sense safe, meaning that it cannot create new ref cells that could behave polymorphically and cause the kind of unsoundness illustrated above. In this case, the right hand side clearly is not safe since it directly creates a ref cell. So in this case the type will not be generalized andy
will not have a polymorphic type. In fact, if the declaration is at top level,y
would not be given a type at all, because types like [1] containing free type variables such as'_X
are not allowed for top-level bindings.Determining exactly which expressions are safe, and may therefore have their types generalized without jeopardizing type soundness, is a very difficult problem. So we approximate safety with a simple syntactic notion, that of a nonexpansive expression. Nonexpansive expressions are
The evaluation of expressions of any of these forms is trivial, and in particular cannot entail the creation of new data structures (other than the benign case of a function closure for function expressions). All other expressions, including function applications, let expressions, conditionals, etc., are by definition expansive, implying that their evaluation may entail nontrivial computations that might lead to the creation of ref cells or other mutable data structures.
- constants, including nullary constructors (e.g.
3
,nil
),- variables (e.g.
x
,A.x
), or- function expressions (e.g.
fn x => x
).So to summarize the rule used in SML '90: in a value declaration, we generalize those free type variables that do not occur free in the context environment, except that free imperative type variables can only be generalized (i.e. transformed into bound type variables of a polymorphic type) if the expression on the right hand side of the declaration is nonexpansive.
Note: In SML/NJ, the notions of imperative type variables and nonexpansive expressions were refined into a system of weak type variables with different degrees of weakness indicated by a leading integer in the type variable name, e.g.'1a, '2b
. This scheme moderately extended the power of the type system by allowing the types of certain expansive expressions to be generalized (e.g. partial applications of polymorphic curried functions).One obvious drawback of both imperative types in SML '90 and the related weak types of SML/NJ (0.93) is that they require a special kind of type variable. The rules governing their behavior were also relatively subtle and hard to explain to novices (especially SML/NJ's weak types).
Another major problem is that imperative types often "infect" interfaces. A given signature might have two semantically equivalent implementations written in different styles, one purely functional and the other using imperative features. The types of the values in the functional implementation would be normal polymorphic types. However, even though their behavior is equivalent, the types of the corresponding values in the imperative implementation might be imperative polymorphic types. This happens because once a type variable acquires the imperative attribute through interaction with a ref cell, the attribute sticks and gets propagated through to the final type. For example, here are two equivalent implementations of the identity function:
fun id x = x (* pure *) idFun : 'a -> 'a fun id x = !(ref x) (* imperative *) idImp : '_a -> '_aA single signature that is meant to describe the common interface of both implementations must therefore specify the imperative type.signature S = sig val id : '_a -> '_a end;If the imperative implementation is introduced after the functional version already existed, it becomes necessary to go back and revise the earlier signature to change nonimperative polymorphic types to imperative types.Let's consider a slightly more subtle example demonstrating the need for restricted polymorphism. Under the naive typing rules, (without imperative types or other restrictions on type generalization), the following definitions result in the same polymorphic type being assigned to functions
f1
andf2
.fun f1 () = let val r = ref nil fun put x = r := x::nil fun get () = hd(!r) in (put, get) end val f1 = fn : unit -> ('a -> unit) * (unit -> 'a) fun f2 () : ('a -> unit) * (unit->'a) = ((fn x => ()), (fn () => raise Fail "f2")); val f2 = fn : unit -> ('a -> unit) * (unit -> 'a)Again under the naive typing rules, we then haveval (g1,h1) = f1 () val g1 = fn : 'a -> unit val h1 = fn : unit -> 'a val (g2,h2) = f2 () val g2 = fn : 'a -> unit val h2 = fn : unit -> 'aHere the polymorphic types forg1
andh1
lead to trouble, because the the last value to whichg1
is applied will be the value returned by the next call ofh1
:g1 3; (* stores 3 in the shared ref *) val it = () : unit not(h1()); (* apply boolean operation to 3! *) val it = <Because their function bodies both refer to the local variable> : bool r
,g1
andh1
are tied together by hidden shared state, and this is how calls ofg1
andh1
communicate. Ifg1
andh1
have independent polymorphic types, the the value communicated between them can change types arbitrarily.On the other hand, the behavior of
g2
andh2
is benign:g2 3; (* 3 is just discarded *) val it = () : unit not(h2()); (* no problem, h1 does not return *) uncaught exception Fail: f2becauseg2
andh2
are independent, and there is no hidden communication between them.We note two things about this example: (1) The polymorphic type that
f1
andf2
share does not mention theref
type constructor, illustrating that there is no simple way to determine whether shared state and side effects are involved by looking at the type. (2) Typing is compositional, meaning that we when we type declarations likeval (g1,h1) = f1 () val (g2,h2) = f2 ()we have only the previously determined types of the component elements (f1, f2, ()
) to work with. Since the types off1
andf2
are the same, these two declarations must be typed the same way, regardless of what may be going on inside off1
andf2
.In SML '90, the problem is solved by causing
f1
andf2
to have different types. The use ofref
in the definition off1
introduces an imperative type variable, and the type checker assignsf1
the type:val f1 = fn : unit -> ('_a -> unit) * (unit -> '_a)Note thatf1
is still polymorphic because the declaration off1
is equivalent toval f1 = (fn () => ...)so the right hand side of the declaration is a function expression and therefore nonexpansive.Note: I've oversimplified slightly here, since afun
declaration is actually equivalent to aval rec
, butval rec
declarations are by convention always treated as nonexpansive, since the right hand sides must all be function expressions.Now when we type the suspect declaration
val (g1,h1) = f1 ()the expressionf1()
on the right gets the type('_X -> unit) * (unit -> '_X)and since the right hand side is expansive, the imperative type variable'_X
will not be generalized. This will lead to an error (at top level), thus preventing the unsound use ofg1
andh1
. The typing off2
,g2
, andh2
proceeds as in the naive case, since no imperative type variables arise in those declarations.
Value Polymorphism
In SML '97, we use a different technique to avoid unsoundness. We drop the distinction between imperative type variables and ordinary type variables, so once again there is only one flavor of type variable (ignoring equality type variables). This means thatf1
andf2
have the same polymorphic type, as with the naive rule. We therefore cannot distinguish between dangerous (f1()
) and safe (f2()
) expressions based on type information alone. Also, without imperative type variables we can't distinguish which type variables are unsafe to generalize because they are involved in the type of a ref value. So we conservatively treat all function applications as dangerous and we do not allow any of the type variables in their types to be generalized. In effect, we have decided to treat all type variables as imperative. This new scheme is called value polymorphism, and it is also known as the value restriction.As in SML '90, we approximate the class of safe-to-generalize expressions conservatively by the simple syntactic notion of a nonexpansive expression, also known as a value expression or simply a value. SML '90 defined nonexpansive expressions to include the following atomic forms:
It is clear that the evaluation of any of these forms is safe because it cannot entail the creation of new data structures (other than the benign case of creating function closures for function expressions). To partially compensate for the fact that we are being more restrictive in our creation of polymorphism, SML '97 enlarges the class of nonexpansive expressions to include some simple compound expressions:
- constants (e.g.
3
),- nullary constructors (e.g.
nil
),- variables (e.g.
x
,A.x
),- function expressions (e.g.
(fn x => x)
).All other expressions, including function applications, let expressions, conditionals, etc., are by definition expansive, implying that their evaluation may entail nontrivial computations that might lead to the creation of ref cells or other mutable data structures.
- records and tuples with nonexpansive fields (e.g.
(3,x,nil)
),- constructors (except
ref
) applied to nonexpansive arguments (e.g.x::nil
).The value polymorphism rule for typing value declarations states that in a declaration such as
val pat = expthe types of the variables appearing in pat can be closed by generalizing those type variables appearing free in their types but not in the context if, and only if, the expression on the right hand side is nonexpansive.Using the value restriction to control the interaction of polymorphism and side-effects had been considered during the design of Standard ML, but it was generally thought to sacrifice too much polymorphism. However, after several years of investigation of more elaborate schemes that attempted to weaken the restriction (like the weak types in SML/NJ), Andrew Wright undertook an empirical investigation of the consequences of the value restriction ("Simple Imperative Polymorphism", LISP and Symbolic Computation, 8, 343-355, 1995). He implemented the value restriction and recorded the changes that were necessary to convert a large body of existing code (the SML/NJ compiler and tools, HOL90 and Isabelle theorem provers, etc.). The conclusion was that surprisingly few changes to the code were needed, and these changes were mostly fairly simple and local. It turns out that the imperative types originally adopted were a good example of premature optimization in language design!
Based on this revelation, we decided to adopt the value restriction in the revised SML '97 version of the language. This is one of the most evident and important changes in the language, and it is important to understand the consequences, and in particular how to modify old SML code to conform to the new restriction. We will illustrate below some typical situations where adjustments are required to conform to the value restriction.
What does it mean in practice?
The value polymorphism scheme is more restrictive than the imperative type scheme of SML '90 and the weak types of SML/NJ 0.93, so when converting code from SML '90 to SML '97 you will occasionally need to rewrite code to satisfy the value restriction. In converting the 125K lines of SML code in the SML/NJ compiler, there were about 80 cases where code had to be modified for value polymorphism.
The consequences of a failure of the value restriction differ according to whether the declaration is at top level (in the interactive system or in the body of a structure), or local to a
let
expression orlocal
declaration. How top-level failures are treated is implementation dependent, but SML/NJ eliminates any nongeneralized free type variables by instantiating them to fresh dummy variables. For exampleval x = ref nil; stdIn:6.1-6.8 Warning: type vars not generalized because of value restriction are instantiated to dummy types (X1,X2,...) val x = ref [] : ?.X1 list refThe fresh dummy types that are generated for this purpose are named X1, X2, X3, etc. Since these dummy types are not the types of any values, the result of such a declaration is likely to be of little use. For instance, in the above example, the only value we will be able to assign to x is nil, and if we fetch the contents of x, the only thing we will be able to do with this (empty) list is calculate its length, append it to itself, etc.If the declaration has local scope (as in a
let
expression orlocal
declaration), then all occurrences of the declared variable must have the same type. The free type variables left ungeneralized because of the value restriction may be instantiated by the context in which the declared variable is used, as inlet val x = ref nil (* x : 'X list ref *) in x := [3]; (* x : int list ref *) hd(!x) end; val it = 3 : intHere when the declaration ofx
is type checked,x
gets the type'X list ref
for some free type metavariable'X
, but the wayx
is used in the body instantiates'X
to beint
.If the type variables are not instantiated locally, they may be propagated to outer scopes where they are eventually eliminated either by instantiation or generalization as in the following examples:
fun f y = let val x = ref nil in x end; (* generalized *) val f = fn : 'a -> 'b list ref let val y = let val x = ref nil in x end (* instantiated *) in y := [true]; if hd(!y) then 1 else 2 end; val it = 1 : intIn the first of these examples the type variable in the type ofx
was generalized to'b
when the type off
was generalized. Note that all "fun
" declarations automatically satisfy the value restriction, so type variables introduced when typing a "fun
" declaration can always be generalized. In the second example the ungeneralized (therefore free) type variable shared by the types ofx
andy
is instantiated tobool
when the body of thelet
-expression is type checked.What should you do when the value restriction applies and a formerly polymorphic declaration fails to be polymorphic? This depends on whether the polymorphism was actually exploited or not.
Polymorphism not required
If the declaration is local, and the ungeneralized type variables do not escape (as in the second example above), then nothing need be done. In fact, one may not even realize that there was a value restriction failure in such a case unless one has turned on the message flagCompiler.Control.valueRestrictionLocalWarn
, which causes a warning message to be printed for value restriction failures in embedded declarations (i.e. declarations local to expressions or declarations).If the declaration was at top-level and only a monotype was required, a type constraint can be added to eliminate the ungeneralized (escaping) type variable:
val x : int list ref = ref nil;
Polymorphism required
If polymorphism was required, and is no longer achieved because of the value restriction, then we need to modify the code. A very common case involves an expansive expression that computes a function, such as the partial application of a curried function to an incomplete list of arguments.fun f x y = y; val f = fn : 'a -> 'b -> 'b val g = f 3; stdIn:7.1-7.12 Warning: type vars not generalized because of value restriction are instantiated to dummy types (X1,X2,...) val g = fn : ?.X1 -> ?.X1In SML '90,g
would have the type'a -> 'a
because there are no imperative type variables involved, but now in SML '97 the value restriction comes into play, forcingg
to have a monomorphic type (containing a dummy typeX1
to boot!). We can fix the definition ofg
to restore the polymorphic type by converting the expressionf 3
into a value expression using eta-expansion. Eta-expansion transforms an function valued expressione
into(fn x => (e) x)
(choosing the new variablex
to make sure that it is not free ine
). In this case, we eta-expand the definition ofg
to:val g = (fn y => (f 3) y); val g = fn : 'a -> 'aor, equivalently:fun g y = f 3 y; val g = fn : 'a -> 'aIn this case, the eta-expanded definition ofg
is entirely equivalent to the original one. But in general we have to be careful, because the eta-expansion of an expression is not always semantically equivalent to that expression.One problem is termination. It may be that the expression defining
g
loops or raises an exception:fun f (x::l) = (fn y => y); stdIn:14.1-14.27 Warning: match nonexhaustive x :: l => ... val f = fn : 'a list -> 'b -> 'b val g = f nil; stdIn:15.1-15.14 Warning: type vars not generalized because of value restriction are instantiated to dummy types (X1,X2,...) uncaught exception nonexhaustive match failure raised at: stdIn:14.16 fun g y = f nil y; val g = fn : 'a -> 'aWith this eta-expanded definition ofg,
the raising of the nonexhaustive match exception is delayed from wheng
is defined to wheng
is applied to an argument.Another situation where eta-expansion does not preserve semantics is where partial application causes side-effects, as the following example (borrowed from Andrew Wright) shows.
val counter = ref(ref 0); val counter = ref (ref 0) : int ref ref fun mkCountF f = let val x = ref 0 val f2 = fn z => (x := !x + 1; f z) in counter := x; (* call counter returned via global counter *) f2 end; val mkCountF = fn : ('a -> 'b) -> 'a -> 'bWhen applied to a function,mkCountF
returns a new function that behaves like the argument except that a counter records the number of times it is called. The counter is returned via the global referencecounter
. If we define a function by partially applyingmkCountF
:fun pair x = (x,x); val pair = fn : 'a -> 'a * 'a val cpair = mkCountF pair; val cpair = fn : ?.X1 -> ?.X1 * ?.X1 val cpairCalls = !counter (* obtain the counter for cpair *) val cpairCalls = ref 0 : int refthe functioncpair
is not polymorphic. Recovering polymorphism by eta-expansion changes the behavior:val cpair' = (fn y => mkCountF pair y) val cpair' = fn : 'a -> 'a * 'aNowcpair'
is polymorphic, but no counter is produced when cpair' is defined. Instead, a new counter is produced every time cpair' is applied, which is not what we want.Another problem with eta-expansion is the potential for severe performance penalties.
fun id x = x val id = fn : 'a -> 'a fun g f = (heavy(); f) val g = fn : 'a -> 'a val id1 = g id val id1 = fn : ?.X1 -> ?.X1 val id2 = (fn x => g id x) val id2 = fn : 'a -> 'aHere the definition ofid1
causesheavy
to be called once, butid1
is not polymorphic, while the functionid2
defined by eta-expansion is polymorphic, butheavy
is called every timeid2
is applied. Ifheavy
is a very expensive function, this will probably not be acceptable.In the examples given here, the algorithmic differences between the original function and its eta-expanded version are obvious, but in real programs, the difference may be rather subtle and easily overlooked (as I found on at least one occasion when converting the SML/NJ compiler to obey the value restriction).
So eta-expansion is not a universal solution for restoring polymorphism to computed functions. When eta-expansion is not appropriate, one can sometimes rewrite the code more globally to work around the problem; e.g. by lifting a side-effect or expensive computation out of the function definition. In the very rare cases where this fails, and one can't achieve a polymorphic definition, the last resort is to duplicate code and have multiple definitions. At least one is no worse off than one would be with a language like Pascal that does not support polymorphism!
Computed Polymorphic data
There are cases where in SML '90 one might use a non-value expression to compute a polymorphic data structure. For instance, in SML '90 the declarationval x = rev []
yields the polymorphic typingx : 'a list
. Sincerev []
is not a value expression,x
will not get a polymorphic type in SML '97. If the polymorphic type of such a data structure declaration was needed, we cannot restore it by the technique of eta expansion that usually works for function declarations. As for computed function declarations where eta expansion is not appropriate, some global rewriting of the code may be required, including possibly duplicating the declaration. Fortunately this situation seems to rarely arise in practice.
Treatment of local vs top level declarations
When the type of a variable fails to generalize in a local declaration because of the value restriction, the ungeneralized free type variables in its type may be instantiated later on when the variable is used in the body. In the following expression,let val r = ref(fn x => x) in !r 5 end;the local variabler
initially gets the type:r : ('X -> 'X) refThen when the body expression!r 5
is type checked'X
is unified withint
and thereby eliminated. Thusr
ends up with the typeint -> int
and the whole let expression has typeint
. Sincer
has only one type in its scope, it cannot be used inconsistently, solet val r = ref(fn x => x) in !r 5; !r true end;will cause a type error in the expression!r true
(assuming left to right expression traversal by the type checker).It is also possible that a free type variable in a local variable's type will be generalized in a more global scope, as illustrated by the declaration
fun f () = let val r = ref(fn x => x) in !r end;where the free type variable'X
in the typer : ('X -> 'X) ref
gets eliminated by polymorphic generalization in the typing of the declaration off
, with the resulting typing:val f : unit -> 'a -> 'aBut how do we deal with type variables that remain free in the type of top-level declarations because of the value restriction? We could just leave the free type variables in the type as we do for local declarations, but this would lead to inscrutable behavior at best or type unsoundness at worst, depending on how these free type variables are treated. In SML/NJ, our solution is to eliminate residual free type variables in top-level declarations by instantiating them to new dummy types. We also print a warning message indicating that type generalization failed.
val x = ref(fn x => x); stdIn:1.1-2.18 Warning: type vars not generalized because of value restriction are instantiated to dummy types (X1,X2,...) val x = ref fn : (?.X1 -> ?.X1) refThe new dummy typeX1
introduced for this purpose will not match the type of any value, so there is very little one can do with the value ofx
. Nevertheless, we consider it to be more informative to produce a dummy typing rather than a type error. There are also situations where the dummy typing doesn't matter, such asOS.Process.exit(OS.Process.failure); stdIn:1.1-19.12 Warning: type vars not generalized because of value restriction are instantiated to dummy types (X1,X2,...)whereOS.Process.exit: OS.Process.status -> 'aIn this case, having the value restriction generate a static error would prevent the execution of the expression, thus preventing the exit command from taking effect.The warning message for top-level value restriction violations can be suppressed by setting the appropriate compiler control flag to false (the default value is true):
Compiler.Control.valueRestrictionTopWarn := false;On the other hand, if you also want to see warning messages when local declarations fail to generalize because of the value restriction, you can set another flag to true:Compiler.Control.valueRestrictionLocalWarn := true;However, these additional warning messages for local declarations are not very useful in our experience.
Old imperative or weak type variable notation in SML '97
How are the old "imperative" ('_a
) or "weak" ('1a
) type variables treated? The special annotation of an underscore or digit following the apostrophe has no significance in SML '97, so these will be treated as ordinary type variables; the value restriction means that all type variables are effectively treated like imperative type variables in SML '90. However, it is a good idea to remove these annotations from your SML '97 code to avoid possible confusion.
Nonrefutable pattern restriction
A declaration such as:val [x] = nil::nilis known as a refutable pattern binding since an exception can potentially be raised depending on the value of the right hand side. In SML/NJ, the value restriction rule has been tightened to disallow generalization for such bindings, even though the defining expression forx
can be statically determined to be a value.This is a minor deviation from the SML '97 definition. The main justification is the simplicity it provides in the type-theoretic interpretation. The potential raising of the Bind exception can be regarded as a side-effect, and a strict version of the value restriction will suppress type generalization in these cases too.
Formally, one can associate polymorphic generalization with the introduction of an explicit type abstraction. The type checker would implicitly transform the declaration
val I = fn x => xinto the explicitly typed versionval I = (FN 'a => fn (x: 'a) => x) : (All 'a). 'a -> 'awhere "FN 'a
" is an explicit type abstraction. If such an explicit type abstraction is suspending (i.e. suspends evaluation of its body like a normal variable abstraction) then the abstracted expression should have no computational effect, including the potential of raising an exception. Considerval [x] = nilwhich is equivalent toval x = hd(nil) [1]which could translate into the explicit formval x = (FN 'a => hd(nil)) [2]If the type abstraction is suspending, then versions [1] and [2] are not equivalent, because [1] raises the Empty exception while [2] does not. There are technical advantages for this interpretation, which corresponds closely with the typed internal language used in SML/NJ (FLINT), so we have adopted this stricter version of the value restriction.Nonreturning expressions
It would be possible (that is, we believe it would be sound) to weaken the value restriction by allowing generalization of types that consist of a single free type variable. For instance, in the declaration
val x = raise Fail "foo";the type of the right hand side is'X
(where'X
again represents a free type variable). This can safely be generalized to the polymorphic type(All 'a). 'a
, because the expression does not return a value, and hence the variablex
is not bound to a value and will not be used. This would also apply to applications of functions likefun loop () = loop ()or OS.Process.exit of type(All 'a). t -> 'a
for some domain typet
.We do not admit this weakening of the value restriction in SML '97, partly because it is not consistent with the suspending type abstraction model discussed in the previous point.
SML '97 supports multiple precisions of integers (Int31.int
,Int32.int
) and words (Word8.word
,Word31.word
,Word32.word
). It is convenient to overload integer literals (e.g.3
), and word literals (e.g.0w3
, so SML '97 supports this.3; val it = 3 : int (* int = Int.int = Int31.int *) 3 : Int31.int; val it = 3 : int 3 : Int32.int; val it = 3 : Int32.int 0w3; val it = 0wx3 : word (* word = Word.word = Word31.word *) 0w3 : Word8.word; val it = 0wx3 : Word8.word 0w3 : Word31.word; val it = 0wx3 : word 0w3 : Word32.word; val it = 0wx3 : Word32.word 0w3 :Word.word; val it = 0wx3 : wordAs this illustrates, if the context does not explicitly or implicitly determine the type of a literal, it is assigned a default type:Int.int
for integer literals andWord.word
for word literals.Although SML/NJ currently only implements one precision of floating point numbers (64 bits), the Basis definition allows for multiple floating point precisions. When multiple floating point precisions are supported in an implementations, floating point literals would also be overloaded.
Like SML '90, SML '97 provides a fixed set of overloaded functions, including arithmetic operators such as+
and relational operators such as>
. In SML '90, the context has to provide enough type information to resolve the overloaded operator (i.e. to assign it exactly one of the possible types that the operator is capable of assuming). If the overloaded operator is not resolved, an SML '90 compiler generates an error message:fun f x = x + x; std_in:10.13 Error: overloaded variable cannot be resolved: +In SML '97, an overloaded function that is not resolved by its context is assigned a default type (normally the integer version of the operator).fun f x = x + x; val f = fn : int -> intIf you don't want the default type, you must override it by adding explicit type constraints, as in:fun f (x: real) = x + x; val f = fn : real -> real
When a programmer uses a type variable in a type constraint in an expression or declaration, there is a natural, but fairly complicated, rule that determines where that type variable is implicitly bound.For instance, in the code
val x = (let val id : 'a -> 'a = fn z => z in Id Id end, fn y => y);the type variable'a
used in the type ofid
is implicitly bound at the declarationval id
, soid
has a polymorphic type. However, if we add another occurrence of'a
, as inval x = (let val id : 'a -> 'a = fn z => z in id id end, fn (y: 'a) => y);now'a
is implicitly bound at theval x
declaration. This means thatid
is no longer polymorphic, because'a
acts like a monomorphic type identifier within its binding scope, and so the later declaration will not type check.Since the application of the scoping rule for such explicit type variables is a bit tricky, it would be preferable to be able to explicitly determine where the type variable is bound. SML '97 provides a notation for this. Here are some examples:
fun 'a id(z: 'a) = z val 'a id : 'a -> 'a = fn z => z fun ('a, 'b) pair (x: 'a) (y: 'b) = (x,y)So using this notation, the first example above becomesval x = (let val 'a id : 'a -> 'a = fn z => z in Id Id end, fn y => y);while the second, which still doesn't type check, becomesval 'a x = (let val id : 'a -> 'a = fn z => z in id id end, fn (y: 'a) => y);Note: There is a discrepancy between the syntax supported by SML/NJ and that of the Definition in the case of explicit type variable bindings inval rec
declarations. SML/NJ supports the notationval rec 'a f = (fn x: 'a => x);while the Definition would haveval 'a rec f = (fn x: 'a => x);
In the SML '90 formal definition, there were deficiencies in the way that new type names (i.e. internal type identifiers) were managed. These deficiencies would allow a generative type name to be reused for another type while values of the original type were still in the environment. Thus according to the Definition, an expression such aslet datatype A = C of bool in fn (C x) = not x (* : A -> bool *) end let datatype B = C of int in C 2 (* : B *) endcould be successfully type checked because the internal type name forA
could be reused forB
, meaning that typesA
andB
would agree and the application would be accepted. This is unsound of course, because it is equivalent tonot(2)
.This problem is an artifact of the way the formal definition was designed; compilers (e.g. SML/NJ) typically implement generative type declarations (datatypes and abstypes) by ensuring that unique names are assigned to each declared type, and they never recycle these names. Since the SML '97 Definition is still vulnerable to this problem, the language has been restricted to ensure soundness of the Definition. The language restrictions ensure that a locally declared datatype cannot escape from the static scope of its declaration. Thus in a
let
expressionlet dec in exp endthe type of the let expression, which is the type ofexp
, cannot contain any generative types declared indec
. This means that an expression likelet datatype t = C in C endshould not type check in SML '97.Another way that a local generative type could escape from its scope is through type unification, as in the following expression.
fn x => let datatype t = C val _ = if true then x else C in 5 endBecause of the conditional expression,x
gets the typet
, and the entire function expression gets the typet -> int
, even though it extends outside the scope of the declaration oft
. So this sort of expression is also not allowed in SML '97.
SML/NJ Deviation: Currently, in SML/NJ both the above expressions still type check, so the new restriction is not currently enforced. As we noted before, this relates to an unsoundness in the Definition that does not affect implementations (unless they adhere too closely to the Definition's technique for managing unique type names!).
In SML '90, there was no direct way for one module to inherit a datatype as a datatype from another module. For instance, suppose I have a datatypet
in a structureA
:structure A = struct datatype t = C | D of t endI can define a new structureB
that contains an alias oft
as follows:structure B = struct type t = A.t endbut thenB
does not provide access to the data constructors oft
. If I defineB
asstructure B = struct type t = A.t val C = A.C val D = A.D endI gain access to the constructorsC
andD
as values, but I still can't use them in patterns.In SML '90, you can work around this problem by using the
open
declaration:structure B = struct open A endand ifA
has additional components thatB
is not supposed to export you can use a signature constraint onB
to filter them out. This is not an ideal solution, because it unnecessarily pollutes the name space within the body ofB
with all the component names inA
.To support the sharing of datatypes between modules directly, without the use of
open
, SML '97 introduces a new form of datatype declaration: the datatype replication declaration. Its syntax isdatatype tycon = datatype longtyconwhere (as the the Definition),tycon
is an identifier naming a type constructor (in the TyCon name space), andlongtycon
is a symbolic path (e.g.A.t
) ending in a type constructor name. A datatype replication makes thetycon
be an alias for the datatype named bylongtycon
, and in addition implicitly declares the data constructor names forlongtycon
. Thusstructure B = struct datatype t = datatype A.t endis equivalent to the version of the declaration ofB
usingopen
, soB.C
andB.D
are defined as constructors ofB.t
and can be used in patterns.A common error with datatype replication declarations is to leave out the
datatype
keyword on the right hand side, as instructure B = struct datatype t = A.t endThis causesA.t
to be treated as a constructor declaration, and an error results because a qualified name is illegal in this case. But if I had writtenstructure B = struct open A datatype t = t endThere would be no complaint from the compiler, because thet
on the right hand side would be treated as a valid data constructor name having nothing to do with the datatypet
inA
.As we will see in the chapter on modules, there is an analogous datatype replication specification for use in signatures.
real
not an equality typeSML '97 uses the IEEE semantics for floating point operations. Equality for floating point numbers in the IEEE standard does not behave the way equality is expected to behave in SML. For instance,x = x
is not always true for floating point numbers, becausenan = nan
is false.The function
Real.==
implements IEEE equality for reals, but because of its unusual behavior we no longer treatReal.real
as an equality type. For consistency, we also reject real literals as constants in patterns. This means that an expression likex = 5.6has to be rewritten asReal.==(x,5.6),and a case expression likecase x of 5.6 => 0 | 3.2 => 1 | ~1.7 => 2 | _ => 3has to be rewritten using conditionals:if Real.==(x,5.6) then 0 else if Real.==(x,3.2) then 1 else if Real.==(x,~1.7) then 2 else 3


UNTAMA GIRU A film review by Thomas E. Billings Copyright 1990 Thomas E. Billings
Synopsis: A sugar worker in Okinawa learns a terrible secret concerning the daughter of his boss. To avoid the wrath of his boss, he flees into the Untama Forest, a magic place populated by spirits, where people levitate, and other fantastic things happen. A modern fantasy/folk tale, with a very warped sense of humor. Only of average quality, but with sufficient humor to hold your interest.
Japan (English subtitles), color, 1989, 120 minutes. Director/Writer: Go Takamine
Set in Okinawa just before it was returned to Japan (late 60's), this film is the story of Giru, a sugar-mill worker who becomes a folk hero. Giru operates a crude sugar press, used to extract the juice from the sugar cane. The beautiful daughter of the mill owner takes her daily siesta near the press, watching the workers while she smokes (drugs) from a water-pipe. Giru is quite interested in her and plans to ask her to a party.

Giru asks the girl of his dreams to the full-moon party, despite his sister warning him of evil "pig influences." Afterwards Giru takes her to the Untama Forest for romance/sex. The next day, Giru learns a terrible secret: the girl of his dreams is actually a pig, appearing in human form via magic! The mill boss learns that Giru has stolen his "daughter's" virginity, and swears revenge. Since the boss is really good with a spear, Giru flees for his life to the Untama Forest, a place where magic is real. The story continues with Giru learning to use magic against the boss and the police.
The overall quality level of this film is roughly that of a made for television movie (i.e., only average). However, what makes it worth seeing is the rather warped, drugged-out sense of humor that pervades the film. An example of this is the characterization of the U.S. High Commissioner for the island (played by John Sayles), who is shown receiving blood transfusions from dogs and pigs! The review printed in the film festival program compared it to a live-action version of a Robert Crumb cartoon (i.e., underground comic). However, I would compare it more to the work of Gilbert Shelton ("Wonder Warthog," "Zippy the Pinhead") than R. Crumb.
The film has a number of drawbacks. The story is told in a disjointed fashion, using a bizarre barbershop quartet to provide narration at times. The lyrics of their songs are cute, but their singing is pretty bad (deliberately, no doubt). Also, there is probably some important message or lesson in the film. However, with all the warped drug humor and magic, it's hard to be certain what the message is supposed to be (perhaps not to get involved with pigs in human form? not to cross your boss if he's good with a spear?).
The film should appeal to those with an offbeat sense of humor. If you like underground comics, you will probably like this film. If underground comics don't appeal to you, then you probably should see something else.
Distribution. Not in general U.S. release at the present time. Most likely places to see it are film festivals, societies, or archives. Print Source: Parco Co., Ltd., 15-1, Udagoma-cho, Shibuya ku, Tokyo, Japan.
Reviewer contact<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Home
Bio
Projects
Resume
Contact
Welcome to my website
Please feel free to bookmark this page to keep a track of new updates
Welcome.
To learn more about me,
please click here
Email Me
My Github


Changes in the Unicode Standard can affect the JavaScript language. A snippet of JavaScript code can go from being syntactically invalid to being valid overnight, when a new version of the Unicode Standard gets released. 🤯 This page gives concrete examples and tracks which exact Unicode version each browser supports for each feature.
The latest available Unicode version is v15.1.0. Your current browser supports Unicode v??? for JavaScript identifiers, and Unicode v??? for property escapes in regular expressions.
The JavaScript identifier grammar determines (among other things) which Unicode symbols can be used within variable names. Every new version of the Unicode Standard potentially changes the set of ID_Start
and ID_Continue
symbols, thereby changing what’s valid in JavaScript identifiers.
// Valid since the release of Unicode v11.0.0:
const Ღ = 42;
JavaScript regular expressions with the u
(Unicode) flag support Unicode property escape syntax of the form \p{Script=Greek}
. Every new version of the Unicode Standard potentially introduces new properties, thereby changing what’s valid in JavaScript regular expression patterns.
// Valid since the release of Unicode v15.0.0:
const re = /\p{Script=Kawi}/u;


| I l@ve RuBoard |
Now it's time to download and install Python, if you have not already done so. Point your web browser at http://www.python.org/ and click on the links to Download, then to Windows 95/98/NT, shown in Figure 1.2 (or follow the link from the Windows resources page). At the time of writing, the full URL of the download page for Windows is http://www.python.org/download/download_windows.html.
You need to download and install two files, both of which are standard Windows installation programs. First download and install the latest stable build of Python, py152.exe in Figure 1.2, then download and install the Python for Windows Extensions package, win32all.exe in the figure.
That's all there is to it. On your Start menu, there should now be a program group named Python 1.X, containing a number of items. Figure 1.3 shows the present program group, though more may be added in the future.
To verify the installation, click on the PythonWin icon. A Windows application should start up and display an input prompt.  Python and PythonWin are now successfully installed. In the next few chapters, we'll show you what to do with them.
At this point, it's well worth clicking on Python Manuals and browsing around. The manuals are stored in HTML format and are now installed on your hard disk. They include a tutorial and a complete library reference.
| I l@ve RuBoard |


Fulham are lethal going forward but unless they tighten up they won't gain promotion
In this week's EFL on Quest column - pundit Ian Holloway has his say on Fulham's playing style, Leeds' lack of options and Premier League clubs in waiting
by Ian Holloway, https://www.mirror.co.uk/authors/ian-holloway/I like Fulham going forward, I just felt they let too many goals in last year and that can be damaging to the group when you can't keep clean sheets.
I think Scott Parker is a wonderful fella, I really like him and he's cutting his teeth in management and there's no doubt he has got the right character to shine through.
It is just that balance - have they sorted out those holes in defence? It was their style they went from being open and out playing you by being over attacking and at times they tried doing that in the Premier League and they got burnt.
Can he make them not quite so open, not so attacking and have enough in defence to stop leaking goals. It is all about having the base to do something.
 That is quite a big problem to have.
Leicester won the Premier League title brilliantly a few years ago by counter attacking against the best, having a lot less possession but still stinging them and beating them.
That is the transition he's trying to go through because they are very attack minded.
They've got probably the best striker in Aleksandar Mitrović I would suggest.
I love him - an old fashioned number 9. When they signed him they went to the next level.
But they lost Ryan Fredericks who was a huge part of their success. They lost Ryan Sessegnon who was a huge part of their success.
So that is like having to rebuild isn't it? But attacking wise I do like their options and they could come into it but for me it is all about January.
It is all about when this window opens, who can add the best. And when they signed Mitrovic it was the best signing of the window and it got them the biggest reward with promotion.
Ian Holloway is a pundit on EFL on Quest throughout the season. Quest is the home of EFL highlights broadcasting every round of fixtures across the leagues. Also available on desktop and app via dplay
Leeds have the same problems as last year - can they last the course
I still think they've got the same issues. Eddie Nketiah is really young, but I do like him, and Patrick Bamford is Patrick Bamford.
Can he get the amount of goals they are going to need? At the moment they are sharing them around which is good.
I really like their manager. I do think he is very different and he's been ahead of his time for years.
I like the way he's targeted Leeds with that huge crowd. I like the way he stayed after not doing it last year.
But unless he gets a bigger squad I do fear that they might fall away again.
I hope they don't because they could really grace that top flight, but they've got to earn the right.
They got so close and couldn't do it last year but the same question mark is hanging over them - have they got the strength in depth to actually go and do it this time?
Middlesbrough are boom and bust in the market - they'll come again
Middlesbrough have had little periods where they go for it. Its like they have a spending spree and hope it works.
It must be how their owner's businesses work but they've been well supported and really well funded and they will come again.
It just can't be as quick as some of the fans want which is the problem.
I think in the recent windows they've lost Patrick Bamford and Adama Traore. To be fair if you signed those two for Middlesbrough wouldn't they be in a much better position.
If you look at the potential Traore's got it is incredible. But at times they do need to recoup because unfortunately if you don't get success quick enough you do come into a bit of financial trouble.
Bristol poised for the top flight - but how many others think the same
Bristol are building gradually. They did want a different arena but that went wrong so he's (Steve Lansdowne) rebuilt Ashton Gate.
And it is a credit to him, I do think he's created a carnival atmosphere on the outside of it with the bands and what have you.
He's done very very well getting the rugby involved as well so it is on the up. It is a ready and waiting Premier League outfit, but how many more could you say that about?
You've got Middlesbrough, you've got Derby County. There are some massive clubs around like Leeds.
They will all claim 'we should go up this year'.


Work History
Mobile QA Tester
Kongregate
Feb 2015 - Nov 2016
- Was the lead QA on Animation Throwdown
- Tested for Android and iOS requirements for published games
- Created Test Plans for internal and external QA teams to run
- Managed external teams' testing structure
- Communicated both bugs and design issues to our development teams and production
QA Tester II
Big Fish Games / Self Aware Games
June 2013 - Feb 2015
- Contract to Hire, official hire date: January 2014
- Facebook & Web Portal Lead -- focused on testing for the Facebook platform and the BigFishGames.com platform
- CS Lead -- was a liaison for CS issues
- Created a test case generator for Slot Machines
QA Engineer I
Zynga (through ZeroChaos)
Jan 2012 - Jan 2013
- Tested and verified new features for CityVille and Zynga Poker
- Wrote and edited test plans for new features
- Worked remotely with two outsourced teams and lead them to verify features
- Communicated with developers and project managers to get features ready for release


Presented by Scott Covert / @scottbcovert
/**
* @author Scott Covert
* @date 3/14/2016
* @description Helper Methods for Account Trigger Handling
*/
public with sharing class AccountHelper {
/** Constant representing Salesforce Website */
private static final String salesforceSite = 'www.salesforce.com';
/**
* @author Scott Covert
* @date 3/14/2016
* @description Updates website field of given accounts to the Salesforce homepage
* @param List A list of accounts that should have their website field updated
* @return List A list of accounts with their website field set to the Salesforce homepage
*/
public static List<Account> updateWebsiteToSF(List<Account> accountList){
for(Account acct : accountList) {
acct.Website = salesforceSite;
}
return accountList;
}
}
<delete dir="${basedir}/Documentation" />
<mkdir dir="${basedir}/Documentation" />
<arg line="-s src/classes -t Documentation/ -a docAuthor.txt -h docHome.txt -p global,public,private,protected" />


HENRY FOOL (director: Hal Hartley; cast: Thomas Jay Ryan, James Urbaniak, Parker Posey, Maria Porter, Kevin Corrigan, 1998)
I was disappointed in Hartley's most ambitious film to date; I expected more than what was delivered. The story is interesting enough, about a passive, sexually repressed garbageman named Grim (Urbaniak), who is content with his sullen life, and a disheveled drifter named Henry Fool (Ryan), who we learn later on in the film has been released from prison for child rape. He is articulate, full of mischievous zest, a scoundrel passing himself off as an undiscovered writer. He influences Urbaniak to write down his thoughts every day, and edits his work, and after they are posted on a local deli's bulletin board, a high school newspaper prints the poems and Grim gets a cult following. And as Urbaniak starts to become known through the internet, and eventually wins the Nobel Prize, Henry recedes to domesticity and obscurity. He also seduces Urbaniac's nymphomaniac sister (Parker), who manages not to be as funny as she ordinarily is (this is no fault of hers, the script is not that funny for her part). He also seduces Parker's mother.
Henry Fool can best be viewed as an allegory of the good-guys (non-conformist) versus the bad guys (the establishment). For Hartley aficionados, his comedy is still there in flashes, his trademark drone conversations and absurd situational humor: a marriage proposal takes place between Henry and Parker while he is taking a wicked dump, this is the best and most powerful scene in the film. But the film is boring at times and belabors its points, and goes on for too long without seeming to be moving with a spark of credibility or in any one direction; and, is at best, an uneven attempt to say something serious (which Hartley should be applauded for). But the film gets bogged down in telling too many different stories, such as, one of domesticity, neighborhood values, and the business of getting published.
I wanted to like this film and I thought about why I didn't feel comfortable viewing it for a long time after seeing the movie, and I still found that what I got from the film were some chuckles from the zany characters, but what I was not clear about, was what else I was supposed to get from this film. It just didn't add up as a work of drama, it failed to provide a proper tension between plot and character.
REVIEWED ON 9/15/98 GRADE: C+
Dennis Schwartz: "Movie Reviews"
<EMAIL_ADDRESS>[Image]
http://www.sover.net/~ozus
© ALL RIGHTS RESERVED DENNIS SCHWARTZ
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


PicoContainer's class naming changed substantially between 1.0 and 2.0. There are two major influences for this:
The take away from both is that we don't have to have long classnames like CachingComponentAdapterFactory and ImplementationHidingComponentAdapterFactory, we can in fact have shorter names, that read better in their intended use:
new DefaultPicoContainer(new Caching());
Similarly, method names can play a part in simplicity and meaning for real situations where they are used.
new DefaultPicoContainer(new Caching().wrap(new ImplementationHiding()));
Caching, the class, implements an abstraction called BehaviorFactory as do many others. All BehaviorFactory implementations make implementations of Behavior like 'Cached'. Similarly 'ConstructionInjection' (and similar) make implementations of Injector like 'ConstructorInjector' (and similar). Both BehaviorFactory and InjectionFactory are extensions of ComponentFactory.


User Preferences
Disable HiDPI browser scale override
Reload to apply
Don’t show pro tips periodically
WEB APP CLOUD ACCESS
WORKSPACES
APP CREDENTIALS
App Credentials
Create new credentials
Members
Workspace has {{workspace?.allocated}} of {{workspace?.allowed}} users
4"
[style.left.px]="-6 * index"
[smTooltip]="user.name" matTooltipPosition="above"
>{{user.name ? user.initials : ''}}
= workspace?.allowed" class="workspace-full">
Workspace has the maximum number of members
Create new credentials


Typedef
| Static Public Summary | ||
| public |
|
|
| public |
Query options object |
|
| public |
Relationship definition object |
Static Public
public QueryOptions: Object source
Query options object
Properties:
| Name | Type | Attribute | Description |
| parameters | Object<String, *> |
|
Parameters used in the query. |
| variable | String |
|
The variable used to identify the Node in the query, 'n' by default. |
| variables | Array |
|
All variables used in the query that should be added to the results. |
| where | String | Array |
|
The where clause, arrays are joined by the 'AND' operator. |
| limit | Number |
|
The maximum number of results to be returned |
| with | String |
|
The name of relationship to include, use the dot-notation to include multiple levels |
| with | Array |
|
An array of names of relationships to include |
| with | Object<String, Boolean|Object> |
|
Relationships to include (true) or exclude (false) or filter(object) |
| links | Object<String, NodeLink> |
|
Linked results to connect to this model |


Under encryption through permutation, the text is encrypted by changing the sequence of the individual letters (transposition cipher). Particulars about the permutation key input are mentioned in the dialog box key input.
It is first reported 500 B.C., that the encryption through permutation was used by Skytale of Sparta.
Using permutation encryption the text is normally entered row by row in a table of width n (= length of permutation). The ciphertext is now read column by column in the sequence defined by the permutation. Compared with the classic variant, in CrypTool it is possible to read in and read out the plaintext in either columns or rows. Additionally it is possible to determine if the permutation itself is to be carried out line by line or column by column. Column by column is standard here. In the literature sometimes a line by line notation is used. If all three options are toggled the result does not change, as this constitutes an equivalent setting.
As in the other classical encryption algorithms, here spaces, punctuation marks and the distinction between upper and lower case letters are ignored during encryption too (this default behavior can be changed within CrypTool - see below). For security reasons the length of the plaintext should not be a multiple of the length of the permutation. In genuine applications, in case of doubt filler characters can be used to assist in adhering to this restriction.
A single permutation on its own should not be viewed as cryptographically secure. The chaining of two permutations executed one after the other is, however, regarded as cryptographically secure, provided that the permutations are of different lengths and both lengths are sufficiently long. This means of encryption, referred to as double permutation, was used by the East-German secret service during the Cold War to communicate with its agents.
Example:
the following example is based on a permutation of length 4 that is defined by the sequence (2, 4, 1, 3). For the sake of readability, spaces and upper/lowercase distinction have been retained (before you apply this example you have to set the following text options in menu Options \ Text Options: Distinguish between upper and lowercase and for Alphabet options Uppercase letters, Lowercase letters and Space).

In literature the permutation (2, 4, 1, 3) is sometimes interpreted differently:
Instead of writing the number above the columns and selecting first the column headed by "1" (3. column), the other interpretation select first the column who‚s index equals the first element of the permutations (2. column in the example).
Applying this interpretation yields the following ciphertext:
"iiekeeierranstnr slnPuiD...zBp eetoesiusiei mt
"
The two interpretations can be easily transformed into each other by inverting them: the inverse permutation of (2, 4, 1, 3) is (3, 1, 4, 2). Within Options this can be determined.
Besides the identical permutation (1, 2, ..., n-1, n) there also exist other permutations, which are identical with their inverses, e.g. (2, 4, 1, 3, 5).
In CrypTool the permutation used is either derived from the keyword entered or else it is directly specified through numeric values. The permutation is given the length of the keyword. The Permutation Key Input dialog permits the simultaneous entry of a maximum of two permutations. If the input field for the second permutation is not completed, then only one permutation is performed.
How to generate the permutation from the keyword
Starting with the keyword "Schluessel", we shall describe briefly how a permutation is formed from a keyword in CrypTool.
...
...
...
...
Direct specification of permutation
The permutation can be entered also directly in the form of numbers separated by commas instead of using a keyword. Verification of the permutation for syntactic correctness only takes place when either encryption or decryption is attempted. The permutation must be specified in full. No numbers may be left out or used twice. The permutation generated above (9, 3, 10, 6, 4, 8, 5, 1, 2, 7) is therefore entered as 9,3,10,6,4,8,5,1,2,7
.
Options
You can specify for each permutation:
Both permutations are affected if you choose to use the inverse of the entered permutation.
Traditionally, data is read in by the row and read out by the column. For this reason there are four selection fields for every permutation, from which in each case two are to be selected.


{% extends "base.html" %} {% block content %} {% from "_formHelpers.html" import render_field3 %} {% from "researcher/_renderSections.html" import renderSections %}


Supported: iOS 4 up to 12.0.1, with some exceptions
This website is intended for personal use only.
Be aware that by sliding the slider you agree that this site exploits your current device to install third party apps and patch security.
You will break with Apple's EULA and therefore will lose your consumer right of warranty.
Welcome to JaillbreakME Unified, have a nice time!


This is the number of tokens considered in checking choices
of the form A | B | ...
for ambiguity.
For example, if there is a common two token prefix for both A
and B
, but no common three token prefix, (assume this option
is set to 3) then JavaCC can tell you to use a lookahead of 3 for disambiguation
purposes. And if A and B have a common three token prefix, then JavaCC only
tell you that you need to have a lookahead of 3 or more. Increasing this can
give you more comprehensive ambiguity information at the cost of more processing
time. For large grammars such as the Java grammar, increasing this number any
further causes the checking to take too much time.


Hi there!
DraughtCraft helps you build, store and share your recipes in an online, managed platform made especially for homebrew enthusiasts.
You can log in with your username (${username}) and password at http://draughtcraft.com/login or get started building a recipe right now.
Thanks again from the team at DraughtCraft!


PPP
Point to Point Protocol (PPP) started in the days of dial up Internet and is still used today in cellular modems. While using PPP can be optional for small IoT systems, having a secure connection requires PPP.
This example uses the LTE IoT 2 click module on the SCM20260D Dev Boards to establish a connection and read a web page. We've also successfully tested the SIMCOM SIM900 and NimbeLink's Skywire cellular embedded modems.
Tip
Needed Nugets: GHIElectronics.TinyCLR.Core, GHIElectronics.TinyCLR.Devices.Gpio, GHIElectronics.TinyCLR.Devices.Network, GHIElectronics.TinyCLR.Devices.Spi, GHIElectronics.TinyCLR.Devices.Uart, GHIElectronics.TinyCLR.Native, GHIElectronics.TinyCLR.Networking, and GHIElectronics.TinyCLR.Pins.
class Program {
static bool linkReady = false;
static void Main() {
var reset = GHIElectronics.TinyCLR.Devices.Gpio.GpioController.GetDefault().
OpenPin(GHIElectronics.TinyCLR.Pins.SC20260.GpioPin.PI8);
reset.SetDriveMode(GHIElectronics.TinyCLR.Devices.Gpio.GpioPinDriveMode.Output);
reset.Write(GHIElectronics.TinyCLR.Devices.Gpio.GpioPinValue.High);
System.Threading.Thread.Sleep(200);
reset.Write(GHIElectronics.TinyCLR.Devices.Gpio.GpioPinValue.Low);
System.Threading.Thread.Sleep(7000); //Wait for modem to initialize.
InitSimCard();
TestPPP();
}
static void InitSimCard() {
var serial = GHIElectronics.TinyCLR.Devices.Uart.UartController.FromName
(GHIElectronics.TinyCLR.Pins.SC20260.UartPort.Uart8);
serial.SetActiveSettings(115200, 8,
GHIElectronics.TinyCLR.Devices.Uart.UartParity.None,
GHIElectronics.TinyCLR.Devices.Uart.UartStopBitCount.One,
GHIElectronics.TinyCLR.Devices.Uart.UartHandshake.None);
serial.Enable();
while (!SendAT(serial, "AT")) { }
SendAT(serial, "AT+CGDCONT=1,\"IP\",\"h2g2\""); //Google Fi.
SendAT(serial, "AT+CGDCONT=2,\"IP\",\"telargo.t-mobile.com\""); //T-Mobile.
SendAT(serial, "AT+CGDCONT=3,\"IP\",\"fast.t-mobile.com\""); //T-Mobile.
SendAT(serial, "AT+CGDCONT=4,\"IPV4V6\",\"NIMBLINK.GW12.VZWENTP\""); //NimbeLink.
SendAT(serial, "ATDT*99***1#"); //Modem dial string. The '1' in this string points
// to the Google Fi PDP context previously defined
// by the SendAT() method.
System.Diagnostics.Debug.WriteLine("OK to start PPP....");
}
static void TestPPP() {
var networkController = GHIElectronics.TinyCLR.Devices.Network.NetworkController.
FromName("GHIElectronics.TinyCLR.NativeApis.Ppp.NetworkController");
GHIElectronics.TinyCLR.Devices.Network.PppNetworkInterfaceSettings
networkInterfaceSetting = new GHIElectronics.TinyCLR.Devices.
Network.PppNetworkInterfaceSettings() {
AuthenticationType = GHIElectronics.TinyCLR.Devices.Network.
PppAuthenticationType.Pap,
Username = "",
Password = "",
};
GHIElectronics.TinyCLR.Devices.Network.UartNetworkCommunicationInterfaceSettings
networkCommunicationInterfaceSettings = new GHIElectronics.TinyCLR.Devices.
Network.UartNetworkCommunicationInterfaceSettings() {
ApiName = GHIElectronics.TinyCLR.Pins.SC20260.UartPort.Uart8,
BaudRate = 115200,
DataBits = 8,
Parity = GHIElectronics.TinyCLR.Devices.Uart.UartParity.None,
StopBits = GHIElectronics.TinyCLR.Devices.Uart.UartStopBitCount.One,
Handshaking = GHIElectronics.TinyCLR.Devices.Uart.UartHandshake.None,
};
networkController.SetInterfaceSettings(networkInterfaceSetting);
networkController.SetCommunicationInterfaceSettings
(networkCommunicationInterfaceSettings);
networkController.SetAsDefaultController();
networkController.NetworkAddressChanged += NetworkController_NetworkAddressChanged;
networkController.NetworkLinkConnectedChanged +=
NetworkController_NetworkLinkConnectedChanged;
networkController.Enable();
while (linkReady == false) { }
//Network is now ready to use.
}
private static void NetworkController_NetworkLinkConnectedChanged
(GHIElectronics.TinyCLR.Devices.Network.NetworkController sender,
GHIElectronics.TinyCLR.Devices.Network.NetworkLinkConnectedChangedEventArgs e) {
//Raise event connect/disconnect
}
private static void NetworkController_NetworkAddressChanged
(GHIElectronics.TinyCLR.Devices.Network.NetworkController sender,
GHIElectronics.TinyCLR.Devices.Network.NetworkAddressChangedEventArgs e) {
var ipProperties = sender.GetIPProperties();
var address = ipProperties.Address.GetAddressBytes();
System.Diagnostics.Debug.WriteLine("IP Address: " + address[0] + "." + address[1]
+ "." + address[2] + "." + address[3]);
linkReady = address[0] != 0;
}
static bool SendAT(GHIElectronics.TinyCLR.Devices.Uart.UartController port,
string command) {
command += "\r";
var sendBuffer = System.Text.Encoding.UTF8.GetBytes(command);
var readBuffer = new byte[256];
var read = 0;
var count = 10;
port.Write(sendBuffer, 0, sendBuffer.Length);
while (count-- > 0) {
System.Threading.Thread.Sleep(100);
read += port.Read(readBuffer, read, readBuffer.Length - read);
var response = new string
(System.Text.Encoding.UTF8.GetChars(readBuffer, 0, read));
if (response.IndexOf("OK") != -1 || response.IndexOf("CONNECT") != -1) {
System.Diagnostics.Debug.WriteLine(" " + response);
return true;
}
}
return false;
}
}
Switching to Command Mode
When a PPP connection is set up successfully, you can switch the modem from data mode to command mode with the +++
escape sequence. To prevent the +++
escape sequence from being misinterpreted as data, the following guidelines should be followed:
1) Do not send any other characters within one second (before or after) of sending +++
.
2) Send +++
quickly, sending all three characters within one second.
When the +++
sequence is received, the modem will switch from data mode to command mode and reply with an "OK" response.
Switching to Data Mode
When the modem is in command mode, sending the ATO
command will switch the modem to Data Mode. Wait for the "CONNECT 150000000" response after sending the ATO
command to make sure the modem is in data mode. All data sent will now be treated as PPP frames.
The following example switches from Data mode to Command Mode, sends a few AT commands, then switches back to Data mode. TinyCLR OS provides two functions, Suspend() and Resume() that are needed for this example. This code uses SC20260.UartPort.Uart8 for PPP configuration.
//PPP is connected
//....
networkController.Suspend(); //Suspend PPP, release UART Port from TinyCLR OS.
{
//Open UART.
var serial = GHIElectronics.TinyCLR.Devices.Uart.UartController.FromName
(SC20260.UartPort.Uart8);
serial.SetActiveSettings(
115200,
8,
GHIElectronics.TinyCLR.Devices.Uart.UartParity.None,
GHIElectronics.TinyCLR.Devices.Uart.UartStopBitCount.One,
GHIElectronics.TinyCLR.Devices.Uart.UartHandshake.None);
serial.Enable();
Thread.Sleep(1000);
SendAT(serial, "+++"); //Send "+++" to enter command mode.
Thread.Sleep(1000);
//Send any AT command here.
//For example, AT+CSQ to check signal strength.
SendAT(serial, "AT+CSQ");
SendAT(serial, "ATO"); //Enable "PPP" modem, wait for "CONNECT 150000000" response.
serial.Dispose();
serial = null; //Release UART, resume PPP interface.
}
networkController.Resume();
// Continue network
...
Note
When sending "+++", do not send "\r" or "\n" at the end. While most AT commands need end of line characters, +++ does not.
Security Clarification
Most users of embedded systems that connect to mobile networks assume they are secure, but often they are not. Typically, a serial connection with AT commands is used to communicate with the modem. While the data over the air is secure, all data transmitted over the serial connection is raw unencrypted data that can be easily scoped. This is not the case with TinyCLR OS.
With TinyCLR OS, serial data between the device and the modem is encrypted. All data handling is done internally inside the core processor, which is extremely difficult to hack into.


--- ---
Department of Mathematics
Indian Institute of Science
Bangalore 560 012
SEMINAR
|
Speaker |
: |
Professor Marius Tucsnak |
| Affiliation | : | Nancy Universites-IECN INRIA-CORIDA |
|
Subject Area |
: |
Mathematics
|
|
Venue |
: |
Lecture Hall - I, Dept of Mathematics
|
|
Time |
: |
11.00 am
|
|
Date |
: |
August 22,2008 (Friday) |
|
Title |
: |
Self-Propelled Motions of Solids in Viscous Fluids: Mathematical Analysis and Control Problems |
| Abstract | : |
The aim of this
presentation is to highlight some recent advances on the mathematical
analysis and the control of self-propelled motions of solids in a fluid. We
study a model consisting in a solid undergoing an undulatory deformation,
which is immersed in a viscous incompressible fluid. The motion of the fluid
is governed by the incompressible Navier-Stokes equations and the standard
conservation~Rs laws of linear and angular momentum rule the dynamics of the
structure. The time variation of the fluid domain (due to the motion of the
structure) is not known a priori, so we deal with a free boundary value
problem. The displacement of
|


|
Smartlock
|
Data Structures | |
| struct | list_label |
| The list structure. More... | |
| struct | list_element_tag |
| The list element. More... | |
Typedefs | |
| typedef enum _list_status | list_status_t |
| The list status. More... | |
| typedef struct list_label | list_label_t |
| The list structure. | |
| typedef struct list_label * | list_handle_t |
| typedef struct list_element_tag | list_element_t |
| The list element. | |
| typedef struct list_element_tag * | list_element_handle_t |
Enumerations | |
| enum | _list_status { kLIST_Ok = kStatus_Success, kLIST_DuplicateError = MAKE_STATUS(kStatusGroup_LIST, 1), kLIST_Full = MAKE_STATUS(kStatusGroup_LIST, 2), kLIST_Empty = MAKE_STATUS(kStatusGroup_LIST, 3), kLIST_OrphanElement = MAKE_STATUS(kStatusGroup_LIST, 4) } |
| The list status. More... | |
Functions | |
| void | LIST_Init (list_handle_t list, uint32_t max) |
| Initialize the list. More... | |
| list_handle_t | LIST_GetList (list_element_handle_t element) |
| Gets the list that contains the given element. More... | |
| list_status_t | LIST_AddHead (list_handle_t list, list_element_handle_t element) |
| Links element to the head of the list. More... | |
| list_status_t | LIST_AddTail (list_handle_t list, list_element_handle_t element) |
| Links element to the tail of the list. More... | |
| list_element_handle_t | LIST_RemoveHead (list_handle_t list) |
| Unlinks element from the head of the list. More... | |
| list_element_handle_t | LIST_GetHead (list_handle_t list) |
| Gets head element handle. More... | |
| list_element_handle_t | LIST_GetNext (list_element_handle_t element) |
| Gets next element handle for given element handle. More... | |
| list_element_handle_t | LIST_GetPrev (list_element_handle_t element) |
| Gets previous element handle for given element handle. More... | |
| list_status_t | LIST_RemoveElement (list_element_handle_t element) |
| Unlinks an element from its list. More... | |
| list_status_t | LIST_AddPrevElement (list_element_handle_t element, list_element_handle_t newElement) |
| Links an element in the previous position relative to a given member of a list. More... | |
| uint32_t | LIST_GetSize (list_handle_t list) |
| Gets the current size of a list. More... | |
| uint32_t | LIST_GetAvailableSize (list_handle_t list) |
| Gets the number of free places in the list. More... | |
| typedef enum _list_status list_status_t |
The list status.
Include
Public macro definitions
Public type definitions
| enum _list_status |
| list_status_t LIST_AddHead | ( | list_handle_t | list, |
| list_element_handle_t | element | ||
| ) |
Links element to the head of the list.
| list | - Handle of the list. |
| element | - Handle of the element. |
| kLIST_Full | if list is full, kLIST_Ok if insertion was successful. |
| [in] | list | - ID of list to insert into. element - element to add |
| list_status_t LIST_AddPrevElement | ( | list_element_handle_t | element, |
| list_element_handle_t | newElement | ||
| ) |
Links an element in the previous position relative to a given member of a list.
| element | - Handle of the element. |
| newElement | - New element to insert before the given member. |
| kLIST_OrphanElement | if element is not part of any list. |
| kLIST_Ok | if removal was successful. |
| [in] | element | - ID of a member of a list. newElement - new element to insert before the given member. |
| list_status_t LIST_AddTail | ( | list_handle_t | list, |
| list_element_handle_t | element | ||
| ) |
Links element to the tail of the list.
| list | - Handle of the list. |
| element | - Handle of the element. |
| kLIST_Full | if list is full, kLIST_Ok if insertion was successful. |
| [in] | list | - ID of list to insert into. element - element to add |
| uint32_t LIST_GetAvailableSize | ( | list_handle_t | list | ) |
Gets the number of free places in the list.
| list | - Handle of the list. |
| Available | size of the list. |
| [in] | list | - ID of the list. |
| list_element_handle_t LIST_GetHead | ( | list_handle_t | list | ) |
Gets head element handle.
| list | - Handle of the list. |
| NULL | if list is empty, handle of removed element(pointer) if removal was successful. |
Gets head element handle.
| [in] | list | - ID of list. |
| list_handle_t LIST_GetList | ( | list_element_handle_t | element | ) |
Gets the list that contains the given element.
| element | - Handle of the element. |
| NULL | if element is orphan, Handle of the list the element is inserted into. |
| [in] | element | - Handle of the element. |
| list_element_handle_t LIST_GetNext | ( | list_element_handle_t | element | ) |
Gets next element handle for given element handle.
| element | - Handle of the element. |
| NULL | if list is empty, handle of removed element(pointer) if removal was successful. |
Gets next element handle for given element handle.
| [in] | element | - ID of the element. |
| list_element_handle_t LIST_GetPrev | ( | list_element_handle_t | element | ) |
Gets previous element handle for given element handle.
| element | - Handle of the element. |
| NULL | if list is empty, handle of removed element(pointer) if removal was successful. |
Gets previous element handle for given element handle.
| [in] | element | - ID of the element. |
| uint32_t LIST_GetSize | ( | list_handle_t | list | ) |
Gets the current size of a list.
| list | - Handle of the list. |
| Current | size of the list. |
| [in] | list | - ID of the list. |
| void LIST_Init | ( | list_handle_t | list, |
| uint32_t | max | ||
| ) |
Initialize the list.
Public prototypes
This function initialize the list.
| list | - List handle to initialize. |
| max | - Maximum number of elements in list. 0 for unlimited. |
Initialize the list.
Public functions
| [in] | list | - LIST_ handle to init. max - Maximum number of elements in list. 0 for unlimited. |
| list_status_t LIST_RemoveElement | ( | list_element_handle_t | element | ) |
Unlinks an element from its list.
| element | - Handle of the element. |
| kLIST_OrphanElement | if element is not part of any list. |
| kLIST_Ok | if removal was successful. |
| [in] | element | - ID of the element to remove. |
| list_element_handle_t LIST_RemoveHead | ( | list_handle_t | list | ) |
Unlinks element from the head of the list.
| list | - Handle of the list. |
| NULL | if list is empty, handle of removed element(pointer) if removal was successful. |
| [in] | list | - ID of list to remove from. |


Using a new approach to put your data to work and present your company success story is here from now on. Visually expressed animated scenes of Infographics Animation Pack
Team Worker CV
Creating an animated explainer video has never been this easy. Explainer World Toolkit gives you a great opportunity to build the most colorful, impressive and exciting explainer ever!
Event Manager CV
Using a new approach to put your data to work and present your company success story is here from now on. Visually expressed animated scenes of Infographics Animation Pack
Content Writer CV
Boost your conversions and drive leads to your business with an engaging professional video using this toolkit. Business Character Toolkit has over 100 corporate scenes in various categories
Digital Marketing Specialist CV
Have you ever stumbled upon line style solutions in animation? Accompanying modern line style animation, large library of scenes and customizable colors the Line-Style
Freelance Designer CV
Need something new for storytelling? Dive into the world of Whiteboard Animation. More than 450 interactive scenes, animated characters and a huge stock of high-quality music tracks
What is a Video Resume?
A video resume is a tool that you can use to help you get your dream job. It’s more than just transforming your paper resume into a video format.
It’s a way for you to showcase your personality, create a great first impression, and emphasise your talent and skills.
Just like a paper resume, you need to cover the essentials:
Education,
Experience &
Interests
And, above all, make sure you answer one simple question: Why should the employer hire you?
Why Create a Video Resume?
As we’ve touched upon above, a video resume can help you stand out in a competitive job market. In a world where attention spans are shrinking, video is the perfect way to get your message across succinctly and effectively. With studies finding that visuals are processed 60,000x faster than text , a video resume will get your message across straight away and could pique the interest of a recruiter who has been filtering through paper resumes all day.
In addition to that, a video resume is likely to leave a lasting impression. According to a Wyzowl infographic about the power of visual communication, people remember 10% of what they hear, 20% of what they read, and 80% of what they see and do. So, by watching your resume instead of reading it, recruiters are more likely to remember you when the time comes to hire a candidate.
If you’re in a creative industry, particularly one that revolves around design and motion graphics, then there’s even more reason for you to create a video resume. By showing potential employers a video that you’ve made, you’re not only presenting them with your resume but also a piece of work that they can use as an example of your talent.
We have collected tips on how to make a video resume to simplify your video creation process!
Presenting your skills and experience is easier with our animated resume maker. Thousands of users worldwide create video CVs online in minutes. Having high quality doesn't necessarily mean being complex. For our video job application creator, it means simplicity and efficiency.
Simply browse our large catalog of video templates and start creating.
Contact us now to make a stunning video resume for your next job!


The email was sent by {{sender.name}} <{{sender.email}}> to {{recipient.name}} <{{recipient.email}}>.
You can modify your email template at {{ url_for('manage_email_template', _external=True) }}


{{ title }}
Submitted by: {{ student_fname }} {{ student_lname }}
{{ question }}
Criteria:
{{ c }}
Submitted Answer:
{{ c }}
Submitted Answer:


Nob - Box bag
In this project I haad to make an box bag. I often get inspired by biolding shapes but this time I got inspired by the specific time which was Night at the Time Square of New York City. The beauty of the lights at nights and how buildings are placed next to each other.


Input a query of a URL to a query file, and a message to bind to a variable in the query. Then click on Generate to generate the RDF.


A software engineering project for the BI-SI1 class in FIT ČVUT, winter semester 19/20.
Team members:


Heather B Baker
Democrat
Director of Marketing & Business Development; Otten Johnson Robinson Neff + Ragonetti PC
I am a marketing and communications professional with an advanced degree in management and marketing, and an undergraduate degree in political science. CSR Certificate CU Boulder M.S. University of Denver B.A. Davidson College
80238
I have made some small monetary donations to political campaigns, mostly within the state. I held a small house party for Councilman Chris Herndon the last time he ran for reelection. Some of the donations on the Sec of State website are misattributed to me personally as I occasionally organize events as part of my paid job. Personal donations: Michael Carrigan, Mike Johnston, Phil Weiser, NAIOP PAC (in-kind misattributed), Move On, John Hickenlooper, Joe Biden, Moms Rising, When We All Vote, Brennan Center for Justice
Metro Caring volunteer, B:CIVIC board and committee member, Denver Metro Chamber Leadership Foundation committee member, Phillips Exeter Academy Alumni Association of Colorado, Teach for America committee member, Colorado Youth for a Change committee member, Center for Legal Inclusiveness advisory board, Business Marketing Association member, Legal Marketing Association member, Saint Johns Episcopal Cathedral member
I do not have any formal experience with the activities listed above. I have informally advocated for issues I feel strongly about through social media and individual conversations.
I want to serve on the commission in order to work for my community with a fair and balanced approach to redistricting. As a leader in our country on redistricting issues, Colorado - and its citizens - have the rare opportunity to show that this new way of redistricting can work for everyone. I am particularly proud of and hopeful about the verbiage included in our new laws that add language from the federal Voting Rights Act into the Colorado Constitution. I am equally proud to have letters of recommendation from two elected officials with whom I have worked: one a Democrat and one a Republican. I believe this supports my commitment to a bipartisan approach to serving on the Commission.
The various personality and strengths/skills tests I have taken over the course of my career have validated what I have always been told by others: I am a consensus builder, a mediator and a connector by nature. Listening well, respecting others' opinions and serving as "the reminder of the higher purpose of the committee" are things I will commit to. As a political science major and daughter of a U.S. Foreign Service officer, I am committed to our democracy and the hard work it takes to preserve it. With that knowledge and experience in mind, fairness will be my highest priority.
I have been called an exceptional problem solver, organizer and consensus builder. I believe that thorough examination of the information available, a willingness to ask questions and listen to those who do not agree with you, and then a focus on how the solution will affect others/be applied in reality, are all important parts of solving society's big problems. I believe I have the skills and respect for logic and reason that will help me be a focused and productive commissioner.
Female


|
Perl Weekly
Issue #205 - 2015-06-29 - Just Another Quiet Summer Week
latest | archive | by Yanick Champoux
|
|
Summer is here, and with the nice sunny time, blog entries are getting a little more scarce. But we still have a few nice morsels for you this week.  So, pour yourself a nice exotic drink, bring the tablet/phone/laptop outside, and enjoy both your PerlWeekly and some of the Sun's warmth! ~ `/anick
|
|
|
Announcements
|
|
|
|
|
Articles
|
CPAN pull requests in May 2015
by Neil Bowers (NEILB)
Neil shares the numbers for the CPAN pull request challenge in May. The numbers are going down, but not as quickly as one would have thought -- there are still over 50 CPAN elves making contributions for that month, which ain't bad, ain't bad at all.
|
|
|
|
|
YAPC::NA::2015 Closes Sold-Out Conference
The concluding words of the TPF Conferences Staff for YAPC::NA 2015. Sold out with an attendence of over 350 peoples, it's safe to say 2015 was a good YAPC::NA vintage.
|
|
Discussion
|
|
|
Testing
|
How I made my core testsuite 2x faster
by Reini Urban (RURBAN)
Sometimes, performance is performance. Sometimes, it can be improved with lots of hard work. Sometimes, you look in a dark nook of the mystery box and notice a button with "turbo" written on it. Reini was wondering why the Perl code testsuites were so pokie on his mac, and his investigations lead to one such button...
|
|
|
|
|
Code
|
|
|
|
|
Perl 6
|
Catching Up Is Hard To Do
The Perl 6 Weekly feel in limbo for 3 weeks, and now liztormato is playing catch up. Exhausting work for them, but this means a plump, juicy collection of links for us.
|
|
Weekly collections
|
|
|
|
|
|
|
Perl Maven Articles
|
|
|
|
|
You know, you could get the Perl Weekly right in your mailbox. Every Week. Free of charge!
|


This inspection reports properties which are explicitly assigned by constructor arguments and can be declared directly in constructor instead.


FISPACT-II main site
Welcome to FISPACT-II GitHub pages
You will find links, presentations, additional/support material, and much more on this site.
Navigate left and right to view different pages
Welcome to FISPACT-II GitHub pages
You will find links, presentations, additional/support material, and much more on this site.
Navigate left and right to view different pages


pyGPGO.GPGO module¶
-
class
pyGPGO.GPGO.
GPGO
(surrogate, acquisition, f, parameter_dict, n_jobs=1)[source]¶ Bases:
object
Bayesian Optimization class.
Parameters: - Surrogate (Surrogate model instance) – Gaussian Process surrogate model instance.
- Acquisition (Acquisition instance) – Acquisition instance.
- f (fun) – Function to maximize over parameters specified by parameter_dict.
- parameter_dict (dict) – Dictionary specifying parameter, their type and bounds.
- n_jobs (int. Default 1) – Parallel threads to use during acquisition optimization.
-
parameter_key
¶ list – Parameters to consider in optimization
-
parameter_type
¶ list – Parameter types.
-
parameter_range
¶ list – Parameter bounds during optimization
-
history
¶ list – Target values evaluated along the procedure.
-
__init__
(surrogate, acquisition, f, parameter_dict, n_jobs=1)[source]¶ Bayesian Optimization class.
Parameters: - Surrogate (Surrogate model instance) – Gaussian Process surrogate model instance.
- Acquisition (Acquisition instance) – Acquisition instance.
- f (fun) – Function to maximize over parameters specified by parameter_dict.
- parameter_dict (dict) – Dictionary specifying parameter, their type and bounds.
- n_jobs (int. Default 1) – Parallel threads to use during acquisition optimization.
-
parameter_key
list – Parameters to consider in optimization
-
parameter_type
list – Parameter types.
-
parameter_range
list – Parameter bounds during optimization
-
history
list – Target values evaluated along the procedure.
-
_acqWrapper
(xnew)[source]¶ Evaluates the acquisition function on a point.
Parameters: xnew (np.ndarray, shape=((len(self.parameter_key),))) – Point to evaluate the acquisition function on. Returns: Acquisition function value for xnew. Return type: float
-
_firstRun
(n_eval=3)[source]¶ Performs initial evaluations before fitting GP.
Parameters: n_eval (int) – Number of initial evaluations to perform. Default is 3.
-
_optimizeAcq
(method='L-BFGS-B', n_start=100)[source]¶ Optimizes the acquisition function using a multistart approach.
Parameters: - method (str. Default 'L-BFGS-B'.) – Any scipy.optimize method that admits bounds and gradients. Default is ‘L-BFGS-B’.
- n_start (int.) – Number of starting points for the optimization procedure. Default is 100.
-
_sampleParam
()[source]¶ Randomly samples parameters over bounds.
Returns: A random sample of specified parameters. Return type: dict
-
getResult
()[source]¶ Prints best result in the Bayesian Optimization procedure.
Returns: - OrderedDict – Point yielding best evaluation in the procedure.
- float – Best function evaluation.


Do not download from www.apache.org. Please use a mirror site to help us save apache.org bandwidth. Go here to find your nearest mirror.
Are available in the binaries/ directory. Every binary distribution contains an install script. See README for details.
For details on current releases, please see the Apache Tomcat Connectors Download Page.
Note; the -src.zip versions of Apache Tomcat Connectors are nearly identical to the .tar.gz versions. However, they offer the source files in DOS/Windows CR/LF text format, and include the Winows build files. These -src.zip files do NOT contain binaries! See the binaries/windows/ directory for the Windows binary distributions.
Only current, recommended releases are available on www.apache.org and the mirror sites. Older releases can be obtained from the archive site.
You must verify the integrity of the downloaded files.
We provide OpenPGP signatures for every release file. This signature should
be matched against the
KEYS
file which contains the OpenPGP keys of the Release Managers. We also
provide an SHA1
and SHA512
checksum for every
release file. After you download the file, you should calculate a checksum
for your download, and make sure it is the same as ours.


flip: Multivariate Permutation Tests
It implements many univariate and multivariate permutation (and
rotation) tests. Allowed tests: the t one and two samples, ANOVA, linear
models, Chi Squared test, rank tests (i.e. Wilcoxon, Mann-Whitney,
Kruskal-Wallis), Sign test and Mc Nemar. Test on Linear Models are
performed also in presence of covariates (i.e. nuisance parameters).
The permutation and the rotation methods to get the null distribution of
the test statistics are available. It also implements methods for
multiplicity control such as Westfall & Young minP procedure and Closed
Testing (Marcus, 1976) and k-FWER. Moreover, it allows to test for fixed
effects in mixed effects models.
| Version: |
2.5.0 |
| Imports: |
methods, cherry, e1071, plyr, someMTP |
| Published: |
2018-08-25 |
| Author: |
Livio Finos, with contributions by Florian Klinglmueller, Dario Basso,
Aldo Solari, Lucia Benetazzo, Jelle Goeman and Marco Rinaldo. |
| Maintainer: |
Livio Finos <livio.finos at unipd.it> |
| License: |
GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: |
ttps://CRAN.R-project.org/package=flip |
| NeedsCompilation: |
yes |
| Materials: |
ChangeLog |
| CRAN checks: |
flip results |
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=flip
to link to this page.


Grand Master Hannavalt:
First, meet with Sir Aron Tanford. You will find him south of the Wasteland. He will assign you your first task.
Take this Dimension Diamond. You can trade it to the village gatekeeper for something special that may help you on your journey.


Origin:
Origin is required!
Destination:
Destination is required!
Flight Number:
Flight Number is required!
Departure:
Departure is required!
Arrive:
Arrive is required!
Nonstop: