| Package | com.flashdynamix.motion |
| Class | public class TweensyTimeline |
| Property | Defined by | ||
|---|---|---|---|
| canRepeat : Boolean [read-only]
Defines whether the TweensyTimeline repeats.
| TweensyTimeline | ||
| defaultTween : Function [static]
The default tween which will be used when none is provided using a to, from and fromTo method.
| TweensyTimeline | ||
| delayEnd : Number = 0
Defines the delay in seconds at the end of the animation.
By default this value is 0 seconds. | TweensyTimeline | ||
| delayStart : Number = 0
Defines the delay in seconds at the start of the animation.
By default this value is 0 seconds. | TweensyTimeline | ||
| duration : Number
Sets and gets the current tween duration for the TweensyTimeline in seconds.
| TweensyTimeline | ||
| ease : Function
Defines the ease equation you would like to use.
| TweensyTimeline | ||
| easeParams : Array [write-only]
Sets the ease params.
| TweensyTimeline | ||
| finished : Boolean [read-only]
Determines whether or not the TweensyTimeline animation has finished.
| TweensyTimeline | ||
| hasTweens : Boolean [read-only]
Whether the TweensyTimeline has any animations.
| TweensyTimeline | ||
| onComplete : Function
Executed when the TweensyTimeline animation is complete.
| TweensyTimeline | ||
| onCompleteParams : Array
Parameters applied to the onComplete Function.
| TweensyTimeline | ||
| onRepeat : Function
Executed when the TweensyTimeline animation repeats.
| TweensyTimeline | ||
| onRepeatParams : Array
Parameters applied to the onRepeat Function.
| TweensyTimeline | ||
| onUpdate : Function
Executed on each update to the TweensyTimeline animation.
| TweensyTimeline | ||
| onUpdateParams : Array
Parameters applied to the onUpdate Function.
| TweensyTimeline | ||
| paused : Boolean [read-only]
Whether the TweensyTimeline is paused.
| TweensyTimeline | ||
| playing : Boolean [read-only]
This is when the animation is after the delay start and before its delay end.
| TweensyTimeline | ||
| position : Number
Seeks and returns the animation to a position from 0 to 1, start to end.
| TweensyTimeline | ||
| repeatCount : int = 0
The count of the number of repeats which have occured.
| TweensyTimeline | ||
| repeatEase : Array
This contains a list of ease Functions to use on each repeat for the tween animation.
i.e. | TweensyTimeline | ||
| repeats : int = -1
The number of repeats to use.
| TweensyTimeline | ||
| repeatType : String
Defines the repeat type for the animation.
| TweensyTimeline | ||
| snapToClosest : Boolean = false
Whether the tweens contained within the TweensyTimeline class will snap tweened properties to the closest whole number.
| TweensyTimeline | ||
| time : Number
The time in seconds the TweensyTimeline has been running for
| TweensyTimeline | ||
| totalDuration : Number [read-only]
The total duration of the TweensyTimeline animation in seconds.
This is the sum of delayStart, duration and delayEnd. | TweensyTimeline | ||
| tweens : int [read-only]
Number of tweens added to the TweensyTimeline Class.
| TweensyTimeline | ||
| smartRotate : Boolean = true
Whether the timelines contained within the TweensyTimeline class will use smart rotation or not.
Smart rotation will make the rotation turn in the direction which is the shortest in degrees fixing what may otherwise appear as a visual glitch even though mathimatically it is correct. | TweensyTimeline |
| Method | Defined by | ||
|---|---|---|---|
| TweensyTimeline | |||
|
add(instance:Object, update:Object = null):AbstractTween
| TweensyTimeline | ||
|
clear():void
Cleans the TweensyTimeline Class ready for check in to the Object Pool for reuse.
| TweensyTimeline | ||
|
dispose():void
Disposes the TweensyTimeline Class instance ready for garbage collection.
| TweensyTimeline | ||
|
from(instance:Object, from:Object, update:Object = null):void
Adds a from based tween to the properties defined in the target Object.
| TweensyTimeline | ||
|
fromTo(instance:Object, from:Object, to:Object, update:Object = null):void
Adds a from to based tween to the properties defined in the target Object.
| TweensyTimeline | ||
|
gc():void
[static]
Prepares the TweensyTimeline class for garbage collection by disposing its Object Pools and making it
no longer usable in the Flash application.
| TweensyTimeline | ||
|
loop():void
Forces a timeline tween to loop the animation.
A looped animation will swap the delays (delayStart & delayEnd) so that the to and from animations have the same delays. | TweensyTimeline | ||
|
pause():void
Pauses a playing TweensyTimeline
| TweensyTimeline | ||
|
removeOverlap(timeline:TweensyTimeline):void
Removes tweening property tween overlaps.
| TweensyTimeline | ||
|
replay():void
Plays a timeline animation at its start position on each repeat.
| TweensyTimeline | ||
|
resume():void
Resumes a paused TweensyTimeline
| TweensyTimeline | ||
|
stop(instance:* = null, ... props):void
Allows for removing tweens via an instance or tween props by the following methods :
| TweensyTimeline | ||
|
stopAll():void
| TweensyTimeline | ||
|
to(instance:Object, to:Object, update:Object = null):void
Adds a to based tween to the properties defined in the target Object.
| TweensyTimeline | ||
|
toString():String
| TweensyTimeline | ||
|
update(secs:Number):Boolean
Updates the TweensyTimeline by the specified amout of time in seconds.
This function is intended for use by the Tweensy class which is controlling this timeline animation. Though calling this function will update the timeline independtly of the mananger allowing for custom control over timelines. | TweensyTimeline | ||
|
updateTo(instance:Object, to:Object):void
Updates a tween for the instance Object to the new target properties defined in the to Object.
| TweensyTimeline | ||
|
yoyo():void
Forces a timeline tween to do a yoyo animation.
A yoyo will use the same delayStart and delayEnd on the to and fro animation. | TweensyTimeline |
| Constant | Defined by | ||
|---|---|---|---|
| LOOP : String = "loop" [static]
| TweensyTimeline | ||
| NONE : String = "null" [static]
| TweensyTimeline | ||
| REPLAY : String = "replay" [static]
| TweensyTimeline | ||
| YOYO : String = "yoyo" [static]
| TweensyTimeline |
| canRepeat | property |
canRepeat:Boolean
[read-only]Defines whether the TweensyTimeline repeats.
Implementation public function get canRepeat():Boolean
| defaultTween | property |
public static var defaultTween:Function
The default tween which will be used when none is provided using a to, from and fromTo method.
See also
| delayEnd | property |
public var delayEnd:Number = 0
Defines the delay in seconds at the end of the animation.
By default this value is 0 seconds.
| delayStart | property |
public var delayStart:Number = 0
Defines the delay in seconds at the start of the animation.
By default this value is 0 seconds.
| duration | property |
duration:Number
[read-write]Sets and gets the current tween duration for the TweensyTimeline in seconds.
Implementation public function get duration():Number
public function set duration(value:Number):void
| ease | property |
public var ease:Function
Defines the ease equation you would like to use. By default this is Quintic.easeOut or the defaultTween.
See also
| easeParams | property |
easeParams:Array
[write-only]
Sets the ease params. These params are used on Back, Bounce and Elastic ease functions.
These parameters lessen or exaggerate the effect of these particular ease functions.
i.e. [0.7] will lessen the effect of a Back equation
public function set easeParams(value:Array):void
| finished | property |
finished:Boolean
[read-only]Determines whether or not the TweensyTimeline animation has finished.
Implementation public function get finished():Boolean
| hasTweens | property |
hasTweens:Boolean
[read-only]Whether the TweensyTimeline has any animations.
Implementation public function get hasTweens():Boolean
| onComplete | property |
public var onComplete:Function
Executed when the TweensyTimeline animation is complete.
See also
| onCompleteParams | property |
public var onCompleteParams:Array
Parameters applied to the onComplete Function.
See also
| onRepeat | property |
public var onRepeat:Function
Executed when the TweensyTimeline animation repeats.
See also
| onRepeatParams | property |
public var onRepeatParams:Array
Parameters applied to the onRepeat Function.
See also
| onUpdate | property |
public var onUpdate:Function
Executed on each update to the TweensyTimeline animation.
See also
| onUpdateParams | property |
public var onUpdateParams:Array
Parameters applied to the onUpdate Function.
See also
| paused | property |
paused:Boolean
[read-only]Whether the TweensyTimeline is paused.
Implementation public function get paused():Boolean
| playing | property |
playing:Boolean
[read-only]This is when the animation is after the delay start and before its delay end.
Implementation public function get playing():Boolean
| position | property |
position:Number
[read-write]Seeks and returns the animation to a position from 0 to 1, start to end.
Implementation public function get position():Number
public function set position(value:Number):void
| repeatCount | property |
public var repeatCount:int = 0
The count of the number of repeats which have occured.
See also
| repeatEase | property |
public var repeatEase:Array
This contains a list of ease Functions to use on each repeat for the tween animation.
i.e. [Quintic.easeIn, Quintic.easeOut]
This will then use each of these ease Functions on each repeat.
By default this is null when this property is null this functionality is ignored.
See also
| repeats | property |
public var repeats:int = -1
The number of repeats to use. If -1 is used then the animation will repeat indefinitely.
See also
| repeatType | property |
public var repeatType:String
Defines the repeat type for the animation. By default this is TweensyTimeline.NONE
Options include :
See also
| snapToClosest | property |
public var snapToClosest:Boolean = false
Whether the tweens contained within the TweensyTimeline class will snap tweened properties to the closest whole number.
| time | property |
time:Number
[read-write]The time in seconds the TweensyTimeline has been running for
Implementation public function get time():Number
public function set time(value:Number):void
| totalDuration | property |
totalDuration:Number
[read-only]
The total duration of the TweensyTimeline animation in seconds.
This is the sum of delayStart, duration and delayEnd.
public function get totalDuration():Number
| tweens | property |
tweens:int
[read-only]Number of tweens added to the TweensyTimeline Class.
Implementation public function get tweens():int
| smartRotate | property |
public var smartRotate:Boolean = true
Whether the timelines contained within the TweensyTimeline class will use smart rotation or not.
Smart rotation will make the rotation turn in the direction which is the shortest in degrees
fixing what may otherwise appear as a visual glitch even though mathimatically it is correct.
| TweensyTimeline | () | constructor |
public function TweensyTimeline()
| add | () | method |
public function add(instance:Object, update:Object = null):AbstractTween
Parameters
instance:Object |
|
update:Object (default = null )
|
AbstractTween |
| clear | () | method |
public function clear():void
Cleans the TweensyTimeline Class ready for check in to the Object Pool for reuse.
| dispose | () | method |
public function dispose():void
Disposes the TweensyTimeline Class instance ready for garbage collection.
| from | () | method |
public function from(instance:Object, from:Object, update:Object = null):void
Adds a from based tween to the properties defined in the target Object.
Parametersinstance:Object — The instance Object to be tweened or multiple instances if using the type Array e.g. timeline.from([item1, item2], {x:50, y:50}) ;
|
|
from:Object — An Object containing the properties you would like to tween from e.g. {x:50, y:25}
or this can be relative e.g. {x:'50', y:'-25'} or can be a random position e.g. {x:'-50, 50', y:'-25, 25'}
|
|
update:Object (default = null ) — This param is used when tweening a property in a Object which needs to be applied onto another Object each time
the tween occurs.For example timeline.from(new DropShadowFilter(), {alpha:0}, myDisplayItem); Will apply the tweening DropShadowFilter onto the DisplayObject 'myDisplayItem' .
|
| fromTo | () | method |
public function fromTo(instance:Object, from:Object, to:Object, update:Object = null):void
Adds a from to based tween to the properties defined in the target Object.
Parametersinstance:Object — The instance Object to be tweened or multiple instances if using the type Array e.g. timeline.fromTo([item1, item2], {x:50, y:50});
|
|
from:Object — An Object containing the properties you would like to tween from e.g. {x:50, y:25}
or this can be relative e.g. {x:'50', y:'-25'} or can be a random position e.g. {x:'-50, 50', y:'-25, 25'}
|
|
to:Object — An Object containing the properties you would like to tween to e.g. {x:50, y:25}
or this can be relative e.g. {x:'50', y:'-25'} or can be a random position e.g. {x:'-50, 50', y:'-25, 25'}
|
|
update:Object (default = null ) — This param is used when tweening a property in a Object which needs to be applied onto another Object each time
the tween occurs.For example timeline.fromTo(new DropShadowFilter(), {alpha:0}, {alpha:1}, myDisplayItem) Will apply the tweening DropShadowFilter onto the DisplayObject 'myDisplayItem'
|
| gc | () | method |
public static function gc():void
Prepares the TweensyTimeline class for garbage collection by disposing its Object Pools and making it no longer usable in the Flash application.
| loop | () | method |
public function loop():void
Forces a timeline tween to loop the animation.
A looped animation will swap the delays (delayStart & delayEnd) so that the to and from animations have the same delays.
See also
| pause | () | method |
public function pause():void
Pauses a playing TweensyTimeline
| removeOverlap | () | method |
public function removeOverlap(timeline:TweensyTimeline):void
Removes tweening property tween overlaps.
Parameterstimeline:TweensyTimeline |
| replay | () | method |
public function replay():void
Plays a timeline animation at its start position on each repeat.
See also
| resume | () | method |
public function resume():void
Resumes a paused TweensyTimeline
| stop | () | method |
public function stop(instance:* = null, ... props):void
Allows for removing tweens via an instance or tween props by the following methods :
timeline.stop(instance);
- stops all property tweens for this instance.timeline.stop(instance, "x", "y");
- stops all x,y property tweens for this instance.timeline.stop([instance1, instance2]);
- stops all property tweens for these instances.timeline.stop([instance1, instance2], "x", "y");
- stops all x,y property tweens for these instances.timeline.stop(null, "x", "y");
- stops all x,y property tweens.timeline.stop();
- stops all tweens though it is recommended to use the stopAll method as this is more efficient.instance:* (default = null )
|
|
... props |
| stopAll | () | method |
public function stopAll():void
| to | () | method |
public function to(instance:Object, to:Object, update:Object = null):void
Adds a to based tween to the properties defined in the target Object.
Parametersinstance:Object — The instance Object to be tweened or multiple instances if using the type Array e.g. timeline.to([item1, item2], {x:50, y:50});
|
|
to:Object — An Object containing the properties you would like to tween to e.g. {x:50, y:25}
or this can be relative e.g. {x:'50', y:'-25'} or can be a random position e.g. {x:'-50, 50', y:'-25, 25'}
|
|
update:Object (default = null ) — This param is used when tweening a property in a Object which needs to be applied onto another Object each time
the tween occurs.For example timeline.to(new DropShadowFilter(), {alpha:0}, myDisplayItem); Will apply the tweening DropShadowFilter onto the DisplayObject 'myDisplayItem' .
|
| toString | () | method |
public function toString():String
Returns
String |
| update | () | method |
public function update(secs:Number):Boolean
Updates the TweensyTimeline by the specified amout of time in seconds.
This function is intended for use by the Tweensy class which is controlling this timeline animation.
Though calling this function will update the timeline independtly of the mananger allowing for custom control
over timelines.
secs:Number |
Boolean — Whether the TweensyTimeline animation has finished playing.
|
| updateTo | () | method |
public function updateTo(instance:Object, to:Object):void
Updates a tween for the instance Object to the new target properties defined in the to Object.
Parametersinstance:Object |
|
to:Object |
| yoyo | () | method |
public function yoyo():void
Forces a timeline tween to do a yoyo animation.
A yoyo will use the same delayStart and delayEnd on the to and fro animation.
See also
| LOOP | constant |
public static const LOOP:String = "loop"
See also
| NONE | constant |
public static const NONE:String = "null"
See also
| REPLAY | constant |
public static const REPLAY:String = "replay"
See also
| YOYO | constant |
public static const YOYO:String = "yoyo"
See also


There should be no text between this and the next

tag in the browser, since it is a


Fill in your names and create a love notes list
Generate your shareable love code
Copy the code and send it to your partner
Your love will open their LoveNote app and use the code to get all the love notes you entered
Voila! All the love in your partners phone with ease


Assume magnetic surfaces of a magnetic conﬁguration are known and given by
|
| (344) |
|
| (345) |
where (r,𝜃) are two parameters and r is magnetic surface label (i.e., ∂Ψ∕∂𝜃|r = 0). The above parametric equations specify a series of concentric-circular magnetic surfaces.
Assume the toroidal ﬁeld function g(r) = RBϕ is given. Then the toroidal magnetic ﬁeld is determined by Bϕ = g∕R. Further assume the safety factor proﬁle q(r) is given, then the magnetic ﬁeld is fully determined. Next, let us derive the explicit form of the poloidal magnetic ﬁeld Bp, which is given by
|
| (346) |
which involves the poloidal magnetic ﬂux Ψp. Therefore our task is to express Ψp in terms of q and g. Using q(r) = dΨt∕dΨp, we obtain
| dΨp = dΨt, |
Integrate the above equation over r, we obtain
|
| (347) |
which an be written as
|
| (348) |
where use has been made of Ψt = ∫ 0r ∫ −ππBϕrdrd𝜃. Using Bϕ = g∕R and R = R0 + r cos𝜃, the above equation is written
|
| (349) |
Using maxima (an open-source computer algebra system), the above integration over 𝜃 can be performed analytically, giving
|
| (350) |
Using this, equation (349) is written as
|
| (351) |
which can be simpliﬁed as
|
| (352) |
This is what we want—the expression of the poloidal magnetic ﬂux in terms of q and g. [Another way of obtaining Eq. (352) is to use Eq. (160), i.e.,
|
| (353) |
where 𝒥 is the Jacobian of the (r,𝜃,ϕ) coordinates and is given by 𝒥 = R(R𝜃Zr −RrZ𝜃) = −Rr. Then Eq. (353) is simpliﬁed as
|
| (354) |
which, after being integrated over r, gives Eq. (352).]
Using Eq. (352), the poloidal magnetic ﬁeld in Eq. (346) is written as
[Using the formulas ∇r = −(Z𝜃−R𝜃) and 𝒥 = R(R𝜃Zr −RrZ𝜃), where 𝒥 is the Jacobian of the (r,𝜃,ϕ) coordinates, we obtain 𝒥 = −Rr and ∇r = cos𝜃 + sin𝜃, ∇ϕ = ∕R. Then Eq. (355) is written as|
| (356) |
This is the explicit form of the poloidal magnetic ﬁeld in terms of g and q. The magnitude of Bp is written as
|
| (357) |
Note that both Bp and Bϕ depend on the poloidal angle 𝜃.]
I use Eq. (352) to compute the 2D data of Ψ (Ψ = Ψp∕2π) on the poloidal plane when creating a numerical G-eqdsk ﬁle for the above magnetic conﬁguration (Fortran code is at ∕home∕yj∕project_new∕circular_configuration_with_q_given).
Assume that the poloidal plasma current is zero, then g(r) = RBϕ is a constant independent of r. This is always assumed by the authors who use concentric-circular conﬁguration but is seldom explicitly mentioned.
In analytical work, 1∕R dependence on (r,𝜃) is often approximated as
| = = ≈(1 − 𝜀cos𝜃), |
where 𝜀 = r∕R0 is the local inverse aspect ratio.


It's a JavaScript library providing multiple simultaneous, stable and resumable uploads via the HTML5 File API.
The library is designed to introduce fault-tolerance into the upload of large files through HTTP. This is done by splitting each files into small chunks; whenever the upload of a chunk fails, uploading is retried until the procedure completes. This allows uploads to automatically resume uploading after a network connection is lost either locally or to the server. Additionally, it allows for users to pause and resume uploads without loosing state.
simple-uploader.js relies on the HTML5 File API and the ability to chunks files into smaller pieces. Currently, this means that support is limited to Firefox 4+ and Chrome 11+.


There is an open source package called DIGITS that provides a graphical interface to numerous deep learning techniques using nVidia GPUs.
The curated image sets created using the Web application above are loaded into DIGITS and trained using the existing GoogLeNet pre-trained (i.e. weighted) Caffe network.
The results indicate significant performance on the TOP1 prediction (i.e. the algorithm got it right). Below are the training graphs indicating ~ 66% accuracy for rough-fog and ~ 72% accuracy for damp-cloud.


In this website i will be showing my work that i have completed at university & in my free time. Amongst other things i will show, hobbies, gaming interests and hopefully in the near future my YouTube channel.
"Do or do not. There is no try"


The current tax rate is %tax_rate%.
This tax rate will be changed to %next_tax_rate%. This tax rate will be applied after 12 o'clock tomorrow.
Return


We use an extension for mediawiki to render EBNF grammars. It uses <bnf> tag. For example
palin = '0' palin '0' | '1' palin '1'
gives:
palin = '0' palin '0' | '1' palin '1'
Terminals are enclosed in ''. To put real single quote please use
'''. Nonterminals don't use any special markers -- anything
that isn't a terminal, or a special symbol is nonterminal.
Special symbols are:
- = used to start a rule
- | used to separate options of given rule
- []{} used for optional and repeated syntax elements
To allow splitting grammar definition over multiple files
the bnf extension support namespaces. If you write non
terminal like Namespace:something , then it will link to
/Namespace#something , so Namespace should be a wiki
page with grammar entry something . Namespace is not displayed.
To save you typing, if you use at least once Foo:bar (within a
given <bnf> entry) as non-terminal, all occurrences of bar
will be replaced with Foo:bar .
For example:
foo = '-' [ bar ]
qux = '+' [ Non_existent_wiki_page:bar ]
gives:
foo = '-' { bar }
qux = '+' [ Non_existent_wiki_page:bar ]
If you would like to access bnf source code, please contact User:Malekith.
That's all folks!
|


Snap up the full-frame Sony A7 II for just £999 in this Black Friday camera steal
by Mark WilsonSnap up the full-frame Sony A7 II for just £999 in this Black Friday camera steal
Full-frame classic dips under a grand for the first time
Been waiting for a full-frame camera bargain to pop up during Black Friday? This £999 offer on the Sony A7 II is the best one we've seen yet, as it gives you one of the best full-framers of recent years for its lowest price yet.
Sony's A7 series have rightly been hailed as trailblazers for mirrorless full-frame cameras in the past few years. Their combination of high-end features, compact design and seriously competitive pricing have left rivals like Canon, Nikon and Panasonic playing catch-up.
Although it's been succeeded by the Sony A7 III, the A7 II remains an excellent full-frame camera thanks to an all-rounder feature set that remains competitive with today's rivals, plus a host of recent firmware upgrades.
The A7 II combines a 24.3MP full-frame CMOS sensor, in-body image stabilization and a sharp 2.4-million dot electronic viewfinder to help frame your scenes. It also uses Sony's E-mount, which means it's compatible with both full-frame and APS-C format E-mount lenses, giving you a fantastic range of glass across all price points.
Still trying to decide whether or not to go full-frame? While every camera is a compromise in some way, full-frame cameras like the Sony A7 II are a particularly good choice if you like to shoot regularly in low light, due to their superior dynamic range and image quality at high ISOs.
They're also great for landscapes and portraits due to their shallower depth of field, which can produce some beautiful bokeh (or background blur).
The Sony A7 II packs these traditional full-frame advantages and, thanks to Sony's firmware update, now offers phase detection AF for Alpha-mount lenses and improved raw files too.
Considering it originally went on sale for £1,599 (body only), this is an unmissable deal if you've been considering going full-frame and taking your snapping to the next level in 2020.
TechRadar is scouring every retailer and rounding up all the top deals over the Black Friday period, and we’ve put all the best Black Friday deals and Cyber Monday deals in easy-to-navigate articles to help you find the bargains you’re looking for.


vignettes/web_only/SignatureAutocorrelation.Rmd
SignatureAutocorrelation.Rmd
When analyzing single-cell data using signatures, one goal would be to identify signatures whose values exhibit interesting patterns of variation in the dataset.
A labor-intensive way to do this would be to plot the expression scores of every signature on top of a visualization of the data (e.g. with tSNE or UMAP) and identify signatures whose scores vary in a coordinated manner. The idea being that signatures that exhibit this property can be used to potentially describe features of the latent space.
VISION both automates this procedure and makes the process more quantitative. A measure of global autocorrelation is evaluated for each signature in the latent space model. This allows for a natural ranking of signatures as well as testing for significance.
To better understand this statistic, which varies from 0 (no autocorrelation to 1 (perfect autocorrelation), the graphic below shows a projection of single cells overlaid with signatures of 6 different autocorrelation values (labeled as C’).
Signature autocorrelation captures the degree to which a cell’s signature score is similar to that of its ‘nearest neighbors’ in a latent model of gene expression. Or put another way, “Do cells with similar global expression also tend to have similar values for the gene signature being examined?” Signatures whose variation is largely composed of random technical noise would not behave in this way and cell-specific biases are controlled for in the calculation of signature scores (described here).
As a measure of autocorrelation, we use the Geary’s C statistic. To compute this statistic, two pieces of information are needed:
The values consist of the signature scores. To calculate the weights, first the nearest \(k\) neighbors are determined for each cell in the latent model. If a latent space is provided as the latent model (or if it is computed using PCA), then nearest neighbors are determined using euclidean distance. If a trajectory model is instead provided, neighbors are determined using the distance between cells along the trajectory. Weights are then computed by applying a Gaussian kernel to the distances between nearest neighbors such that higher weights are assigned to similar cells and the weight between distant cells is reduced to zero.
Finally, the autocorrelation statistic, C’ is computed as:
\[ C' = 1-\frac{ (N-1)\sum_i \sum_j w_{ij}(x_i-x_j)^2 }{ 2W\sum_i(x_i-\bar{x})^2 } \]
A permutation test using randomly-generated signatures (of similar size and positive-to-negative ratio) is used to assess the significance of these values. However, due to the large number of cells involved in modern single-cell experiments, it is fairly easy to reject the null hypothesis and so the authors also recommend ranking and filtering using the C’ values and not only the FDR rates (similar to how differential expression tests may be further filtered by the estimated log fold-change).
More details are available in our Biorxiv preprint.


EE241B Project - Approximate Compute for Mobile Ultrasound Systems
Karthik Gopalan, Josh Kay
Proposal
Midterm Report
Final Report
Slides
(
Download with Media
)


You Are Dead.
Do.. or do not. There is no try. Will you continue?
Congatulations!
You Win!!
Hey, this is Connor. Thank you for taking the time to play my game.
Score:
- Coins :
- Correct Answers :
- Continues used :
- Time :
Do.. or do not. There is no try. Will you continue?
Hey, this is Connor. Thank you for taking the time to play my game.


NASTOS VASILEIOS
STUDENT AT DEPARTMENT OF INFORMATICS AND TELECOMMUNICATIONS AT DEPARTMENT OF IOANNINA Interested at:Big Data,Gui Programming,WebPage Design,Bitcoin Mining,Data Analysis,Machine Learning
PROGRAMMING LANGUAGES
C
C++
JAVA
Python
Html
PROJECTS
Music Player
This is a music player project designed in Qt by Nastos Vasileios and Konstantinos Sakkas (Informatics and Telecommunications department located in Arta Greece).All Rights Reserved!!!
Music Player
With Music Player you can download your own songs - videos (.mp3, .mp4) and by integrating them in our application you will no longer need to look for them on your computer as they will be permanently stored in our application, with the PlayList we have the songs - videos change by themselves while pressing the button of the random order now everything plays in random order. All mp4 files are viewed directly through our application while then through PlayNow you are informed about which song is playing. Another advantage is that if you want to make a change to any of your files through the Directory it is immediately where your file is. Finally in About you can find the functionability of the keys for even easier use.
Try it now !!!
NOTE!!!In order to run the App please download LAV FILTERS 0.74.1->https://www.free-codecs.com/lav_filters_download.htm
Development Team:
Vassilis Nastos - Software Developer
Konstantinos Sakkas - Hardware Developer and Web Designer
Department of Informatics & Telecommunications - University of Ioannina (Arta)
Laboratory of Electronics and Telecommunications.
Cfg calculator
With the calculator you can do some basic calculations like adding,subtraction,dividing,multipling,find modulo of a number,find square of a number,using numbers like e which is number 2.71 and pi 3.1415.Also the results of every calculation stored in a second page board,and you can save them in a comma separated value file.
In order to install the calculator
Download the zip file
Extract it in a folder on your Desktop
Open the folder and run the .exe file,which is located inside the zip folder
Enjoy the App,hope you like it!!!!!
Development Team:
Vassilis Nastos - Software Developer
Konstantinos Sakkas - Hardware Developer and Web Designer
Department of Informatics & Telecommunications - University of Ioannina (Arta)
Laboratory of Electronics and Telecommunications.
Graph Coloring App
Algorithms Used
First Fit
DSatur
RLF
BackTracking DSatur
App used a sample file datasheet which is refered to an amount of exams and with algorithms we see the collisions between the exams and we schedule the exams properly based on the students needSee full release in:Graph_Coloring/Vasnatos
Development Team:
Vassilis Nastos - Software Developer
Department of Informatics & Telecommunications - University of Ioannina (Arta)
Laboratory of Electronics and Telecommunications.


Comparing Majors
Background
Footgolf is a new sport and there are a lot of things that are still being figured out. One such item is that courses aren’t rated like they are in golf. Rating requires a whole new level of experience that the sport just doesn’t have a whole lot of yet. Rating a course requires taking into account many different variables like slope, distance, obstacles, etc. You can read about it here from the PGA website. Footgolf is too new to have that, but it got me thinking. How uniform are major tournament courses? Are pars approximately the same distance? How does the field perform at these distances/pars?
I’ve only played in the US Open major this year and it was LONG, approximately 3700 yds! For some perspective, that’s about half the length of the average 18-hole golf course. But not all courses are created the same. The Capital Cup and French Open were 3200 and 2900 yds, respectively. Now understandably, not all courses have the same space and some are built more technically minded. I would encourage readers that have played these variety of courses to comment on their experiences. What’s your favorite type of course? Fast, long, technical? Why?
The Data
I’ve aggregated all scores from the top 100 players from each of the major tournaments from fgranks.com. The only exception is the Capital Cup. Only the top 90 players were examined because at the time the data was pulled players in positions greater than 90 received abnormally/artificially high strokes on hole 18. To avoid skewing the analysis I decided to exclude the players.
Analysis
We want to evaluate if there’s a significant difference in distance between pars at each major. These courses were setup independently and one courses distances doesn’t affect the another courses distances, so these are independent populations. To evaluate the distance means between courses we can use the unpaired t-test.
The unpaired t-test, however, assumes that the distribution of the populations is normal. So let’s first check to see if the distances are normally distributed at the courses. Our sample is tiny, so we’ll need to keep that in mind.
Are the distances normally distributed?
##
## Shapiro-Wilk normality test
##
## data: unique(filter(majors_scores, par == 3)$yds)
## W = 0.9477, p-value = 0.6037
##
## Shapiro-Wilk normality test
##
## data: unique(filter(majors_scores, par == 4)$yds)
## W = 0.9466, p-value = 0.1492
##
## Shapiro-Wilk normality test
##
## data: unique(filter(majors_scores, par == 5)$yds)
## W = 0.94476, p-value = 0.578
Our Shapiro-Wilks tests for each par indicate p-values larger than 0.05 (alpha) telling us that we cannot reject the null hypothesis of normal distribution. So our data do not fit the normal distribution.
##
## Welch Two Sample t-test
##
## data: unique(filter(majors_scores, par == 3)$yds) and unique(filter(majors_scores, par == 4)$yds)
## t = -9.4498, df = 33.16, p-value = 6.243e-11
## alternative hypothesis: true difference in means is not equal to 0
## 95 percent confidence interval:
## -113.90246 -73.55157
## sample estimates:
## mean of x mean of y
## 99.58333 193.31034
##
## Welch Two Sample t-test
##
## data: unique(filter(majors_scores, par == 3)$yds) and unique(filter(majors_scores, par == 5)$yds)
## t = -8.3748, df = 14.465, p-value = 6.336e-07
## alternative hypothesis: true difference in means is not equal to 0
## 95 percent confidence interval:
## -164.9710 -97.8623
## sample estimates:
## mean of x mean of y
## 99.58333 231.00000
##
## Welch Two Sample t-test
##
## data: unique(filter(majors_scores, par == 4)$yds) and unique(filter(majors_scores, par == 5)$yds)
## t = -2.3744, df = 15.51, p-value = 0.03086
## alternative hypothesis: true difference in means is not equal to 0
## 95 percent confidence interval:
## -71.426002 -3.953308
## sample estimates:
## mean of x mean of y
## 193.3103 231.0000
Are the major tournament pars and distances significantly different?
Mean distances (yards) per par
| tourney | par | mean.yds |
|---|---|---|
| capital cup | 3 | 110.2594 |
| capital cup | 4 | 179.2019 |
| capital cup | 5 | 237.3571 |
| french open | 3 | 82.0000 |
| french open | 4 | 185.4545 |
| french open | 5 | 178.6667 |
| us open | 3 | 106.5000 |
| us open | 4 | 220.2000 |
| us open | 5 | 264.0000 |


Create a Signature
Use one of the following ways to create your signature
Type
Upload
Draw
Upload
Clear


Verona councillors want legal action against Balotelli for defamation
MILAN: Verona's city government has been asked by a group of local councillors to take action against footballer Mario Balotelli after he complained about racist insults from the crowd during a match at the Bentegodi stadium on Sunday.
Balotelli, playing for visiting side Brescia, kicked the ball into the crowd and threatened to walk off the pitch early in the second half because he said some fans were making monkey noises. The referee stopped play for around five minutes while announcements were made to the crowd.
The 29-year-old, who was born in Sicily to Ghanaian parents and given up for adoption when he was three, has faced racist abuse throughout his career in Italy. He was backed by Napoli coach Carlo Ancelotti and by rival club AS Roma, among others, for his action on Sunday.
But the Verona club and the city's mayor Federico Sboarina, who said he was at the game, denied the racist insults took place.
On Tuesday, the Gazzetta dello Sport published a motion sent to the Verona council by four councillors proposing that "the mayor and the legal offices of the municipality should take legal action against the footballer and all those who attack Verona by unjustly defaming it."
The motion added: "It is no longer fair that Verona is put in the dock when, as in this case, nothing happened."
Serie A's disciplinary tribunal was due to announce its decision in the case - the latest in a long line of alleged racist incidents to mar Italian football - later on Tuesday.

The insults against Lukaku were judged by the tribunal to be too limited in terms of "real perception" for it to take action.
(Writing by Brian Homewood; Editing by Christian Radnedge)


Match Play. Red leads White 5-2 to 7. How should Red play 41?
pips Red=134 White=113
(CorrectAnswer= 0/0, ErrorScore= 0)
Red's position is parlous indeed but with the right play he will win nearly 24% of the time. Sadly he will lose a gammon nearly 39% of the time and 43% if he chooses the play made over the board, bar/24, 6/2.
Red can win by anchoring and hitting a late shot or he can win by counter-priming White. He can also win by creating a back game. Bar/24, 13/9 puts no pressure on White but bar/24, 8/4* does. Now Red can quickly build a prime or revert to the anchoring/back game plans if hit.
Anything other than bar/24, 8/4* is an error at best.
Red can win by anchoring and hitting a late shot or he can win by counter-priming White. He can also win by creating a back game. Bar/24, 13/9 puts no pressure on White but bar/24, 8/4* does. Now Red can quickly build a prime or revert to the anchoring/back game plans if hit.
Anything other than bar/24, 8/4* is an error at best.
1. Cubeful 2-ply 21/9 10/4(2) Eq.: +0.659 0.794 0.162 0.002 - 0.206 0.021 0.000 2. Cubeful 2-ply 21/9 13/7(2) Eq.: +0.524 (-0.135) 0.744 0.162 0.003 - 0.256 0.040 0.001 3. Cubeful 0-ply 21/9 8/2(2) Eq.: +0.477 (-0.182) 0.716 0.180 0.003 - 0.284 0.041 0.000 4. Cubeful 0-ply 13/7(2) 10/4(2) Eq.: +0.465 (-0.194) 0.688 0.254 0.006 - 0.312 0.062 0.003 5. Cubeful 0-ply 21/15 13/7(3) Eq.: +0.453 (-0.206) 0.707 0.186 0.004 - 0.293 0.050 0.001


{% extends './base.html' %} {% block title %}DynoSRC Benchmarks{% endblock %} {% block content %}
Test Navigation Timing events with and without DynoSRC.
Without DynoSRC
Test localStorage support.
localStorage Test


This tool allows you to view the days which you may volunteer at the North Texas Food Bank. We encourage you to choose the date with the lowest number of volunteers.
Click an empty date or a date with green to schedule your volunteer time.


Schools are responsible for your child’s safety while they’re at school or on a school trip.
Contact the school if you’re worried about your child’s health and safety. If you’re still concerned, tell the local council or the Health and Safety Executive ( HSE ).
Schools are responsible for day-to-day health and safety whenever your child is in the care of school staff - this includes school trips and clubs.
Every school has a health and safety policy. Ask the school if you want to read it. It should contain details of what the school is responsible for (eg school trips) as well as what they should do to look after your child.
Schools must follow the same health and safety law for indoor temperature as other workplaces.
There’s no legal limit to class size for health and safety reasons. To help raise standards in maintained schools, children between 5 and 7 have a maximum class size of 30.
Contact the HSE if there’s an accident or incident and you want advice about health and safety.
Who decides the health and safety policy and has ultimate responsibility for the health and safety of your child at school depends on the type of school.
The school must report serious accidents, outbreaks of disease or dangerous incidents to the HSE . If you want to check that the school has done this, contact the HSE .


trapezoid: The Trapezoidal Distribution
The trapezoid package provides dtrapezoid, ptrapezoid,
qtrapezoid, and rtrapezoid functions for the trapezoidal
distribution.
| Version: |
2.0-0 |
| Depends: |
R (≥ 2.12.0) |
| Suggests: |
ggplot2, plyr |
| Published: |
2012-12-28 |
| Author: |
Jeremy Thoms Hetzel [aut, cre] |
| Maintainer: |
Jeremy Thoms Hetzel <jthetzel at gmail.com> |
| License: |
GPL-3 |
| NeedsCompilation: |
yes |
| Materials: |
ChangeLog |
| In views: |
Distributions |
| CRAN checks: |
trapezoid results |
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=trapezoid
to link to this page.


This guide provides a brief overview of the basic components of a web-based VR application made with three.js.
First, you have to include [link:https://github.com/mrdoob/three.js/blob/master/examples/jsm/webxr/VRButton.js VRButton.js] into your project.
import { VRButton } from 'three/addons/webxr/VRButton.js';
*VRButton.createButton()* does two important things: It creates a button which indicates VR compatibility. Besides, it initiates a VR session if the user activates the button. The only thing you have to do is to add the following line of code to your app.
document.body.appendChild( VRButton.createButton( renderer ) );
Next, you have to tell your instance of `WebGLRenderer` to enable XR rendering.
renderer.xr.enabled = true;
Finally, you have to adjust your animation loop since we can't use our well known *window.requestAnimationFrame()* function. For VR projects we use [page:WebGLRenderer.setAnimationLoop setAnimationLoop]. The minimal code looks like this:
renderer.setAnimationLoop( function () {
renderer.render( scene, camera );
} );
Have a look at one of the official WebVR examples to see this workflow in action.
[example:webxr_vr_ballshooter WebXR / VR / ballshooter]
[example:webxr_vr_cubes WebXR / VR / cubes]
[example:webxr_vr_dragging WebXR / VR / dragging]
[example:webxr_vr_paint WebXR / VR / paint]
[example:webxr_vr_panorama_depth WebXR / VR / panorama_depth]
[example:webxr_vr_panorama WebXR / VR / panorama]
[example:webxr_vr_rollercoaster WebXR / VR / rollercoaster]
[example:webxr_vr_sandbox WebXR / VR / sandbox]
[example:webxr_vr_sculpt WebXR / VR / sculpt]
[example:webxr_vr_video WebXR / VR / video]


Funky dessert cafes are all the rage nowadays, and New York City is the best place to find the quirkiest ones. Sweet Moment, located in Manhattan’s Little Italy neighborhood, has latte art that is almost too cute to drink. Plus, these adorable drinks taste even better than they look!
Bibble & Sip has got to be one of the cutest shops in New York City. While trendy bakeries selling Asian-inspired desserts, coffees, and teas are not new to the scene, this one has a special twist — their “mascot” is an alpaca. Alpaca's decorate the walls, the baked goods, the coffees, and everything in between.
You may have seen this place on Facebook.  I'd definitely recommend bringing a friend and sharing a milkshake together as one is too much for any one person to finish, unless you're ambitious.
Broken Coconut is like a tropical oasis in the midst of the concrete jungle. All the decor is gorgeous and totally instagrammable – like the swing underneath the neon "Eat Pretty" sign, and the food is just as colorful and aesthetically pleasing.
This ice cream place is famous for their boozy ice cream, but they create quite spectacular ice cream designs as well! Gigantic, colorful, and crazy ice cream concoctions are abound at Tipsy Scoop – all of which are perfect for instagram.
This matcha place just recently opened up a few months ago, yet has been featured dozens of times on instagram already! Their gorgeous leafy wall design combined with vibrant matcha selections, a glowing neon wall sign, and even some gold leaf makes for stunning photos!


How to display feedback for a single category only using the Feedback Comments module. You may like to have a different Feedback Comments module to display feedback for each category or feedback for different categories as visible to different roles and users.
Tip: Categories are managed under Feedback Lists on the Feedback module.
Displaying Feedback for a Single Category


The following global variables are created and managed automatically by the [incr Tcl] library. Except where noted below, these variables should normally be treated as read-only by application-specific code and by users.
In vanilla Tcl/Tk, there is a single pool of commands, so the access command for a widget is the same as the window name. When a widget is created within a namespace, however, its access command is installed in that namespace, and should be accessed outside of the namespace using a qualified name. For example,
namespace foo { namespace bar { button .b -text "Testing" } } foo::bar::.b configure -background red pack .b
The "winfo command" command can be used to query the fully-qualified access command for any widget, so one can write:
[winfo command .b] configure -background red
bind Button <Key-Return> {%q flash; %q invoke}
The itcl::purist variable controls a backward-compatibility mode. By default, this variable is "0", and the window name can be used as an access command in any context. Whenever the unknown procedure stumbles across a widget name, it simply uses "winfo command" to determine the appropriate command name. If this variable is set to "1", this backward-compatibility mode is disabled. This gives better encapsulation, but using the window name as the access command may lead to "invalid command" errors.


Angular Rails App
Rails templates are powerful and give us an easy way to build a front end that integrates with our back end. However, Rails templates are also limited. They are largely static, meaning they are rendered by the controller before being sent as a response to the user. But that means a hard page reload in your browser, and that makes it more difficult to make applications that operate seamlessly like many modern websites such as Facebook or Twitter.
As seen in one of my past projects, we can use jQuery
to build a single-page application that makes requests asynchronously with AJAX
. However, it quickly gets complicated and hard to maintain, organize, and develop. There are many JavaScript front end frameworks that have risen over the last several years. For this project, I used Angular to build an application for uploading and sharing sketches.
Integrating Angular With Rails
Angular and Rails aren’t really designed to work together, so building an application integrating both requires some finagling. In order to get the functionality we want, we need to manage both front end and back end dependencies. Back end dependencies are easy to manage: we just use gems in our gemfile and install with bundle install
. However, front end dependencies are a bit trickier. There are many Angular related gems we could use, but there aren’t gems for everything. So instead, we can use Bower.
First, we install Bower by running npm install -g bower
. Then we isntall bower-rails gem through our gemfile. We specify our front end dependencies in a bower.json file. After that, we run rake bower:install
, and our dependencies will be installed (the default directory being vendor/assets/bower_components
). We then have to specify the dependencies in the javascript manifest file (app/assets/javascripts/application.js
) to incorporate them in the asset pipeline.
Another gem we can use is angular-rails-templates to incorporate our Angular templates into the Rails asset pipeline.
You can take a look at my Bower dependencies in my bower.json file here as well as the app.js file explaining them.
Rails Back End
The back end is set up similarly to my last jQuery project, so I won’t go into it in depth. There are several models including sketches and tags. The sketch model uses Paperclip to manage file attachments. It’s easy to set up file uploads for Paperclip with a Rails form, but with Angular we will have to set up a different solution - namely ngFileUpload.
We’ll enable AJAX
functionality by setting up Active Model Serializers for JSON
serialization of our models through our controller actions.
Authentication is handled with Devise. Like Paperclip, it’s easy to sign in and register with Devise Rails templates, however, we’ll again have to set up something different with Angular, using angular-devise.

Since this is a single page application, we have to handle routing for pages on the front end, and for this I used ui-router. Ui-router states are created in the application configuration, and I did so in the app.js file.
I tried to have some of the organization of the Angular part of the project mimic Rails and its RESTful conventions - such as having a sketches index page, a sketch show page, and reusing the sketch form for creation and updating. Each page has a controller associated with it to handle the unique functionality requirements.
In addition, I have a couple Angular components that act as partials used in repeaters. There’s an artist component displaying an artist’s name, information, and link to artist show page, as well as a similar component for sketches.
I put all the logic for actually communicating to the back end in various Angular services - such as SketchesService for creating and retrieving sketches, and TagsService for creating and retrieving tags. The services use $http to make GET, POST, PUT, and DELETE requests to interact with the back end models via AJAX
.
Overall, I found this to be a challenging project, not just due to the complexity of Angular itself, but also due to all the work required to get Angular and Rails to work effectively together.
You can see the source code for the project here on Github.


This website hosts a game which is written in JavaScript. If you wish to play the game, please enable JavaScript.


#include <limits.h>
#include <stdio.h>
#include <string.h>
#include "LinearMath/btAlignedAllocator.h"
Go to the source code of this file.
Classes | |
| class | btGenericMemoryPool |
| Generic Pool class. More... | |
| class | btGenericPoolAllocator |
| Generic Allocator with pools. More... |
Definition in file btGenericPoolAllocator.h.


Binary Puzzle 6x6
Welcome to the homepage! Here you will find links to every version of the puzzle :)
Link to V1.01
Link to V1.02
Link to V1.03
Link to V1.04
Link to V1.05
Link to V1.06
Link to V1.07
Link to V1.08
Link to V1.09
Link to V1.10
Link to V1.11


Introduction to ADL Launch
This example implements xAPI launch to share the LRS endpoint and actor at launch time. This solution can be used to eliminate hard coded credentials from your web app. The panel below will display information about the launch of this content.
Actor
LRS Endpoint:


Gecode::Int::GCC::Edge Class Reference
List of all members.Detailed Description
Class for edges in the variable-value-graph.
Definition at line 294 of file graphsup.icc.
Constructors | |
| Edge (VarNode *x, ValNode *v) | |
| Construct edge from variable node x and value node y. | |
| void * | operator new (size_t, void *) |
| Create a new edge in memory. | |
Access | |
| template<BC > | |
| bool | used (void) |
| return whether the edge is used | |
| template<BC > | |
| bool | matched (void) |
| return whether the edge is matched | |
| bool | is_deleted (void) |
| return whether the edge has been deleted from the graph | |
| Edge * | next (bool t) const |
| return a pointer to the next edge If t is false the function returns the next edge incident on x otherwise it returns the next edge incident on v | |
| Edge * | next (void) const |
| return the pointer to the next edge incident on x | |
| Edge * | prev (void) const |
| return the pointer to the previous edge incident on x | |
| Edge * | vnext (void) const |
| return the pointer to the next edge incident on v | |
| Edge * | vprev (void) const |
| return the pointer to the previous edge incident on v | |
| VarNode * | getVar (void) |
| return the pointer to the variable node x of this edge | |
| ValNode * | getVal (void) |
| return the pointer to the value node v of this edge | |
| VVGNode * | getMate (bool t) |
| return pointer to x if t = true otherwise return v | |
| template<BC > | |
| void | use (void) |
| Mark the edge as used. | |
| template<BC > | |
| void | free (void) |
| Mark the edge as unused. | |
| template<BC > | |
| void | reset (void) |
| Reset the edge ( free the edge, and unmatch the edge including its end-nodes. | |
| template<BC > | |
| void | match (void) |
| Match the edge. | |
| template<BC > | |
| void | unmatch (void) |
| Unmatch the edge and the incident nodes. | |
| template<BC > | |
| void | unmatch (bool t) |
| Unmatch the edge and ( x if t=false, v otherwise ). | |
| void | unlink (void) |
| Unlink the edge from the linked list of edges. | |
| void | del_edge (void) |
| Mark the edge as deleted during synchronization. | |
| void | insert_edge (void) |
| Insert the edge again. | |
| Edge ** | next_ref (void) |
| return the reference to the next edge incident on x | |
| Edge ** | prev_ref (void) |
| return the reference to the previous edge incident on x | |
| Edge ** | vnext_ref (void) |
| return the reference to the next edge incident on v | |
| Edge ** | vprev_ref (void) |
| return the reference to the previous edge incident on v |
Constructor & Destructor Documentation
|
|
Construct edge from variable node x and value node y.
Definition at line 1047 of file graphsup.icc. |
Member Function Documentation
|
|
Create a new edge in memory.
Definition at line 1055 of file graphsup.icc. |
|
|
return whether the edge is used An edge can be used in a matching on the graph, a path on the graph or a cycle in the graph. Definition at line 1089 of file graphsup.icc. |
|
|
return whether the edge is matched
Definition at line 1213 of file graphsup.icc. |
|
|
return whether the edge has been deleted from the graph
Definition at line 1233 of file graphsup.icc. |
|
|
return a pointer to the next edge If t is false the function returns the next edge incident on x otherwise it returns the next edge incident on v
Definition at line 1103 of file graphsup.icc. |
|
|
return the pointer to the next edge incident on x
Definition at line 1098 of file graphsup.icc. |
|
|
return the pointer to the previous edge incident on x
Definition at line 1122 of file graphsup.icc. |
|
|
return the pointer to the next edge incident on v
Definition at line 1112 of file graphsup.icc. |
|
|
return the pointer to the previous edge incident on v
Definition at line 1132 of file graphsup.icc. |
|
|
return the pointer to the variable node x of this edge
Definition at line 1146 of file graphsup.icc. |
|
|
return the pointer to the value node v of this edge
Definition at line 1152 of file graphsup.icc. |
|
|
return pointer to x if t = true otherwise return v
Definition at line 1158 of file graphsup.icc. |
|
|
Mark the edge as used.
Definition at line 1061 of file graphsup.icc. |
|
|
Mark the edge as unused. the failure is here, capacity is not increased for value nodes Definition at line 1071 of file graphsup.icc. |
|
|
Reset the edge ( free the edge, and unmatch the edge including its end-nodes.
Definition at line 1082 of file graphsup.icc. |
|
|
Match the edge.
Definition at line 1195 of file graphsup.icc. |
|
|
Unmatch the edge and the incident nodes.
Definition at line 1168 of file graphsup.icc. |
|
|
Unmatch the edge and ( x if t=false, v otherwise ).
Definition at line 1180 of file graphsup.icc. |
|
|
Unlink the edge from the linked list of edges.
Definition at line 996 of file graphsup.icc. |
|
|
Mark the edge as deleted during synchronization.
Definition at line 1222 of file graphsup.icc. |
|
|
Insert the edge again.
Definition at line 1227 of file graphsup.icc. |
|
|
return the reference to the next edge incident on x
Definition at line 1142 of file graphsup.icc. |
|
|
return the reference to the previous edge incident on x
Definition at line 1127 of file graphsup.icc. |
|
|
return the reference to the next edge incident on v
Definition at line 1117 of file graphsup.icc. |
|
|
return the reference to the previous edge incident on v
Definition at line 1137 of file graphsup.icc. |
The documentation for this class was generated from the following file:
- gecode/int/gcc/graphsup.icc (Revision: 3512)


About Me
Hi! I am Arnav Kansal. I am passionate about Machine Learning, high-performance systems and their applications in technology and finance. In the past I have worked on the Linux Kernel, Low Level HFT software, x86 Simulators, recommendation systems, NLP, Economics of a small cafe, etc. In general, I like to solve challenging, real life problems.
I am a software engineer at Google. I am currently working on various parts of an Operating System being build and maintained at Google Cloud. Learn more about it here. Previously I spent about 2 years at a startup (Uber Freight within Uber).
I have done a couple of internships as a software engineer working at the relatively lower level of abstractions in software and that is where my interest lies. I like exploring under the hood.
Interning at Citadel Securities in their Low Latency Technologies team I tasted modern C++(11/14/17) learning memory models, parallel programming, profiling applications/ functions at a very fine level of granularity using linux perf, and other hw level time stamp counters. It was over here that I was exposed to the high frequency trading world where people measure code in cpu cycles (nano seconds).
I have also worked on the scheduler subsystem of the linux kernel (Operating System) for the Andriod smartphone Samsung C7 at Samsung Electronics.
I did my graduate schooling at NYU, Courant School of Mathematical Sciences, where I am pursued a Masters in Computer Science, working with Professor Zahran on developing a self learning AI support for architecture which optimises tunables in the HW at runtime for any application. Read more about it here and here.
Before this, I graduated from Indian Institute of Technology Delhi in Electrical Engineering. Back in IIT, I worked with Prof. Jayadeva on various aspects of machine learning(ranking systems) and recommendation systems. My thesis from IITD.
More information on my projects can be found on my GitHub Page.
My really old resume can be found here and the current version is available on request.
My hobbies
I like to cook in my spare time. I am also learning to play an electric guitar. Currently I am listening to Tame Impala, Khruangbin, Jungle and a lot of new artists on KEXP. I like to play soccer and enjoy running.
I love coffee. My love for coffee flourished in Manhattan, probably because of the many cute little coffee shops I used to frequent there. Here are some nice places to get coffee while in the big apple.
Also, included are some brunch places I love!
I am always excited to know about the next generation video games and the latest gaming PCs that can be built to play them. I once successfully overclocked an Intel E8400 Dual Core to 4.0 Ghz from its base clock of 3.0 Ghz.


{% extends "global/Page.html" %} {% load otree %} {% block title %} Part 1 - Instructions {% endblock %} {% block content %} {% if player.treatment == "I" or player.treatment == "J" %}
For this part of the study, you will start with 10 points. You will be shown two images countaining dots. You will have five seconds to look at these images and then decide which image had the highest number of dots. At the end of the five seconds, you will be taken to a different screen. On this screen, you will select whether the image on the right or the picture on the left had more dots.
{% elif player.treatment == "K" or player.treatment == "L" %}For this part of the study, you will start with 1 point. You will be shown two images countaining dots. You will have five seconds to look at these images and then decide which image had the highest number of dots. At the end of the five seconds, you will be taken to a different screen. On this screen, you will select whether the image on the right or the picture on the left had more dots.
{% endif %}If you get the question right, you will receive 1 point. If you get the question wrong, you will lose 1 point.
You will repeat this process 30 times - 30 questions in total. You can only proceed to the second part of the study if, at the end of the 30th time, you maintain a balance of at least 1 point.
Once you have read and understood the instructions, please press "next" to proceed.
{% formfields %} {% next_button %} {% endblock %}


--- title: Only, by Kostas Karyotakis date: 2011-05-16 13:41:52.000000000 +03:00 categories: - art tags: - karyotakis - kostas karyotakis - only - poem - the night - translation status: publish type: post published: true meta: _edit_last: '600927' geo_latitude: '37.979180' geo_longitude: '23.716647' geo_accuracy: '4584' geo_address: "Αθήνα, Ελλάς" geo_public: '1' reddit: a:2:{s:5:"count";s:1:"0";s:4:"time";s:10:"1308145594";} _wpas_done_twitter: '1' _wpas_done_fb: '1' tagazine-media: a:7:{s:7:"primary";s:0:"";s:6:"images";a:0:{}s:6:"videos";a:0:{}s:11:"image_count";s:1:"0";s:6:"author";s:6:"600927";s:7:"blog_id";s:7:"5739772";s:9:"mod_stamp";s:19:"2011-05-16 13:51:34";} author: login: kouk email<EMAIL_ADDRESS>display_name: Konstantinos Koukopoulos first_name: '' last_name: '' excerpt: !ruby/object:Hpricot::Doc options: {} ---
[youtube=http://www.youtube.com/watch?v=cKPbQ7s65ng]
Oh, it all had to come about the way it came to be
That hopes and roses withered
That, like boats, the years left me
Left and faded awayThat, like we would part at night
So many friends forever were lost
The place where as a child I grew
One afternoon I left behindThe pretty, simple girls - oh loves! -
Life was to take away - dance whirl
Even the pain, once fragrant,
Was to bear barren upon me.All of it had to happen. Only the night
Wasn't to be so sweet
The stars there blinking like eyes
As if laughing at me.Nipenthi, 1921
translation of "Μόνο" by Kostas Karyotakis by Kostas Koukopoulos. Video by @iacovos_camchis. Music by Lena Platonos and singing by Savina Yannatou.


This article is part of the God object resolution series. To illustrate it, we use a running example through the whole series. So far, we dispatched the logics of the God object into new features, while keeping the state centralized in the God object. This article is about the dispatch of this state.
Each feature depends on the state of the God object instead of having its own. We want instead to have complete features to build on, in other words to extract the state into the relevant features.
In our running example, we have reached this state:
class EmployeeManager {
// Initial state
private int nextEmployeeId = 0;
private final Map<Integer, Employee> employees = new HashMap<>();
private final Map<Integer, Address> addresses = new HashMap<>();
private final Map<Integer, String> phoneNumbers = new HashMap<>();
private final Map<Integer, Double> salaries = new HashMap<>();
// New features building on it
private final Employer employer = new EmployerImpl(() -> ++nextEmployeeId, () -> employees);
private final EmployeeDetails details = new EmployeeDetailsImpl(() -> addresses, () -> phoneNumbers, () -> employees);
private final SalarySettings salarySettings = new SalarySettingsImpl(() -> salaries);
...
}
At this point, we can identify which parts of the state should go to which features.
The most trivial case is the salaries
map, which is only used by the salariesSettings
feature.
For this kind of trivial case, we can simply move the map of the God class into the new feature.
As a reminder, the current SalarySettingsImpl
class is the following:
class SalarySettingsImpl implements SalarySettings {
private final Supplier<Map<Integer, Double>> salariesMap;
public SalarySettingsImpl(Supplier<Map<Integer, Double>> salariesMap) {
this.salariesMap = salariesMap;
}
/** Change the salary of the given {@link Employee}. */
public void setSalary(int employeeID, double salary) {
salariesMap.get().put(employeeID, salary);
}
/** Return the salary of the given {@link Employee}. */
public double getSalary(int employeeID) {
return salariesMap.get().get(employeeID);
}
/** Raise the salary of the given {@link Employee}. */
public void raiseSalary(int employeeID, double amount) {
Map<Integer, Double> salaries = salariesMap.get();
salaries.put(employeeID, salaries.get(employeeID) + amount);
}
}
We now replace the salariesMap
supplier by the actual salaries
map:
class SalarySettingsImpl implements SalarySettings {
private final Map<Integer, Double> salaries = new HashMap<>();
// No parametered constructor needed anymore, we only use the default constructor.
/** Change the salary of the given {@link Employee}. */
public void setSalary(int employeeID, double salary) {
salaries.put(employeeID, salary);
}
/** Return the salary of the given {@link Employee}. */
public double getSalary(int employeeID) {
return salaries.get(employeeID);
}
/** Raise the salary of the given {@link Employee}. */
public void raiseSalary(int employeeID, double amount) {
salaries.put(employeeID, salaries.get(employeeID) + amount);
}
}
This modification allows us to simplify the God object:
class EmployeeManager {
// Initial state
private int nextEmployeeId = 0;
private final Map<Integer, Employee> employees = new HashMap<>();
private final Map<Integer, Address> addresses = new HashMap<>();
private final Map<Integer, String> phoneNumbers = new HashMap<>();
// No salaries map anymore
// New features building on it
private final Employer employer = new EmployerImpl(() -> ++nextEmployeeId, () -> employees);
private final EmployeeDetails details = new EmployeeDetailsImpl(() -> addresses, () -> phoneNumbers, () -> employees);
private final SalarySettings salarySettings = new SalarySettingsImpl(/*no param anymore*/);
...
}
Now, the SalarySettingsImpl
class is complete: it integrates both the logics and its related state.
When we created this class, we didn't spend much time on its naming because our objective was to move all the existing code to implement the feature.
Now that we have all of it, we can think better about the specifics of this class (relatively to its interface) to rename it.
In our case, we could rename it MemoryBasedSalarySettings
because it stores the information in local memory.
We could rename it MapBasedSalarySettings
to be more specific regarding the kind of memory storage (we could use other structures in other implementations).
We could use yet again other naming conventions based on what seems the most relevant for the situation at hand.
Although the naming of the class is out of scope regarding the God object issue, this is the right time to think about it.
After moving the salaries
map into its feature, we can look for the other fields of the God class.
addresses
and phoneNumbers
are also used by a single feature: EmployeeDetailsImpl
.
Like salaries
, we can move them directly into the feature:
class EmployeeManager {
// Initial state
private int nextEmployeeId = 0;
private final Map<Integer, Employee> employees = new HashMap<>();
// No addresses map anymore
// No phoneNumbers map anymore
// New features building on it
private final Employer employer = new EmployerImpl(() -> ++nextEmployeeId, () -> employees);
private final EmployeeDetails details = new EmployeeDetailsImpl(/*two params removed*/ () -> employees);
private final SalarySettings salarySettings = new SalarySettingsImpl();
...
}
class EmployeeDetailsImpl implements EmployeeDetails {
private final Map<Integer, Address> addresses = new HashMap<>();
private final Map<Integer, String> phoneNumbers = new HashMap<>();
private final Supplier<Map<Integer, Employee>> contractsMap;
public EmployeeDetailsImpl(Supplier<Map<Integer, Employee>> contractsMap) {
// No supplier for addresses anymore
// No supplier for phone numbers anymore
this.contractsMap = contractsMap;
}
/** Return the {@link Address} of the given {@link Employee}. */
public Address getAddress(int employeeID) {
return addresses.get(employeeID);
}
/** Change the {@link Address} of the given {@link Employee}. */
public void setAddress(int employeeID, Address address) {
addresses.put(employeeID, address);
}
/** Return the phone number of the given {@link Employee}. */
public String getPhoneNumber(int employeeID) {
return phoneNumbers.get(employeeID);
}
/** Change the phone number of the given {@link Employee}. */
public void setPhoneNumber(int employeeID, String phoneNumber) {
phoneNumbers.put(employeeID, phoneNumber);
}
/**
* Replace the {@link Employee}'s contractual details and returns the previous
* version.
*/
public Employee setContract(int employeeID, Employee employee) {
return contractsMap.get().put(employeeID, employee);
}
/** Return the {@link Employee}'s contractual details. */
public Employee getContract(int employeeID) {
return contractsMap.get().get(employeeID);
}
}
Notice we remain with the contractMap
supplier.
In the God class, this parameter is filled with the emploees
field.
This field is shared between several features: EmployerImpl
and EmployeeDetailsImpl
.
Consequently, we cannot simply move it in the features, because we would break the integrity of the data.
You may face a case where the shared object is itself a God object, in which case you should refactor it like we refactor EmployeeManager
, but it can be postponed until EmployeeManager
is done.
If we use it as a genuine shared state, features depending on it should receive it as an external dependency, through their constructor or a setter.
EmployeeDetailsImpl
can thus be refactored like this:
class EmployeeManager {
// Initial state
private int nextEmployeeId = 0;
private final Map employees = new HashMap<>();
// New features building on it
private final Employer employer = new EmployerImpl(() -> ++nextEmployeeId, () -> employees);
private final EmployeeDetails details = new EmployeeDetailsImpl(employees);
private final SalarySettings salarySettings = new SalarySettingsImpl();
...
}
class EmployeeDetailsImpl implements EmployeeDetails {
private final Map<Integer, Address> addresses = new HashMap<>();
private final Map<Integer, String> phoneNumbers = new HashMap<>();
private final Map<Integer, Employee> contracts;
public EmployeeDetailsImpl(Map<Integer, Employee> contracts) {
this.contracts = contracts;
}
...
/**
* Replace the {@link Employee}'s contractual details and returns the previous
* version.
*/
public Employee setContract(int employeeID, Employee employee) {
return contracts.put(employeeID, employee);
}
/** Return the {@link Employee}'s contractual details. */
public Employee getContract(int employeeID) {
return contracts.get(employeeID);
}
}
It means that the state of EmployeeDetailsImpl
is partially shared: while it contains the addresses and phone numbers, the details about the contracts are stored elsewhere.
If such a design is not wanted, it can be refactored later based on your own requirements, but such a refactoring goes out of our scope.
This observation also applies to EmployerImpl
, which also builds on it and can be refactored the same way:
class EmployeeManager {
// Initial state
private int nextEmployeeId = 0;
private final Map<Integer, Employee> employees = new HashMap<>();
// New features building on it
private final Employer employer = new EmployerImpl(() -> ++nextEmployeeId, employees);
private final EmployeeDetails details = new EmployeeDetailsImpl(employees);
private final SalarySettings salarySettings = new SalarySettingsImpl();
...
}
class EmployerImpl implements Employer {
private final Supplier<Integer> newEmployeeID;
private final Map<Integer, Employee> employees;
public EmployerImpl(Supplier<Integer> newEmployeeID, Map<Integer, Employee> employees) {
this.newEmployeeID = newEmployeeID;
this.employees = employees;
}
/** Add a new {@link Employee} and returns its ID. */
public int hireEmployee(Employee employee) {
int employeeId = newEmployeeID.get();
employees.put(employeeId, employee);
return employeeId;
}
/** Fire an {@link Employee} and returns its ID. */
public Employee fireEmployee(int employeeID) {
return employees.remove(employeeID);
}
}
Notice that, although we named it contracts
in EmployeeDetailsImpl
, we still call it employees
here.
This is because the expected usage is not the same, and because EmployeeDetailsImpl
may require further refactoring to deal with Contract
instances.
The decisions taken for EmployeeDetailsImpl
remain independent of the oens taken for EmployerImpl
, which has its own purpose.
The last piece of the God object state is nextEmployeeId
, which is only required by EmployerImpl
.
Like the previous trivial cases, it means that we can move it to the feature.
Notice that it is not just a field, but also an associated processing (incrementation).
We should move both of them inside the feature:
class EmployeeManager {
// Initial state
// No nextEmployeeID anymore
private final Map<Integer, Employee> employees = new HashMap<>();
// New features building on it
private final Employer employer = new EmployerImpl(/*one parameter less*/ employees);
private final EmployeeDetails details = new EmployeeDetailsImpl(employees);
private final SalarySettings salarySettings = new SalarySettingsImpl();
...
}
class EmployerImpl implements Employer {
private int nextEmployeeId = 0;
private final Map<Integer, Employee> employees;
public EmployerImpl(Map<Integer, Employee> employees) {
// No employeeID supplier anymore
this.employees = employees;
}
/** Add a new {@link Employee} and returns its ID. */
public int hireEmployee(Employee employee) {
int employeeId = ++nextEmployeeId;
employees.put(employeeId, employee);
return employeeId;
}
/** Fire an {@link Employee} and returns its ID. */
public Employee fireEmployee(int employeeID) {
return employees.remove(employeeID);
}
}
With this last refactoring, we have now dispatched all the state of the God object. Only the state shared between several features should remain at this point, since it cannot be dispatched to a single feature. The God class now looks like a façade but is still bound to all its dependencies, since it implements them and stores their shared state. But before to dig in that matter, we should take a detour to the tests. Indeed, the tests of the God object are actually the tests of the features, so we must dipatch these tests before to consider the features as done.


Problem : Updates and Queries | Time limit: 0.03secs | Memory: 2MB | Submit code
Given three positive integers 'n','u','s' The next 'u' lines of the input contains two integers 'a' and 'b' seperated by a single space. Coming to explanation of the prolem, assume an array of size 'n' in which each of its elements is initialised to 1.
For each 'a' and 'b' given, increment the elements of the array from indexed 'a' to 'b' inclusively.
Finally after 'u' updates output the sum of the array till the index 's'(inclusively).
Constraints:
n<=100 , u<=10, s<=br
<99>
Input:
First line of input contains three positive integers 'n','u','s'.
Each of the 'u' lines contain two single space seperated integers 'a' and 'b'.
Output:
After 'u' operations, output the sum of the array till the index 's' (inclusively).
10 3 7
1 3
2 6
5 8
Sample Output:
19


Reports on any duplicate conditions among different branches of an
if statement. While it may rarely be the
desired semantics, duplicate conditions usually represent programmer oversight.
Use the checkbox below to let this inspection ignore conditions containing method calls. Some method calls may return a different value
on an identical invocation.


--- layout: contact title: Contact permalink: /contact/ ---
Find some issues? Have some suggestions? Maybe even want to help? Please reach out.
Report bugs and enhancement requests in the GitHub issue trackers.
JUniversal issues (for language translator + build plugins):
New issue (translator)
JSimple issues (for JSimple library):
New issue (library)
Especially at first we're looking to support folks directly as you try out JUniversal and run into the inevitable (at this stage) questions and issues. That's to help you minimize frustration and help us get the best feedback, so we can turn around fixes quickly.
So if you're giving it a whirl for your code, feel free to reach out directly via the contact mechnisms on the right for help.
Reach out directly for interactive support.
It'll help us both.
Short, sweet and public:
Tweet to @bretajohnson
Interactive chat, when that's best:
The old standbys:
Email:
Tel: {{ site.tel }}
{% for line in site.address.first.lines %}
{{ line }}
{% endfor %}


Social
Shortform
Interactive
VR
Twitter
Vimeo
BBC Digital Storytelling Team
Video not supported.
Home: VR Spacewalk Experience
Body Hack
Which Shakespeare Character are You?


--- layout: post title: Funeral Cookies post_id: 287 categories: - life date: 2004-03-30 14:16:00.000000000 -07:00 author: Jamis permalink: 2004/3/30/funeral-cookies.html ---
Why did this strike me as funny?
I’m the webelos leader for our local cub scout pack (sponsored by our ward—which is just what we call a congregation of members of the LDS Church). Tonight we had a pack meeting, and after all was said and done, cookies were served for the snack. Soft, store-bought sugar cookies, with a thick layer of bright pink, white, and blue frosting, with sprinkles on them. Very festive.
We didn’t have a very good turn out at the meeting, so there were lots of cookies left over. Our Bishop (the title given to a leader of an LDS congregation) was asked what could be done with the leftovers, and after thinking a moment he offered to take them and use them at a funeral that was going to be held in the next couple of days…
So. Anyone else find that vaguely humorous? And if so, why? Is it because of the thought of sugar cookies at a funeral (and these are not exactly somber-looking cookies), or is it the thought of reusing leftover cookies from a scouting activity at a funeral?
Anyway, it give Tarasine and me a chuckle this evening.


A component is a combination of basic elements. It is combined with other components to create a web page. For example, this page makes use of header, navigation, and footer components.
Each component should be self-contained and reusable.


Black bicycle parked beside brown wooden shelf
Kitty wants food
Woman in blue dress standing near window
Github


getting-started.Rmd
Slurm Work Manager (formerly Simple Linux Utility for Resource Manager),
Some important definitions
--partition
).--account
)sbatch
, salloc
, or srun
.--cpus-per-task
, --
)https://slurm.schedmd.com/cpu_management.html
Unless overcommitment of CPUs to tasks is specified for the job, the number of tasks distributed to a node is constrained by the number of CPUs allocated on the node and the number of CPUs per task – Slurm CPU Management
sluRrm
packageJust like rslurm
, sluRm
has two levels of job distribution: Slurm Jobs (via the Slurm_lapply
and Slurm_Map
functions), and within each job via parallel::mclapply
and parallel::mcMap
(task forking).
In general, the function Slurm_*
is implemented as follows:
List whatever R packages are loaded, including the path to the R package.
List all the objects passed via elipsis (...
), and, together with X
and FUN
or f
, save them at [job_path]/[job_name]/
as [object-name].rds
.
Write out the corresponding R script and Slurm bash file, and save them as [job_path]/[job_name]/00-rscript.r
, and [job_path]/[job_name]/01-bash.sh
respectively.
If submit = TRUE
(the default), the job will be submitted to the queue, which implies that Slurm_lapply
will call sbatch()
. Then return.
Once sbatch()
is called, a Job Array will be submitted in which each R job will lunch up to mc.cores
forked processes (2nd layer of parallelization)
Users can collect their results using the function Slurm_collect
.
We would like to implement a simulation algorithm to be run in a cluster. In this case, we have the very simple function we would like to parallelize:
This simple function generates Pi. Using parallel::mclapply
, we could just type
But there’s another way, using Slurm_lapply
, we can write
## On load, `sluRm` sets default options for your jobs (`chdir`, which is the default directory where sluRm will use to create the auxiliar files, and `job-name`, which is the option of the same name in Slurm. You can view/set these at:
## ?opts_sluRm
## or you could just type
## "opts_sluRm".
# Setting required parameters
opts_sluRm$set_chdir(tempdir())
opts_sluRm$set_job_name("test1")
# Optional parameters are set via set_opts
opts_sluRm$set_opts(partition="conti", account="lc_dvc")
# We can look at the setup
opts_sluRm
## Current default for Slurm jobs:
##
## List of 4
## $ partition: chr "conti"
## $ chdir : chr "/tmp/Rtmpn2oYwh"
## $ account : chr "lc_dvc"
## $ job-name : chr "test1"
##
## To get and set options for Slurm jobs creation use (see ?opts_sluRm):
##
## debug_off : function ()
## debug_on : function ()
## get_chdir : function ()
## get_cmd : function ()
## get_debug : function ()
## get_job_name : function (check = TRUE)
## get_opts : function (...)
## get_verbose : function ()
## set_chdir : function (path, recursive = TRUE, overwrite = FALSE)
## set_job_name : function (path, check = TRUE, overwrite = TRUE)
## set_opts : function (...)
## verbose_off : function ()
## verbose_on : function ()
sbatch_opt
Options to sbatch
can be passed via sbatch_opt
as a list. For example, the following
Advices Slurm to allocate 4G of memory per task, set a maximum time limit of 12 hours, and specify that you will be running 10 tasks per job.
A comprehensive list of options can be found here.
Extract from the FAQs at the Slurm website:
30. Slurm documentation refers to CPUs, cores and threads. What exactly is considered a CPU? If your nodes are configured with hyperthreading, then a CPU is equivalent to a hyperthread. Otherwise a CPU is equivalent to a core. You can determine if your nodes have more than one thread per core using the command “scontrol show node” and looking at the values of “ThreadsPerCore”.
Note that even on systems with hyperthreading enabled, the resources will generally be allocated to jobs at the level of a core (see NOTE below). Two different jobs will not share a core except through the use of a partition OverSubscribe configuration parameter. For example, a job requesting resources for three tasks on a node with ThreadsPerCore=2 will be allocated two full cores. Note that Slurm commands contain a multitude of options to control resource allocation with respect to base boards, sockets, cores and threads. — FAQ #30


Proton Swift Wallet SDK ( BETA v0.5.0 ) 🚧
Important: This library is currently under heavy development. Please be aware that all functionality is subject to change at anytime. Documention and examples are also being worked on and will be added over time as well.
Description
Proton is a drop in library to handle all things ProtonChain. This includes but is not limited to accout management and storage, signing and pushing transctions, etc.
- [x] Swift 5
- [x] iOS v13+
- [x] macOS v10_15+
- [x] Mac Catalyst
- [x] Persist and manage Proton Accounts
- [x] Persist and manage private keys via keychain
- [x] Signing transactions
- [x] Handle ESR Signing requests ( In progress ) 🚧
Functional Reference
https://protonprotocol.github.io/ProtonSwift
Usage
The main class that you will need to interface with is Proton
which encapsulates most all of the needed functions. Firstly you import Proton
. Initialize Proton
by passing a Proton.Config
struct. You’ll want to also call Proton.shared.fetchRequirements
function at startup so that all needed requirements for the library will be present before moving forward.
import Proton
Proton.initialize(Proton.Config()).updateDataRequirements { result in
Proton.shared.updateAccount { result in }
}
There are currently 2 environment enum values that can be used which live on the Proton.Config
object.
public enum Environment: String {
case testnet = "https://api-dev.protonchain.com"
case mainnet = "https://api.protonchain.com"
}
As seen above, most of the function closures provided by the library will return swift’s Result
type.
This library requires the user to authenticate via FaceId, TouchId, or phone passcode fallback when signing transactions. This is because that private key is stored in the keychain using the user presense flag.
You’ll need to add the following to your app’s Info.plist file.
<key>NSFaceIDUsageDescription</key>
<string>$(PRODUCT_NAME) Authentication with TouchId or FaceID</string>
Find and Import an account
When importing and account using a private key, its important to note that sometimes a private key may have more than 1 account associated with it. For that reason we will call the findAccounts
function to get an unattached list of Account
structs associated with the public key that was extracted from the private key wif.
Proton.shared.findAccounts(forPrivateKey: "<wif_formatted_private_key_here>") { result in
switch result {
case .success(let accounts):
if let account = accounts.first {
Proton.shared.setAccount(withName: account.name.stringValue, andPrivateKey: Proton.PrivateKey("<wif_formatted_private_key_here>")) { result in
if case .success = result {
print("YAH")
} else if case .failure(let error) = result {
print(error.localizedDescription)
}
}
}
case .failure(let error):
print(error)
}
}
The
Proton
library only stores oneAccount
struct at a time. Using thestorePrivateKey
orsetAccount
functions will overwrite the the current activeAccount
if there is already one. It will however NOT remove the private key from the keychain. That operation will have to be done seperately.
Now that you have an active Account
stored, you can access it at Proton.shared.account
Update active account
You can easily fetch the latest actions and other updates about your active account by simply calling Proton.shared.updateAccount
Proton.shared.updateAccount { result in }
This will fetch the lates
TokenTransferAction
items,Account
info, etc. It will automatically update these on the sharedProton
singleton.
Transfer token
Transfering a token is a fairly simple process. You’ll the need to grab the TokenContract
struct of the token you will be transfering. This can be fetched from Proton.shared.tokenContracts
.
guard let xprTokenContract = Proton.shared.tokenContracts.first(where: { $0.contract.stringValue == "eosio.token" && $0.symbol.name == "XPR" }) else {
return
}
Proton.shared.transfer(to: Proton.Name("blah"), quantity: 1.0, tokenContract: xprTokenContract, memo: "My first transfer") { result in
switch result {
case .success(let transferTokenAction):
break
case .failure(let error):
print(error)
}
}
Its important to note that this function will require the user to authenticate via FaceId, TouchId, or phone passcode fallback. This is because that private key is stored in the keychain using the user presense flag. Also make sure you have added the following to your Info.plist file.
<key>NSFaceIDUsageDescription</key> <string>$(PRODUCT_NAME) Authentication with TouchId or FaceID</string>
Get PrivateKey from keychain
You can fetch the private key stored for an Account
by calling the member function privateKey(forPermissionName: String)
. You will mostly be dealing with active permission keys.
guard let account = Proton.shared.account else {
return
}
guard let privateKey = account.privateKey(forPermissionName: "active") else {
return
}
Other functions to note
Proton.shared.loadAll()
Used to load all saved data objects from disk. This is called during the
Proton
init phase. You may however want to call this for instance when your app goes comes back from the background.
Proton.shared.saveAll()
Used to save all data objects to disk that are currently in memory on the
Proton.shared
singleton. This is called at the completion ofProton.shared.updateAccount
. You may however want to call this for instance when your app goes in the background.
Proton.shared.generatePrivateKey()
This can be used to generate a new private key. This is useful if you want to use the Proton API to create an account as you would use this key to extract the public key’s needed for account creation. FYI. The account creation API requires an API key which you will need to register for. The account creation API is heavily rate limited. If you are a wallet provider and need a more liberal rate limit you will have to contact us.
A function reference has been generated from the commented code.
Vote for Block Producer
Coming soon…
Stake XPR Tokens
Coming soon…
Unstake XPR Tokens
Coming soon…
Claim Staking Rewards
Coming soon…
Handling ESR requests
Coming soon…
Installation
SPM
Proton is available through Swift Package Manager. Add Proton as a dependency to your Package.swift. For more information, please see the Swift Package Manager documentation.
.package(url: "https://github.com/ProtonProtocol/ProtonSwift.git", .branch("master"))
Cocoapods
Coming soon…
Libraries Used
WebOperations - Proton
EOSIO - Greymass
KeychainAccess - kishikawakatsumi
MIT License
Copyright © 2020 Proton Chain LLC, Delaware
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


Simple user picker
ng-model:
{{ firstModel.selected }}
An enhanced version of the original luid-user-picker, based on the luid-select directive.
ng-model
: the selected user. If you are using the luid-user-picker-multiple
directive, the ng-model is an array which contains the selected users.on-select
: function which will be called when an item is selected (default: nothing)on-remove
: function which will be called when an item is removed (multi-select or emptying the input) (default: nothing)control-disabled
: boolean indicating if you want the control to be disabled (default: false)allow-clear
: boolean indicating if you can clear the current value (default: false)show-former-employees
: boolean indicating if you want to fetch former employees or not (default: false)homonyms-properties
: list of properties you want to display in case of homonymscustom-filter
: function that filters users. For a given user, it returns if he should be kept in the set of results or not. This function should respect the following signature: function(user){ return boolean; }
app-id
: the set of results should have access to the application matching this idoperations
: list of operations that the set of results should support for the given applicationcustom-info
: function that will return the information to display next to each user. It should respect the following signature : function(user) { return string; }
custom-info-async
: Same idea than custom-info
, except that the information is fetched asynchronously. It has to be a function with the following signature: function(user) { return promise; }
display-me-first
: boolean indicating if you want to display the connected user as first result if he belongs to the set of resultsdisplay-all-users
: boolean used to force the directive to disable paging and display all the users (default: false)bypass-operations-for
: list of user ids to display even if they does not have
access to operations in operations
attribute. Warning: if the current user can't see one of the users, it will not be displayed and a 404 error will occur
ng-model:
{{ firstModel.selected }}
ng-model:
{{ users.selected }}


--- layout: post title: Lean and Agile Development, The Big Picture categories: - Articles tags: - Lean, Agile, Software Development status: publish type: post published: true meta: _publicize_pending: '1' author: ---
Lean and Agile Development has been around for many years now and numerous practices have evolved around various phases of software development. There has been a proliferation of consulting services around agile and lean. Fortunately or unfortunately, not many methodologies have evolved - apart from XP and Scrum.
Most articles or books on Agile development start with a reference to the Agile Manifesto as a precursor to the practices followed. But to obtain a better understanding why agile practices are followed, we need to understand why individuals and interactions are valued over processes and tools, why working software is preferred over comprehensive documentation, why responding to change is more important than following a plan and why customer collaboration is considered paramount.
It is common sense that businesses exist to maximize profit, but what is uncommon about some of the software methods of the past (Six Sigma, ISO 9000) is how following those would result in better business profitability. ISO and Six-Sigma touted that improving quality and reducing defects would result in better customer satisfaction and higher profit. But a defect-free product that arrived years late does not improve profit.
Lean thinking and TPS is adopted to make sure products are delivered with reduced cycle times, but the base metrics are derived from the time-cost-quality triangle and optimizing one usually results in sub-par performance in another. To run an optimum business, we need a metric that follows the principle of optimal-substructure, that can be applied to all sub-components of the business and optimizing this metric in each area should help us optimize the metric for the whole business.
It is a fundamental fact that 'asymmetric information' leads to profitability. Insider trading in stocks, counting in card games, testing in drug research, A/B testing of web products, price comparison in online shopping, and many more such instances try to improve our ability to have better information and ultimately profit from it. Better information results in better decision making and higher profit. Information that is available to us much before it is available to the rest of the world can be considered asymmetric and enhances competitive advantage. In the software development process, the 'product' or outcome of various activities is in fact information in various forms - requirement documents, design documents, code, test specifications, reports, and so on. In the context of a business unit developing software one can think of better information delivered faster to the customer as an optimal metric that can be used to measure each individual activity We can call this metric Information Rate.
When we think of the software development process as an entire system, the best form of information one can deliver to the customer is actual working software. During the process of developing working software (information), there may be opportunities to improve the quality of this information by continuously interacting (customer collaboration) with the customer. If the customer thinks there is better opportunity for generating better information by introducing new inputs, one must respond to changes. We can now understand how meaningless it would be to deliver information that is outdated (working software that requires change). Lastly delivering software requires a set of steps where information is handed over by individuals from one step to next. For each such step, the individuals from the previous step act as customers and hence to improve customer collaboration, one needs to improve on individuals and interactions.
One can thus see how the principles of the agile manifesto directly lead to the generation of better, faster asymmetric information and has a direct impact on business profitability. This informational view of software is a paradigm shift in the way we approach software quality. It is no more necessary for working software in production to be perfect from day one, what is more important is for the software to be usable and functional, and most importantly to deliver the best information of how it needs to change to meet future requirements !!


Upload
View Students
Edit/Re-assign Students
Sign Out
Admin page (Spring Security protected)
Hello [[${#httpServletRequest.remoteUser}]]!